macaw_framework 1.3.0 → 1.3.3

data/lib/macaw_framework/data_filters/request_data_filtering.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require_relative "../errors/endpoint_not_mapped_error"
+require_relative '../errors/endpoint_not_mapped_error'
 
 ##
 # Module containing methods to filter Strings
 module RequestDataFiltering
-  VARIABLE_PATTERN = %r{:[^/]+}.freeze
+  VARIABLE_PATTERN = %r{:[^/]+}
 
   ##
   # 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", ""))
+    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)
+    body = extract_body(client, body_first_line, headers['Content-Length'].to_i)
     [path, method_name, headers, body, parameters]
   end
 
@@ -26,15 +26,15 @@ module RequestDataFiltering
 
     selected_route = nil
     routes.each do |route|
-      split_route = route.split(".")
-      split_name = method_name.split(".")
+      split_route = route&.split('.')
+      split_name = method_name&.split('.')
 
-      next unless split_route.length == split_name.length
+      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
+      split_route&.each_with_index do |var, index|
+        parameters[var[1..].to_sym] = split_name&.dig(index) if var =~ VARIABLE_PATTERN
       end
       break
     end
@@ -45,7 +45,7 @@ module RequestDataFiltering
   end
 
   def self.match_path_with_route(split_path, split_route)
-    split_route.each_with_index do |var, index|
+    split_route&.each_with_index do |var, index|
       return false if var != split_path[index] && !var.match?(VARIABLE_PATTERN)
     end
 
@@ -56,26 +56,28 @@ module RequestDataFiltering
   # 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 = 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("/", ".")
+    return path if path.nil?
+
+    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")
+    header = client.gets&.delete("\n")&.delete("\r")
     headers = {}
-    while header.match(%r{[a-zA-Z0-9\-/*]*: [a-zA-Z0-9\-/*]})
-      split_header = header.split(":")
+    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")
+      header = client.gets&.delete("\n")&.delete("\r")
     end
     [header, headers]
   end
@@ -83,7 +85,7 @@ module RequestDataFiltering
   ##
   # Method responsible for extracting the body from request
   def self.extract_body(client, body_first_line, content_length)
-    body = client.read(content_length)
+    body = client&.read(content_length)
     body_first_line << body.to_s
   end
 
@@ -92,11 +94,11 @@ module RequestDataFiltering
   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_and_parameters = http_first_line.split('?', 2)
     path = "#{path_and_parameters[0]} "
-    parameters_array = path_and_parameters[1].split("&")
+    parameters_array = path_and_parameters[1].split('&')
     parameters_array.map! do |item|
-      split_item = item.split("=")
+      split_item = item.split('=')
       { sanitize_parameter_name(split_item[0]) => sanitize_parameter_value(split_item[1]) }
     end
     parameters = {}
@@ -107,13 +109,13 @@ module RequestDataFiltering
   ##
   # Method responsible for sanitizing the parameter name
   def self.sanitize_parameter_name(name)
-    name.gsub(/[^\w\s]/, "")
+    name&.gsub(/[^\w\s]/, '')
   end
 
   ##
   # Method responsible for sanitizing the parameter value
   def self.sanitize_parameter_value(value)
-    value.gsub(/[^\w\s]/, "")
-    value.gsub(/\s/, "")
+    value&.gsub(/[^\w\s]/, '')
+    value&.gsub(/\s/, '')
   end
 end

data/lib/macaw_framework/data_filters/response_data_filter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../utils/http_status_code"
+require_relative '../utils/http_status_code'
 
 ##
 # Module responsible to filter and mount HTTP responses
@@ -19,9 +19,9 @@ module ResponseDataFilter
   end
 
   def self.mount_response_headers(headers)
-    return "" if headers.nil?
+    return '' if headers.nil?
 
-    response = ""
+    response = ''
     headers.each do |key, value|
       response += "#{key}: #{value}\r\n"
     end

data/lib/macaw_framework/errors/endpoint_not_mapped_error.rb

@@ -4,7 +4,7 @@
 # Error raised when the client calls
 # for a path that doesn't exist.
 class EndpointNotMappedError < StandardError
-  def initialize(msg = "Undefined endpoint")
+  def initialize(msg = 'Undefined endpoint')
     super
   end
 end

data/lib/macaw_framework/macaw.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require_relative 'errors/endpoint_not_mapped_error'
+require_relative 'middlewares/prometheus_middleware'
+require_relative 'data_filters/request_data_filtering'
+require_relative 'middlewares/memory_invalidation_middleware'
+require_relative 'core/cron_runner'
+require_relative 'core/thread_server'
+require_relative 'version'
+require 'prometheus/client'
+require 'securerandom'
+require 'singleton'
+require 'pathname'
+require 'logger'
+require 'socket'
+require 'json'
+
+##
+# Main module for all Macaw classes
+module MacawFramework; end
+
+##
+# Class responsible for creating endpoints and
+# starting the web server.
+class MacawFramework::Macaw
+  attr_reader :routes, :macaw_log, :config, :jobs, :cached_methods, :secure_header, :session
+  attr_accessor :port, :bind, :threads
+
+  ##
+  # Initialize Macaw Class
+  # @param {Logger} custom_log
+  # @param {ThreadServer} server
+  # @param {String?} dir
+  def initialize(custom_log: Logger.new($stdout), server: ThreadServer, dir: nil)
+    apply_options(custom_log)
+    create_endpoint_public_files(dir)
+    setup_default_configs
+    @server_class = server
+  end
+
+  ##
+  # Creates a GET endpoint associated
+  # with the respective path.
+  # @param {String} path
+  # @param {Proc} block
+  #
+  # @example
+  #   macaw = MacawFramework::Macaw.new
+  #   macaw.get("/hello") do |context|
+  #     return "Hello World!", 200, { "Content-Type" => "text/plain" }
+  #   end
+  ##
+  def get(path, cache: [], &block)
+    map_new_endpoint('get', cache, path, &block)
+  end
+
+  ##
+  # Creates a POST endpoint associated
+  # with the respective path.
+  # @param {String} path
+  # @param {Boolean} cache
+  # @param {Proc} block
+  # @example
+  #
+  #   macaw = MacawFramework::Macaw.new
+  #   macaw.post("/hello") do |context|
+  #     return "Hello World!", 200, { "Content-Type" => "text/plain" }
+  #   end
+  ##
+  def post(path, cache: [], &block)
+    map_new_endpoint('post', cache, path, &block)
+  end
+
+  ##
+  # Creates a PUT endpoint associated
+  # with the respective path.
+  # @param {String} path
+  # @param {Proc} block
+  # @example
+  #
+  #   macaw = MacawFramework::Macaw.new
+  #   macaw.put("/hello") do |context|
+  #     return "Hello World!", 200, { "Content-Type" => "text/plain" }
+  #   end
+  ##
+  def put(path, cache: [], &block)
+    map_new_endpoint('put', cache, path, &block)
+  end
+
+  ##
+  # Creates a PATCH endpoint associated
+  # with the respective path.
+  # @param {String} path
+  # @param {Proc} block
+  # @example
+  #
+  #   macaw = MacawFramework::Macaw.new
+  #   macaw.patch("/hello") do |context|
+  #     return "Hello World!", 200, { "Content-Type" => "text/plain" }
+  #   end
+  ##
+  def patch(path, cache: [], &block)
+    map_new_endpoint('patch', cache, path, &block)
+  end
+
+  ##
+  # Creates a DELETE endpoint associated
+  # with the respective path.
+  # @param {String} path
+  # @param {Proc} block
+  # @example
+  #
+  #   macaw = MacawFramework::Macaw.new
+  #   macaw.delete("/hello") do |context|
+  #     return "Hello World!", 200, { "Content-Type" => "text/plain" }
+  #   end
+  ##
+  def delete(path, cache: [], &block)
+    map_new_endpoint('delete', cache, path, &block)
+  end
+
+  ##
+  # Spawn and start a thread running the defined periodic job.
+  # @param {Integer} interval
+  # @param {Integer?} start_delay
+  # @param {String} job_name
+  # @param {Proc} block
+  # @example
+  #
+  #   macaw = MacawFramework::Macaw.new
+  #   macaw.setup_job(interval: 60, start_delay: 60, job_name: "job 1") do
+  #     puts "I'm a periodic job that runs every minute"
+  #   end
+  ##
+  def setup_job(interval: 60, start_delay: 0, job_name: "job_#{SecureRandom.uuid}", &block)
+    @cron_runner ||= CronRunner.new(self)
+    @jobs ||= []
+    @cron_runner.start_cron_job_thread(interval, start_delay, job_name, &block)
+    @jobs << job_name
+  end
+
+  ##
+  # Starts the web server
+  def start!
+    if @macaw_log.nil?
+      puts('---------------------------------')
+      puts("Starting server at port #{@port}")
+      puts("Number of threads: #{@threads}")
+      puts('---------------------------------')
+    else
+      @macaw_log.info('---------------------------------')
+      @macaw_log.info("Starting server at port #{@port}")
+      @macaw_log.info("Number of threads: #{@threads}")
+      @macaw_log.info('---------------------------------')
+    end
+    @server = @server_class.new(self, @endpoints_to_cache, @cache, @prometheus, @prometheus_middleware)
+    server_loop(@server)
+  rescue Interrupt
+    if @macaw_log.nil?
+      puts('Stopping server')
+      @server.shutdown
+      puts('Macaw stop flying for some seeds...')
+    else
+      @macaw_log.info('Stopping server')
+      @server.shutdown
+      @macaw_log.info('Macaw stop flying for some seeds...')
+    end
+  end
+
+  ##
+  # This method is intended to start the framework
+  # without an web server. This can be useful when
+  # you just want to keep cron jobs running, without
+  # mapping any HTTP endpoints.
+  def start_without_server!
+    @macaw_log.nil? ? puts('Application starting') : @macaw_log.info('Application starting')
+    loop { sleep(3600) }
+  rescue Interrupt
+    @macaw_log.nil? ? puts('Macaw stop flying for some seeds.') : @macaw_log.info('Macaw stop flying for some seeds.')
+  end
+
+  private
+
+  def setup_default_configs
+    @port ||= 8080
+    @bind ||= 'localhost'
+    @config ||= nil
+    @threads ||= 200
+    @endpoints_to_cache = []
+    @prometheus ||= nil
+    @prometheus_middleware ||= nil
+  end
+
+  def apply_options(custom_log)
+    setup_basic_config(custom_log)
+    setup_session
+    setup_cache
+    setup_prometheus
+  rescue StandardError => e
+    @macaw_log&.warn(e.message)
+  end
+
+  def setup_cache
+    return if @config['macaw']['cache'].nil?
+
+    @cache = MemoryInvalidationMiddleware.new(@config['macaw']['cache']['cache_invalidation'].to_i || 3_600)
+  end
+
+  def setup_session
+    @session = false
+    return if @config['macaw']['session'].nil?
+
+    @session = true
+    @secure_header = @config['macaw']['session']['secure_header'] || 'X-Session-ID'
+  end
+
+  def setup_basic_config(custom_log)
+    @routes = []
+    @cached_methods = {}
+    @macaw_log ||= custom_log
+    @config = JSON.parse(File.read('application.json'))
+    @port = @config['macaw']['port'] || 8080
+    @bind = @config['macaw']['bind'] || 'localhost'
+    @threads = @config['macaw']['threads'] || 200
+  end
+
+  def setup_prometheus
+    return unless @config['macaw']['prometheus']
+
+    @prometheus = Prometheus::Client::Registry.new
+    @prometheus_middleware = PrometheusMiddleware.new
+    @prometheus_middleware&.configure_prometheus(@prometheus, @config, self)
+  end
+
+  def server_loop(server)
+    server.run
+  end
+
+  def map_new_endpoint(prefix, cache, path, &block)
+    @endpoints_to_cache << "#{prefix}.#{RequestDataFiltering.sanitize_method_name(path)}" unless cache.empty?
+    @cached_methods["#{prefix}.#{RequestDataFiltering.sanitize_method_name(path)}"] = cache unless cache.empty?
+    path_clean = RequestDataFiltering.extract_path(path)
+    slash = path[0] == '/' ? '' : '/'
+    @macaw_log&.info("Defining #{prefix.upcase} endpoint at #{slash}#{path}")
+    define_singleton_method("#{prefix}.#{path_clean}", block || lambda {
+      |context = { headers: {}, body: '', params: {} }|
+    })
+    @routes << "#{prefix}.#{path_clean}"
+  end
+
+  def get_files_public_folder(dir)
+    return [] if dir.nil?
+
+    folder_path = Pathname.new(File.expand_path('public', dir))
+    file_paths = folder_path.glob('**/*').select(&:file?)
+    file_paths.map { |path| "public/#{path.relative_path_from(folder_path)}" }
+  end
+
+  def create_endpoint_public_files(dir)
+    get_files_public_folder(dir).each do |file|
+      get(file) { |_context| return File.read(file).to_s, 200, {} }
+    end
+  end
+end

data/lib/macaw_framework/middlewares/prometheus_middleware.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "prometheus/client"
-require "prometheus/client/formats/text"
+require 'prometheus/client'
+require 'prometheus/client/formats/text'
 
 ##
 # Middleware responsible to configure prometheus
@@ -14,20 +14,20 @@ class PrometheusMiddleware
 
     @request_duration_milliseconds = Prometheus::Client::Histogram.new(
       :request_duration_milliseconds,
-      docstring: "The duration of each request in milliseconds",
+      docstring: 'The duration of each request in milliseconds',
       labels: [:endpoint],
       buckets: (100..1000).step(100).to_a + (2000..10_000).step(1000).to_a
     )
 
     @request_count = Prometheus::Client::Counter.new(
       :request_count,
-      docstring: "The total number of requests received",
+      docstring: 'The total number of requests received',
       labels: [:endpoint]
     )
 
     @response_count = Prometheus::Client::Counter.new(
       :response_count,
-      docstring: "The total number of responses sent",
+      docstring: 'The total number of responses sent',
       labels: %i[endpoint status]
     )
 
@@ -40,9 +40,9 @@ class PrometheusMiddleware
   private
 
   def prometheus_endpoint(prometheus_registry, configurations, macaw)
-    endpoint = configurations["macaw"]["prometheus"]["endpoint"] || "/metrics"
+    endpoint = configurations['macaw']['prometheus']['endpoint'] || '/metrics'
     macaw.get(endpoint) do |_context|
-      [Prometheus::Client::Formats::Text.marshal(prometheus_registry), 200, { "Content-Type" => "plaintext" }]
+      [Prometheus::Client::Formats::Text.marshal(prometheus_registry), 200, { 'Content-Type' => 'plaintext' }]
     end
   end
 end

data/lib/macaw_framework/utils/http_status_code.rb

@@ -7,66 +7,66 @@ module HttpStatusCode
   ##
   # Http Status Code Map
   HTTP_STATUS_CODE_MAP = {
-    100 => "Continue",
-    101 => "Switching Protocols",
-    102 => "Processing",
-    103 => "Early Hints",
-    200 => "OK",
-    201 => "Created",
-    202 => "Accepted",
-    203 => "Non-Authoritative Information",
-    204 => "No Content",
-    205 => "Reset Content",
-    206 => "Partial Content",
-    207 => "Multi-Status",
-    208 => "Already Reported",
-    226 => "IM Used",
-    300 => "Multiple Choices",
-    301 => "Moved Permanently",
-    302 => "Found",
-    303 => "See Other",
-    304 => "Not Modified",
-    305 => "Use Proxy",
-    307 => "Temporary Redirect",
-    308 => "Permanent 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 => "Content Too Large",
-    414 => "URI Too Long",
-    415 => "Unsupported Media Type",
-    416 => "Range Not Satisfiable",
-    417 => "Expectation Failed",
-    421 => "Misdirected Request",
-    422 => "Unprocessable Content",
-    423 => "Locked",
-    424 => "Failed Dependency",
-    425 => "Too Early",
-    426 => "Upgrade Required",
-    428 => "Precondition Required",
-    429 => "Too Many Requests",
-    431 => "Request Header Fields Too Large",
-    451 => "Unavailable For Legal Reasons",
-    500 => "Internal Server Error",
-    501 => "Not Implemented",
-    502 => "Bad Gateway",
-    503 => "Service Unavailable",
-    504 => "Gateway Timeout",
-    505 => "HTTP Version Not Supported",
-    506 => "Variant Also Negotiates",
-    507 => "Insufficient Storage",
-    508 => "Loop Detected",
-    510 => "Not Extended (OBSOLETED)",
-    511 => "Network Authentication Required"
+    100 => 'Continue',
+    101 => 'Switching Protocols',
+    102 => 'Processing',
+    103 => 'Early Hints',
+    200 => 'OK',
+    201 => 'Created',
+    202 => 'Accepted',
+    203 => 'Non-Authoritative Information',
+    204 => 'No Content',
+    205 => 'Reset Content',
+    206 => 'Partial Content',
+    207 => 'Multi-Status',
+    208 => 'Already Reported',
+    226 => 'IM Used',
+    300 => 'Multiple Choices',
+    301 => 'Moved Permanently',
+    302 => 'Found',
+    303 => 'See Other',
+    304 => 'Not Modified',
+    305 => 'Use Proxy',
+    307 => 'Temporary Redirect',
+    308 => 'Permanent 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 => 'Content Too Large',
+    414 => 'URI Too Long',
+    415 => 'Unsupported Media Type',
+    416 => 'Range Not Satisfiable',
+    417 => 'Expectation Failed',
+    421 => 'Misdirected Request',
+    422 => 'Unprocessable Content',
+    423 => 'Locked',
+    424 => 'Failed Dependency',
+    425 => 'Too Early',
+    426 => 'Upgrade Required',
+    428 => 'Precondition Required',
+    429 => 'Too Many Requests',
+    431 => 'Request Header Fields Too Large',
+    451 => 'Unavailable For Legal Reasons',
+    500 => 'Internal Server Error',
+    501 => 'Not Implemented',
+    502 => 'Bad Gateway',
+    503 => 'Service Unavailable',
+    504 => 'Gateway Timeout',
+    505 => 'HTTP Version Not Supported',
+    506 => 'Variant Also Negotiates',
+    507 => 'Insufficient Storage',
+    508 => 'Loop Detected',
+    510 => 'Not Extended (OBSOLETED)',
+    511 => 'Network Authentication Required'
   }.freeze
 end

data/lib/macaw_framework/utils/supported_ssl_versions.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require "openssl"
+require 'openssl'
 
 module SupportedSSLVersions
   VERSIONS = {
-    "SSL2" => OpenSSL::SSL::SSL2_VERSION,
-    "SSL3" => OpenSSL::SSL::SSL3_VERSION,
-    "TLS1.1" => OpenSSL::SSL::TLS1_1_VERSION,
-    "TLS1.2" => OpenSSL::SSL::TLS1_2_VERSION,
-    "TLS1.3" => OpenSSL::SSL::TLS1_3_VERSION
+    'SSL2' => OpenSSL::SSL::SSL2_VERSION,
+    'SSL3' => OpenSSL::SSL::SSL3_VERSION,
+    'TLS1.1' => OpenSSL::SSL::TLS1_1_VERSION,
+    'TLS1.2' => OpenSSL::SSL::TLS1_2_VERSION,
+    'TLS1.3' => OpenSSL::SSL::TLS1_3_VERSION
   }.freeze
 end

data/lib/macaw_framework/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MacawFramework
-  VERSION = "1.3.0"
+  VERSION = '1.3.3'
 end