simple-httpd 0.0.4 → 0.3.0

data/lib/simple/httpd/base_controller.rb

@@ -12,8 +12,8 @@ class Simple::Httpd::BaseController < Sinatra::Base
   # Rails development mode, but on the other hand it is much faster, and
   # probably useful 90% of the time.
   configure :development do
-    require "sinatra/reloader"
-    register Sinatra::Reloader
+    # require "sinatra/reloader"
+    # register Sinatra::Reloader
   end
 end
 

data/lib/simple/httpd/base_controller/error_handling.rb

@@ -1,6 +1,10 @@
 require_relative "./json"
 
+# rubocop:disable Metrics/ClassLength
+
 class Simple::Httpd::BaseController
+  H = ::Simple::Httpd::Helpers
+
   set :show_exceptions, false
   set :dump_errors, false
   set :raise_errors, false
@@ -64,27 +68,51 @@ class Simple::Httpd::BaseController
                       description: error_description(exc)
   end
 
-  # class NotAuthorizedError < RuntimeError
-  # end
-  #
-  # error(NotAuthorizedError) do
-  #   render_error e, status: 403,
-  #                title: "Not authorized",
-  #                description: "You don't have necessary powers to access this page."
-  # end
+  error(::Simple::Service::ArgumentError) do |exc|
+    render_error exc, status: 422,
+                      title: "Invalid input #{exc.message}",
+                      description: exc.message
+  end
 
-  # class LoginRequiredError < RuntimeError
-  # end
-  #
-  # error(LoginRequiredError) do
-  #   render_error e, status: 404,
-  #                title: "Not found",
-  #                description: "The server failed to recognize affiliation. Please provide a valid Session-Id."
-  # end
+  # -- not authorized.---------------------------------------------------------
+
+  class NotAuthorizedError < RuntimeError
+  end
+
+  error(NotAuthorizedError) do
+    render_error e, status: 403,
+                    title: "Not authorized",
+                    description: "You don't have necessary powers to access this page."
+  end
+
+  def not_authorized!(msg)
+    raise NotAuthorizedError, msg
+  end
+
+  # -- login required.---------------------------------------------------------
+
+  class LoginRequiredError < RuntimeError
+  end
+
+  def login_required!(msg)
+    raise LoginRequiredError, msg
+  end
+
+  error(LoginRequiredError) do
+    render_error e, status: 404,
+                    title: "Not found",
+                    description: "The server failed to recognize affiliation. Please provide a valid Session-Id."
+  end
+
+  # -- resource not found.-----------------------------------------------------
 
   class NotFoundError < RuntimeError
   end
 
+  def not_found!(msg)
+    raise NotFoundError, msg
+  end
+
   error(NotFoundError) do |exc|
     render_error exc, status: 404,
                       title: "Not found",
@@ -117,7 +145,7 @@ class Simple::Httpd::BaseController
   private
 
   def error_type(exc)
-    "error/#{exc.class.name.underscore}".gsub(/\/error$/, "")
+    "error/#{H.underscore exc.class.name}".gsub(/\/error$/, "")
   end
 
   def error_description(exc)

data/lib/simple/httpd/base_controller/json.rb

@@ -29,18 +29,25 @@ class Simple::Httpd::BaseController
 
   public
 
-  def parsed_json_body
-    @parsed_json_body ||= parse_json_body
+  def parsed_body
+    return @parsed_body if defined? @parsed_body
+
+    @parsed_body = parse_body
+  rescue RuntimeError => e
+    raise ArgumentError, e.to_s
   end
 
   private
 
-  def parse_json_body
-    unless request.content_type =~ /application\/json/
-      raise "Cannot parse non-JSON request body w/content_type #{request.content_type.inspect}"
+  def parse_body
+    case request.media_type
+    when "application/json"
+      request.body.rewind
+      body = request.body.read
+      body == "" ? {} : JSON.parse(body)
+    else
+      # parses form data
+      request.POST
     end
-
-    request.body.rewind
-    JSON.parse(request.body.read)
   end
 end

data/lib/simple/httpd/cli.rb

@@ -0,0 +1,99 @@
+# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+
+module Simple
+  class Httpd
+    class << self
+      attr_accessor :env
+    end
+  end
+end
+
+module Simple::Httpd::CLI
+  include Simple::CLI
+
+  # Runs a simple httpd server
+  #
+  # A mount_spec is either the location of a directory, which would then be mounted
+  # at the "/" HTTP location, or a directory followed by a colon and where to mount
+  # the directory.
+  #
+  # Mounted directories might contain either ruby source code which is then executed
+  # or static files to be delivered verbatim. See README.md for more details.
+  #
+  # Examples:
+  #
+  #   simple-httpd --port=8080 httpd/root --service=src/to/service.rb MyService:/ httpd/assets:assets
+  #
+  # serves the content of ./httpd/root on http://0.0.0.0/ and the content of httpd/assets
+  # on http://0.0.0.0/assets.
+  #
+  # Options:
+  #
+  #   --environment=ENV         ... the environment setting, which adjusts configuration.
+  #   --services=<path>,<path>  ... load these ruby file during startup. Used to define service objects.
+  #
+  # simple-httpd respects the HOST and PORT environment values to determine the interface
+  # and port to listen to. Default values are "127.0.0.1" and 8181.
+  #
+  # Each entry in mounts can be either:
+  #
+  # - a mount_point <tt>[ mount_point, path ]</tt>, e.g. <tt>[ "path/to/root", "/"]</tt>
+  # - a string denoting a mount_point, e.g. "path/to/root:/")
+  # - a string denoting a "/" mount_point (e.g. "path", which is shorthand for "path:/")
+  def main(*mount_specs, environment: "development", services: nil)
+    ::Simple::Httpd.env = environment
+
+    start_simplecov if environment == "test"
+
+    mount_specs << "." if mount_specs.empty?
+
+    host = ENV["HOST"] || "127.0.0.1"
+    port = Integer(ENV["PORT"] || 8181)
+
+    # late loading simple/httpd, for simplecov support
+    require "simple/httpd"
+    helpers = ::Simple::Httpd::Helpers
+
+    services&.split(",")&.each do |service_path|
+      paths = if Dir.exist?(service_path)
+                Dir.glob("#{service_path}/**/*.rb").sort
+              else
+                [service_path]
+              end
+
+      paths.each do |path|
+        logger.info "Loading service(s) from #{helpers.shorten_path path}"
+        load path
+      end
+    end
+
+    ::Simple::Httpd.listen!(*mount_specs, environment: environment,
+                                          host: host,
+                                          port: port,
+                                          logger: logger)
+  end
+
+  private
+
+  def stderr_logger
+    logger = ::Logger.new STDERR
+    logger.level = ::Logger::INFO
+    logger
+  end
+
+  def start_simplecov
+    require "simplecov"
+
+    SimpleCov.command_name "Integration Tests"
+    SimpleCov.start do
+      # return true to remove src from coverage
+      add_filter do |src|
+        next true if src.filename =~ /\/spec\//
+
+        false
+      end
+
+      # minimum_coverage 90
+    end
+  end
+end

data/lib/simple/httpd/helpers.rb

@@ -0,0 +1,54 @@
+module Simple::Httpd::Helpers
+  extend self
+
+  private
+
+  def pwd
+    @pwd ||= File.join(Dir.getwd, "/")
+  end
+
+  def home
+    @home ||= File.join(Dir.home, "/")
+  end
+
+  public
+
+  def shorten_path(path)
+    path = File.absolute_path(path)
+
+    if path.start_with?(pwd)
+      path = path[pwd.length..-1]
+      path = File.join("./", path) if path =~ /\//
+    end
+
+    if path.start_with?(home)
+      path = File.join("~/", path[home.length..-1])
+    end
+
+    path
+  end
+
+  def underscore(str)
+    parts = str.split("::")
+    parts = parts.map do |part|
+      part.gsub(/[A-Z]+/) { |ch| "_#{ch.downcase}" }.gsub(/^_/, "")
+    end
+    parts.join("/")
+  end
+
+  # instance_eval zero or more paths in the context of obj
+  def instance_eval_paths(obj, *paths)
+    paths.each do |path|
+      # STDERR.puts "Loading #{path}"
+      obj.instance_eval File.read(path), path, 1
+    end
+    obj
+  end
+
+  # subclass a klass with an optional description
+  def subclass(klass, description: nil)
+    subclass = Class.new(klass)
+    subclass.define_method(:inspect) { description } if description
+    subclass
+  end
+end

data/lib/simple/httpd/mount_spec.rb

@@ -0,0 +1,106 @@
+# rubocop:disable Metrics/AbcSize, Style/ParallelAssignment
+
+require "simple-service"
+require_relative "./rack"
+
+class Simple::Httpd::MountSpec
+  def self.build(arg, at:)
+    if at
+      entity, mount_point = arg, at
+    else
+      # The regexp below uses negative lookbehind and negative lookahead to
+      # only match single colons, but not double (or more) colons. See
+      # `ri Regexp` for details.
+      entity, mount_point = *arg.split(/(?<!:):(?!:)/, 2)
+    end
+
+    mount_point = normalize_and_verify_mount_point(mount_point)
+
+    ServiceMountSpec.build(mount_point, service: entity) ||
+      PathMountSpec.build(mount_point, path: entity) ||
+      raise(ArgumentError, "#{mount_point}: don't know how to mount #{entity.inspect}")
+  end
+
+  def self.normalize_and_verify_mount_point(mount_point)
+    mount_point ||= "/"                           # fall back to "/"
+    mount_point = File.join("/", mount_point)     # make sure we start at "/"
+
+    canary_url = "http://0.0.0.0#{mount_point}"   # verify mount_point: can it be used to build a URL?
+    URI.parse canary_url
+
+    mount_point
+  end
+
+  attr_reader :mount_point
+
+  class PathMountSpec < ::Simple::Httpd::MountSpec
+    Rack = ::Simple::Httpd::Rack
+
+    attr_reader :path, :mount_point
+
+    def self.build(mount_point, path:)
+      path = path.gsub(/\/$/, "") # remove trailing "/"
+
+      raise ArgumentError, "You probably don't want to mount your root directory, check mount_spec" if path == ""
+      return unless Dir.exist?(path)
+
+      new(mount_point, path)
+    end
+
+    def initialize(mount_point, path)
+      @mount_point, @path = mount_point, path
+    end
+
+    def build_rack_apps
+      [
+        Rack::DynamicMount.build(mount_point, path),
+        Rack::StaticMount.build(mount_point, path)
+      ].compact
+    end
+  end
+
+  class ServiceMountSpec < ::Simple::Httpd::MountSpec
+    H = ::Simple::Httpd::Helpers
+
+    attr_reader :service
+
+    def self.build(mount_point, service:)
+      service = ::Simple::Service.resolve(service)
+      return unless service
+
+      new(mount_point, service)
+    end
+
+    def initialize(mount_point, service)
+      @mount_point, @service = mount_point, service
+    end
+
+    def build_rack_apps
+      [build_controller]
+    end
+
+    private
+
+    # wraps all helpers into a Simple::Httpd::BaseController subclass
+    def build_controller
+      controller = H.subclass(::Simple::Httpd::BaseController)
+      setup_action_routes! controller
+      controller
+    end
+
+    def setup_action_routes!(controller)
+      action_names = service.actions.keys
+
+      controller.mount_service(service) do |service|
+        action_names.each do |action_name|
+          ::Simple::Httpd.logger.debug "#{mount_point}/#{action_name} -> #{service.name}##{action_name}"
+          controller.post "/#{action_name}" => action_name
+        end
+      end
+
+      ::Simple::Httpd.logger.info do
+        "#{mount_point}: mounting #{action_names.count} actions(s) from #{service.name} service"
+      end
+    end
+  end
+end

data/lib/simple/httpd/rack.rb

@@ -0,0 +1,17 @@
+module Simple::Httpd::Rack
+end
+
+require_relative "rack/static_mount"
+require_relative "rack/dynamic_mount"
+require_relative "rack/merger"
+
+module Simple::Httpd::Rack
+  def self.merge(apps)
+    Merger.build(apps)
+  end
+
+  def self.error(status, message = nil)
+    message ||= "Error #{status}"
+    [status, {}, [message]]
+  end
+end

data/lib/simple/httpd/rack/dynamic_mount.rb

@@ -0,0 +1,66 @@
+require "expectation"
+
+# The Simple::Httpd::Mountpoint.build returns a Rack compatible app, which
+# serves HTTP requests according to a set of dynamic ruby scripts and some
+# existing static files.
+class Simple::Httpd::Rack::DynamicMount
+  H = ::Simple::Httpd::Helpers
+  Rack = ::Simple::Httpd::Rack
+
+  def self.build(mount_point, path)
+    expect! path => String
+
+    url_map = new(mount_point, path).build_url_map
+
+    ::Rack::URLMap.new(url_map)
+  end
+
+  attr_reader :path
+  attr_reader :mount_point
+
+  def initialize(mount_point, path)
+    @mount_point = mount_point
+    @path = path
+
+    # determine source_paths and controller_paths
+    source_paths = Dir.glob("#{path}/**/*.rb")
+    helper_paths, @controller_paths = source_paths.partition { |str| /_helpers\.rb$/ =~ str }
+
+    # build root_controller
+    @root_controller = build_root_controller(helper_paths)
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  def build_url_map
+    @controller_paths.sort.each_with_object({}) do |absolute_path, url_map|
+      relative_path = absolute_path[(path.length)..-1]
+
+      relative_mount_point = relative_path == "/root.rb" ? "/" : relative_path.gsub(/\.rb$/, "")
+      controller_class = load_controller absolute_path
+
+      ::Simple::Httpd.logger.info do
+        absolute_mount_point = File.join(mount_point, relative_mount_point)
+        routes_count = controller_class.routes.reject { |verb, _| verb == "HEAD" }.values.sum(&:count)
+
+        "#{absolute_mount_point}: mounting #{routes_count} route(s) from #{H.shorten_path absolute_path}"
+      end
+
+      url_map.update relative_mount_point => controller_class
+    end
+  end
+
+  # wraps all helpers into a Simple::Httpd::BaseController subclass
+  def build_root_controller(helper_paths)
+    klass = H.subclass ::Simple::Httpd::BaseController,
+                       description: "root controller at #{path} w/#{helper_paths.count} helpers"
+
+    H.instance_eval_paths klass, *helper_paths.sort
+    klass
+  end
+
+  # wraps the source file in path into a root_controller
+  def load_controller(path)
+    klass = H.subclass @root_controller, description: "controller at #{path}"
+    H.instance_eval_paths klass, path
+  end
+end