macaw_framework 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46f8af6ed22b7980942f7ec3def269395d1e65e9c7bfd06a96d161c31666997d
-  data.tar.gz: 258e71f4b693c410c325e7a7751f8a2702e3b2db814752d0de39566fa1b94576
+  metadata.gz: d900a18480da4792dfa03608ca8c85c0d0ba4084a3430c39008f4ca026ae784c
+  data.tar.gz: e3bc35f7b78bc0a6e995c0abd906879dda434e4c12306d3d55713c35dc45065c
 SHA512:
-  metadata.gz: cc2b8fbd4d25b795df95a47025b7465b3cfb6bd340008bebdfe527232a009bad959e25f9c4528b7eb4ce98f14f6148a47dd44e56b19b4d4c23187a2b4a24b56c
-  data.tar.gz: 0d0f265ea93a3467718cbccd2ed93d85d0d98f9c84e53a821d3071b20243ca251e7670a788bd6e848f6381cee213c16ee8164dd27a32a2a28b77de5979a23326
+  metadata.gz: 6ac4eb646bb2510fbc67ddec9ccfca45bea8dfcb6833f9e55b60f0f18d5edebaf392645c53dae7745eec797c926af1700c273516682bd6f10e66c2b018f1cea6
+  data.tar.gz: 0ecb2e16a9f1762833751bb403d824e04571c4f3b79f01355ffb6f1f29eb29c234befc759c7d76d7b939f05d5f9f3c252d8a5828198e9c7674b7854fe2edcdf1

data/.rubocop.yml

@@ -17,3 +17,6 @@ Metrics/MethodLength:
 
 Metrics/AbcSize:
   Max: 35
+
+Metrics/CyclomaticComplexity:
+  Max: 10

data/CHANGELOG.md

@@ -18,3 +18,9 @@
 ## [0.1.3] - 2022-12-13
 
 - Adding logger gem to Macaw class to fix a bug on the application start
+
+## [0.1.4] - 2023-04-09
+
+- Adding log by aspect on endpoint calls to improve observability
+- Moving the server for a new separate class to respect single responsibility
+- Improved the data filtering middleware to sanitize inputs

data/Gemfile

@@ -10,3 +10,5 @@ gem "rake", "~> 13.0"
 gem "minitest", "~> 5.0"
 
 gem "rubocop", "~> 1.21"
+
+gem "simplecov", "~> 0.22.0"

data/README.md

@@ -1,7 +1,10 @@
 # MacawFramework
 
+<img src="macaw_logo.png" alt= “” style="width: 30%;height: 30%;margin-left: 35%">
+
 This is a framework for developing web applications. Please have in mind that this is still a work in progress and
-it is strongly advised to not use it for production purposes for now. Anyone who wishes to contribute is welcome.
+it is strongly advised to not use it for production purposes for now. Actualy it supports only HTTP. HTTPS and SSL
+support will be implemented soon. Anyone who wishes to contribute is welcome.
 
 ## Installation
 
@@ -24,7 +27,9 @@ in the same directory of the script that will start the application with the fol
 ```json
 {
   "macaw": {
-    "port": 80
+    "port": 8080,
+    "bind": "localhost",
+    "threads": 10
   }
 }
 ```
@@ -37,7 +42,10 @@ require 'json'
 
 m = MacawFramework::Macaw.new
 
-m.get('/hello_world') do |headers, body, parameters|
+m.get('/hello_world') do |context|
+  context[:body] # Returns the request body as string
+  context[:params] # Returns query parameters and path variables as a hash
+  context[:headers] # Returns headers as a hash
   return JSON.pretty_generate({ hello_message: 'Hello World!' }), 200
 end
 

data/lib/macaw_framework/aspects/logging_aspect.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "logger"
+
+##
+# This Aspect is responsible for logging
+# the input and output of every endpoint called
+# in the framework.
+module LoggingAspect
+  def call_endpoint(logger, *args)
+    logger.info("Input of #{args[0]}: #{args}")
+    response = super(*args)
+    logger.info("Output of #{args[0]} #{response}")
+    response
+  end
+end

data/lib/macaw_framework/middlewares/request_data_filtering.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "../errors/endpoint_not_mapped_error"
+
+##
+# Module containing methods to filter Strings
+module RequestDataFiltering
+  VARIABLE_PATTERN = %r{:[^/]+}.freeze
+
+  ##
+  # Method responsible for extracting information
+  # provided by the client like Headers and Body
+  def self.parse_request_data(client, routes)
+    path, parameters = extract_url_parameters(client.gets.gsub("HTTP/1.1", ""))
+    parameters = {} if parameters.nil?
+
+    method_name = sanitize_method_name(path)
+    method_name = select_path(method_name, routes, parameters)
+    body_first_line, headers = extract_headers(client)
+    body = extract_body(client, body_first_line, headers["Content-Length"].to_i)
+    [path, method_name, headers, body, parameters]
+  end
+
+  def self.select_path(method_name, routes, parameters)
+    return method_name if routes.include?(method_name)
+
+    selected_route = nil
+    routes.each do |route|
+      split_route = route.split(".")
+      split_name = method_name.split(".")
+
+      next unless split_route.length == split_name.length
+      next unless match_path_with_route(split_name, split_route)
+
+      selected_route = route
+      split_route.each_with_index do |var, index|
+        parameters[var[1..].to_sym] = split_name[index] if var =~ VARIABLE_PATTERN
+      end
+      break
+    end
+
+    raise EndpointNotMappedError if selected_route.nil?
+
+    selected_route
+  end
+
+  def self.match_path_with_route(split_path, split_route)
+    split_route.each_with_index do |var, index|
+      return false if var != split_path[index] && !var.match?(VARIABLE_PATTERN)
+    end
+
+    true
+  end
+
+  ##
+  # Method responsible for sanitizing the method name
+  def self.sanitize_method_name(path)
+    path = extract_path(path)
+    method_name = path.gsub("/", ".").strip.downcase
+    method_name.gsub!(" ", "")
+    method_name
+  end
+
+  ##
+  # Method responsible for extracting the path from URI
+  def self.extract_path(path)
+    path[0] == "/" ? path[1..].gsub("/", ".") : path.gsub("/", ".")
+  end
+
+  ##
+  # Method responsible for extracting the headers from request
+  def self.extract_headers(client)
+    header = client.gets.delete("\n").delete("\r")
+    headers = {}
+    while header.match(%r{[a-zA-Z0-9\-/*]*: [a-zA-Z0-9\-/*]})
+      split_header = header.split(":")
+      headers[split_header[0].strip] = split_header[1].strip
+      header = client.gets.delete("\n").delete("\r")
+    end
+    [header, headers]
+  end
+
+  ##
+  # Method responsible for extracting the body from request
+  def self.extract_body(client, body_first_line, content_length)
+    body = client.read(content_length)
+    body_first_line << body.to_s
+  end
+
+  ##
+  # Method responsible for extracting the parameters from URI
+  def self.extract_url_parameters(http_first_line)
+    return http_first_line, nil unless http_first_line =~ /\?/
+
+    path_and_parameters = http_first_line.split("?", 2)
+    path = "#{path_and_parameters[0]} "
+    parameters_array = path_and_parameters[1].split("&")
+    parameters_array.map! do |item|
+      split_item = item.split("=")
+      { sanitize_parameter_name(split_item[0]) => sanitize_parameter_value(split_item[1]) }
+    end
+    parameters = {}
+    parameters_array.each { |item| parameters.merge!(item) }
+    [path, parameters]
+  end
+
+  ##
+  # Method responsible for sanitizing the parameter name
+  def self.sanitize_parameter_name(name)
+    name.gsub(/[^\w\s]/, "")
+  end
+
+  ##
+  # Method responsible for sanitizing the parameter value
+  def self.sanitize_parameter_value(value)
+    value.gsub(/[^\w\s]/, "")
+    value.gsub(/[\r\n\s]/, "")
+  end
+end

data/lib/macaw_framework/middlewares/server.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../aspects/logging_aspect"
+require_relative "../utils/http_status_code"
+
+##
+# Class responsible for providing a default
+# webserver.
+class Server
+  prepend LoggingAspect
+  include HttpStatusCode
+
+  ##
+  # Create a new instance of Server.
+  # @param {Macaw} macaw
+  # @param {Logger} logger
+  # @param {Integer} port
+  # @param {String} bind
+  # @param {Integer} num_threads
+  # @return {Server}
+  def initialize(macaw, logger, port, bind, num_threads)
+    @port = port
+    @bind = bind
+    @macaw = macaw
+    @macaw_log = logger
+    @num_threads = num_threads
+    @work_queue = Queue.new
+    @workers = []
+  end
+
+  ##
+  # Start running the webserver.
+  def run
+    @server = TCPServer.new(@bind, @port)
+    @num_threads.times do
+      @workers << Thread.new do
+        loop do
+          client = @work_queue.pop
+          break if client == :shutdown
+
+          handle_client(client)
+        end
+      end
+    end
+
+    loop do
+      @work_queue << @server.accept
+    rescue IOError, Errno::EBADF
+      break
+    end
+  end
+
+  ##
+  # Method Responsible for closing the TCP server.
+  def close
+    @server.close
+    @num_threads.times { @work_queue << :shutdown }
+    @workers.each(&:join)
+  end
+
+  private
+
+  def handle_client(client)
+    path, method_name, headers, body, parameters = RequestDataFiltering.parse_request_data(client, @macaw.routes)
+    raise EndpointNotMappedError unless @macaw.respond_to?(method_name)
+
+    @macaw_log.info("Running #{path.gsub("\n", "").gsub("\r", "")}")
+    message, status = call_endpoint(@macaw_log, method_name, headers, body, parameters)
+    status ||= 200
+    message ||= "Ok"
+    client.puts "HTTP/1.1 #{status} #{HTTP_STATUS_CODE_MAP[status]} \r\n\r\n#{message}"
+    client.close
+  rescue EndpointNotMappedError
+    client.print "HTTP/1.1 404 Not Found\r\n\r\n"
+    client.close
+  rescue StandardError => e
+    client.print "HTTP/1.1 500 Internal Server Error\r\n\r\n"
+    @macaw_log.info("Error: #{e}")
+    client.close
+  end
+
+  def call_endpoint(name, headers, body, parameters)
+    @macaw.send(name.to_sym, { headers: headers, body: body, params: parameters })
+  end
+end

data/lib/macaw_framework/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MacawFramework
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/lib/macaw_framework.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "macaw_framework/endpoint_not_mapped_error"
-require_relative "macaw_framework/request_data_filtering"
-require_relative "macaw_framework/http_status_code"
+require_relative "macaw_framework/errors/endpoint_not_mapped_error"
+require_relative "macaw_framework/middlewares/request_data_filtering"
+require_relative "macaw_framework/middlewares/server"
 require_relative "macaw_framework/version"
 require "logger"
 require "socket"
@@ -13,18 +13,27 @@ module MacawFramework
   # Class responsible for creating endpoints and
   # starting the web server.
   class Macaw
-    include(HttpStatusCode)
+    ##
+    # Array containing the routes defined in the application
+    attr_reader :routes
+
     ##
     # @param {Logger} custom_log
-    def initialize(custom_log = nil)
+    def initialize(custom_log: nil, server: Server)
       begin
+        @routes = []
+        @macaw_log ||= custom_log.nil? ? Logger.new($stdout) : custom_log
         config = JSON.parse(File.read("application.json"))
         @port = config["macaw"]["port"]
-      rescue StandardError
-        @port ||= 8080
+        @bind = config["macaw"]["bind"]
+        @threads = config["macaw"]["threads"].to_i
+      rescue StandardError => e
+        @macaw_log.error(e.message)
       end
       @port ||= 8080
-      @macaw_log ||= custom_log.nil? ? Logger.new($stdout) : custom_log
+      @bind ||= "localhost"
+      @threads ||= 5
+      @server = server.new(self, @macaw_log, @port, @bind, @threads)
     end
 
     ##
@@ -80,46 +89,30 @@ module MacawFramework
     ##
     # Starts the web server
     def start!
+      @macaw_log.info("---------------------------------")
       @macaw_log.info("Starting server at port #{@port}")
-      time = Time.now
-      server = TCPServer.open(@port)
-      @macaw_log.info("Server started in #{Time.now - time} seconds.")
-      server_loop(server)
+      @macaw_log.info("Number of threads: #{@threads}")
+      @macaw_log.info("---------------------------------")
+      server_loop(@server)
     rescue Interrupt
       @macaw_log.info("Stopping server")
-      server.close
+      @server.close
       @macaw_log.info("Macaw stop flying for some seeds...")
     end
 
     private
 
     def server_loop(server)
-      loop do
-        Thread.start(server.accept) do |client|
-          path, method_name, headers, body, parameters = RequestDataFiltering.extract_client_info(client)
-          raise EndpointNotMappedError unless respond_to?(method_name)
-
-          @macaw_log.info("Running #{path.gsub("\n", "").gsub("\r", "")}")
-          message, status = send(method_name, headers, body, parameters)
-          status ||= 200
-          message ||= "Ok"
-          client.puts "HTTP/1.1 #{status} #{HTTP_STATUS_CODE_MAP[status]} \r\n\r\n#{message}"
-          client.close
-        rescue EndpointNotMappedError
-          client.print "HTTP/1.1 404 Not Found\r\n\r\n"
-          client.close
-        rescue StandardError => e
-          client.print "HTTP/1.1 500 Internal Server Error\r\n\r\n"
-          @macaw_log.info("Error: #{e}")
-          client.close
-        end
-      end
+      server.run
     end
 
     def map_new_endpoint(prefix, path, &block)
       path_clean = RequestDataFiltering.extract_path(path)
       @macaw_log.info("Defining #{prefix.upcase} endpoint at /#{path}")
-      define_singleton_method("#{prefix}_#{path_clean}", block)
+      define_singleton_method("#{prefix}.#{path_clean}", block || lambda {
+        |context = { headers: {}, body: "", params: {} }|
+                                                         })
+      @routes << "#{prefix}.#{path_clean}"
     end
   end
 end

data/sig/logging_aspect.rbs

@@ -0,0 +1,3 @@
+module LoggingAspect
+  def call_endpoint: -> Array[untyped]
+end

data/sig/macaw_framework/macaw.rbs

@@ -1,7 +1,15 @@
 module MacawFramework
   class Macaw
+    @bind: string
+    @macaw_log: Logger
     @port: int
 
+    @server: Server
+
+    @threads: Integer
+
+    attr_reader routes: Array[String]
+
     def delete: -> nil
 
     def get: -> nil

data/sig/request_data_filtering.rbs

@@ -0,0 +1,3 @@
+module RequestDataFiltering
+  VARIABLE_PATTERN: Regexp
+end

data/sig/server.rbs

@@ -0,0 +1,25 @@
+class Server
+  @bind: String
+  @macaw: MacawFramework::Macaw
+  @macaw_log: Logger
+  @num_threads: Integer
+  @port: Integer
+
+  @server: TCPServer
+
+  @threads: Integer
+
+  @work_queue: Thread::Queue
+
+  @workers: Array[Thread]
+
+  def close: -> nil
+
+  def run: -> nil
+
+  private
+
+  def call_endpoint: -> Array[untyped]
+
+  def handle_client: -> nil
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: macaw_framework
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Aria Diniz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-12-14 00:00:00.000000000 Z
+date: 2023-04-16 00:00:00.000000000 Z
 dependencies: []
 description: A project started for study purpose that I intend to keep working on.
 email:
@@ -25,13 +25,19 @@ files:
 - README.md
 - Rakefile
 - lib/macaw_framework.rb
-- lib/macaw_framework/endpoint_not_mapped_error.rb
-- lib/macaw_framework/http_status_code.rb
-- lib/macaw_framework/request_data_filtering.rb
+- lib/macaw_framework/aspects/logging_aspect.rb
+- lib/macaw_framework/errors/endpoint_not_mapped_error.rb
+- lib/macaw_framework/middlewares/request_data_filtering.rb
+- lib/macaw_framework/middlewares/server.rb
+- lib/macaw_framework/utils/http_status_code.rb
 - lib/macaw_framework/version.rb
+- macaw_logo.png
 - sig/http_status_code.rbs
+- sig/logging_aspect.rbs
 - sig/macaw_framework.rbs
 - sig/macaw_framework/macaw.rbs
+- sig/request_data_filtering.rbs
+- sig/server.rbs
 homepage: https://github.com/ariasdiniz/macaw_framework
 licenses:
 - MIT
@@ -54,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: A web framework still in development.

data/lib/macaw_framework/request_data_filtering.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-##
-# Module containing methods to filter Strings
-module RequestDataFiltering
-  ##
-  # Method responsible for extracting information
-  # provided by the client like Headers and Body
-  def self.extract_client_info(client)
-    path, parameters = extract_url_parameters(client.gets.gsub("HTTP/1.1", ""))
-    method_name = path.gsub("/", "_").strip!.downcase
-    method_name.gsub!(" ", "")
-    body_first_line, headers = extract_headers(client)
-    body = extract_body(client, body_first_line, headers["Content-Length"].to_i)
-    [path, method_name, headers, body, parameters]
-  end
-
-  ##
-  # Method responsible for extracting the path from URI
-  def self.extract_path(path)
-    path[0] == "/" ? path[1..].gsub("/", "_") : path.gsub("/", "_")
-  end
-
-  ##
-  # Method responsible for extracting the headers from request
-  def self.extract_headers(client)
-    header = client.gets.delete("\n").delete("\r")
-    headers = {}
-    while header.match(%r{[a-zA-Z0-9\-/*]*: [a-zA-Z0-9\-/*]})
-      split_header = header.split(":")
-      headers[split_header[0]] = split_header[1][1..]
-      header = client.gets.delete("\n").delete("\r")
-    end
-    [header, headers]
-  end
-
-  ##
-  # Method responsible for extracting the body from request
-  def self.extract_body(client, body_first_line, content_length)
-    body = client.read(content_length)
-    body_first_line << body.to_s
-  end
-
-  ##
-  # Method responsible for extracting the parameters from URI
-  def self.extract_url_parameters(http_first_line)
-    return http_first_line, nil unless http_first_line =~ /\?/
-
-    path_and_parameters = http_first_line.split("?", 2)
-    path = "#{path_and_parameters[0]} "
-    parameters_array = path_and_parameters[1].split("&")
-    parameters_array.map! do |item|
-      split_item = item.split("=")
-      { split_item[0] => split_item[1].gsub("\n", "").gsub("\r", "").gsub("\s", "") }
-    end
-    parameters = {}
-    parameters_array.each { |item| parameters.merge!(item) }
-    [path, parameters]
-  end
-end