class Tsurezure::RequestHandler

this class is made to handle requests coming from a single client on a tcp server.

Public Class Methods

new(session) click to toggle source

initializes with a client socket returned from a TCPSocket object.

# File lib/tsurezure.rb, line 43
def initialize(session)
  @session = session
  # endpoints are organized into arrays, sorted by method.
  # ex: { get: [ ...endpoint objects ], post: [ ... ] }
  # etc.
end

Public Instance Methods

call_each_middleware(request, middleware, type) click to toggle source
# File lib/tsurezure.rb, line 135
def call_each_middleware(request, middleware, type)
  alt = nil

  middleware.each do |path|
    break if alt

    @middleware[path]&.each do |mid|
      alt = mid[:callback].call fix_req(request, mid)
    end
  end

  return true unless alt

  send_middleware_response(request, alt, type)
end
fix_req(request, mid) click to toggle source
# File lib/tsurezure.rb, line 97
def fix_req(request, mid)
  request[:vars] =
    HTTPUtils::URLUtils.get_match_indices(
      mid[:path_regex],
      request[:url]
    ) || {}

  request[:options] = mid[:options]

  request
end
generate_response(request_object) click to toggle source

generate a response from a supplied request object from handle_request.

# File lib/tsurezure.rb, line 72
def generate_response(request_object)
  type = 'text/plain'

  unless request_object[:options].nil? || request_object[:options].empty?
    type = request_object[:options][:content_type]
  end

  res = TResponse.get_response request_object, @endpoints

  # to initialize: session and length of response
  responder = HTTPUtils::ServerResponse.new(
    @session,
    res[:message].nil? ? '' : res[:message].bytesize
  )

  go_through_middleware request_object, responder, res, type
end
get_correct_middleware(request_object) click to toggle source
# File lib/tsurezure.rb, line 90
def get_correct_middleware(request_object)
  @middleware.keys.select do |pat|
    HTTPUtils::URLUtils.matches_url_regex?(pat, request_object[:url]) ||
      pat == '*'
  end
end
go_through_middleware(request_object, responder, res, type) click to toggle source
# File lib/tsurezure.rb, line 151
def go_through_middleware(request_object, responder, res, type)
  exp = get_correct_middleware request_object

  done = call_each_middleware request_object, exp, type

  return unless done

  # to send: response, options, status, content_type
  responder.respond res[:message], res[:options] || {}, res[:status], type
end
handle_request(request) click to toggle source

handles an incoming request from the open socket in +@session+. constructs a formatted request object from the original request object, and calls send_final_response in order to send a response.

# File lib/tsurezure.rb, line 54
def handle_request(request)
  url_main = request[:url].split('?')[0]

  request_object = {
    method: request[:method],
    url: url_main,
    params: HTTPUtils::URLUtils.extract_url_params(request[:url]),
    protocol: request[:protocol],
    headers: request[:headers],
    data: request[:data]
  }

  generate_response request_object
end
process(client, endpoints, middleware) click to toggle source

main process, allows server to handle requests

# File lib/tsurezure.rb, line 164
def process(client, endpoints, middleware)
  @endpoints = endpoints
  @middleware = middleware
  @request = client.gets
  # wait until server isn't recieving anything
  return if @session.gets.nil?
  return if @session.gets.chop.length.zero?

  request_made = HTTPUtils.make_proper_request client, @request

  request_to_handle = HTTPUtils.make_request_object request_made

  handle_request request_to_handle
end
respond_with_error(error) click to toggle source
# File lib/tsurezure.rb, line 109
def respond_with_error(error)
  Logbook::Dev.log(error)

  message = { error: error }.to_json

  responder = HTTPUtils::ServerResponse.new(
    @session,
    message.bytesize
  )

  responder.respond message, {}, 500, 'application/json'
end
send_middleware_response(req, resp, type) click to toggle source
# File lib/tsurezure.rb, line 122
def send_middleware_response(req, resp, type)
  res = resp.merge req

  return respond_with_error INVALID_RESPONSE_FORMAT if res[:message].nil?

  responder = HTTPUtils::ServerResponse.new(
    @session,
    res[:message].bytesize
  )

  responder.respond res[:message], res[:options] || {}, res[:status], type
end