waitress-core 0.0.1

data/lib/waitress.rb

@@ -0,0 +1,98 @@
+require 'waitress/version'
+require 'waitress/util'
+require 'waitress/kernel'
+require 'waitress/configure'
+require 'waitress/parse/query'
+
+require 'waitress/server'
+require 'waitress/request'
+require 'waitress/response'
+
+require 'waitress/vhost'
+require 'waitress/handlers/handler'
+require 'waitress/handlers/dirhandler'
+require 'waitress/handlers/handler404'
+require 'waitress/handlers/libhandler'
+require 'waitress/chef'
+
+require 'waitress_http11'
+
+require 'go'
+require 'configfile'
+require 'fileutils'
+
+# The Base module for the Waitress Web Server, containing all the required
+# classes and utilities created by Waitress
+module Waitress
+
+  # Create a new Waitress Server, or, in case of the Filesystem, create a Configuration
+  # for a set of Servers
+  # Params:
+  # +filesystem+:: True if waitress should be loaded from the Filesystem. Default: false
+  # +rootdir+:: The root directory to load waitress from, defaults to ~/.waitress
+  def self.serve! filesystem=false, rootdir=:default
+    waitress = Waitress.new
+    waitress.serve! filesystem, rootdir
+  end
+
+  # Create a configuration for a single Waitress Server instance. This should be called
+  # from the config.rb file and nowhere else.
+  # Params:
+  # +args+:: The arguments to configure with. This should be a variable amount of arguments
+  # representing what ports to run the server on. If no args are provided, port 80 will
+  # be used as a default
+  # +block+:: The block to call once the configuration has been created. Setup should be
+  # done in here
+  def self.configure! *args, &block
+    Waitress::Configure.configure! *args, &block
+  end
+
+  # Create a new Launch Instance, used to serve a simple Waitress Server from either the
+  # filesystem, or embedded.
+  def self.new *args
+    Waitress::Launcher.new *args
+  end
+
+  class Launcher
+
+    # Create a new launcher. This is responsible for creating Waitress server instances
+    # from either the Filesystem, or being embedded in an application
+    def initialize waitress_root="~/.waitress"
+      @waitress_root = File.expand_path waitress_root
+    end
+
+    # Serve a Waitress server from either the Filesystem or embedded in an application
+    def serve! filesystem=false, rootdir=:default
+      if filesystem
+        serve_filesystem rootdir
+      else
+        serve
+      end
+    end
+
+  :private
+    def config
+      ConfigFile.new File.join(@waitress_root, "config.yml"),
+        {"server_root" => File.join(@waitress_root, "www")}, :yaml
+    end
+
+    def serve_filesystem rootdir
+      if rootdir == :default
+        FileUtils.mkdir_p @waitress_root unless File.exist? @waitress_root
+        cfg = config
+        cfg.load
+        @root = File.expand_path cfg["server_root"]
+      else
+        @root = rootdir
+      end
+      # s = serve
+      # Waitress::Configure.new s, @root
+      # s
+      Waitress::Configure.new @root
+    end
+
+    def serve
+      Waitress::HttpServer.new
+    end
+  end
+end

data/lib/waitress/chef.rb

@@ -0,0 +1,110 @@
+module Waitress
+
+  # The chef class handles the cooking of responses, by serving errors and files
+  # from the Filesystem, as well as providing a system for including files within
+  # handlers and .wrb files. This class handles most loading from Filesystems
+  # and serving of the body of a response.
+  class Chef
+
+    HANDLERS = {
+      404 => Handler404.new
+    }
+
+    # Get the waitress resources directory, containing templates and the default
+    # http assets of waitress
+    def self.resources
+      File.expand_path "../resources", __FILE__
+    end
+
+    # Get the waitress HTTP assets directory, containing the default index, 404
+    # and styles resources.
+    def self.resources_http
+      File.join(resources, "http")
+    end
+
+    # Set the response to use an error page with the given error code (usually 404)
+    def self.error code, request, response, client, vhost
+      HANDLERS[code].serve!(request, response, client, vhost)
+    end
+
+    # Serve a file from the Filesystem, automatically handling based on whether the
+    # file is dynamic or static. This will set the body io and any required
+    # headers on the reponse object.
+    def self.serve_file request, response, client, vhost, file
+      if File.extname(file) == ".wrb" || File.extname(file) == ".rb"
+        response.mime ".html"
+        include_absfile File.expand_path(file)
+      else
+        response.mime File.extname(file)
+        response.body_io File.open(file, "r")
+      end
+    end
+
+    # Include a file from the VHost loadpath in the current running instance.
+    # Params:
+    # +filename+:: The filename of the file, relative to the load path of the VHost.
+    def self.include_file filename
+      lp = $VHOST.load_path
+      target = nil
+      lp.each do |path|
+        fl = File.join(path, filename)
+        ext = ["", ".rb", ".wrb"]
+        ext.each do |e|
+          flnew = "#{fl}#{e}"
+          target = flnew if File.exist?(flnew)
+        end
+      end
+
+      raise LoadError.new("Include does not exist in Load Path: #{target}") if target.nil?
+      include_absfile target
+    end
+
+    # Include a file from anywhere in the filesystem (absolute) in the current running
+    # instance. This will load the file's content and, if dynamic, evaluate it to the
+    # current response.
+    # Params:
+    # +target+:: The target file, given in absolute path form.
+    def self.include_absfile target
+      ext = File.extname target
+      if ext == ".wrb"
+        Waitress::WRBParser.parse! File.read(target), $RESPONSE.body_io
+      elsif ext == ".rb"
+        require target
+      else
+        echo File.read(target)
+      end
+    end
+
+    # Find a file to serve. This is used by the DirHandler
+    # to automatically include an index file if it exists under the
+    # requested directory, automatically add the .wrb or .html file extension
+    # for paths without the extension, etc. A hash containing the result (ok / notfound)
+    # and the new filepath will be given. 
+    def self.find_file abspath
+      ret = {}
+      if File.exist?(abspath)
+        if File.directory?(abspath)
+          wrb = File.join(abspath, "index.wrb")
+          html = File.join(abspath, "index.html")
+          if File.exist?(wrb)
+            ret = { :result => :ok, :file => wrb }
+          elsif File.exist?(html)
+            ret = { :result => :ok, :file => html }
+          else
+            ret = { :result => :dir, :file => abspath }
+          end
+        else
+          ret = { :result => :ok, :file => abspath }
+        end
+      elsif File.exist?("#{abspath}.html")
+        ret = { :result => :ok, :file => "#{abspath}.html" }
+      elsif File.exist?("#{abspath}.wrb")
+        ret = { :result => :ok, :file => "#{abspath}.wrb" }
+      else
+        ret = { :result => :notfound }
+      end
+      ret
+    end
+
+  end
+end

data/lib/waitress/configure.rb

@@ -0,0 +1,116 @@
+module Waitress
+
+  # The Configure Class is used to load Waitress configurations from the filesystem,
+  # usually used in the config.rb file.
+  class Configure
+
+    # Endpoint for Waitress.configure!
+    def self.configure! *args, &block
+      raise "Using 'configure!' outside of file target" if @@configure_target.nil?
+      @@configure_target.read_configure *args, &block
+    end
+
+    def self.config_target o
+      @@configure_target = o
+    end
+
+    attr_accessor :servers
+    attr_accessor :root
+
+    def initialize root
+      @root = root
+      @configurations = []
+      generate_configs
+
+      load_cfg
+
+      @servers = @configurations.map do |conf|
+        s = Waitress::HttpServer.new
+        conf.hosts.each { |h| s << h }
+        s.ports *conf.ports
+        s
+      end
+      puts "Waitress Configuration Complete"
+      puts "Servers Started on Ports: "
+      @servers.each do |x|
+        puts "\t#{x.ports.join ", "}"
+      end
+    end
+
+    # Run all servers in this configuration
+    def run
+      @servers.each { |s| s.run }
+    end
+
+    # Join all the server threads in this configuration
+    def join
+      @servers.each { |s| s.join }
+    end
+
+    # Read the configuration object
+    def read_configure *args, &block
+      config = Configuration.new self, *args
+      block.call(config)
+      @configurations << config
+    end
+
+    # Generate the configuration file if it doesn't already exist.
+    def generate_configs
+      FileUtils.mkdir_p(@root) unless File.exist?(@root)
+      raise "File #{@root} is not a directory!" unless File.directory?(@root)
+      @config = File.join(@root, "config.rb")
+      unless File.exist?(@config)
+        c = File.read(File.join(Waitress::Chef.resources, "default_config.rb"))
+        File.write(@config, c)
+      end
+    end
+
+    # Load the config.rb file
+    def load_cfg
+      Waitress::Configure.config_target self
+      path = File.absolute_path(@config)
+      require path
+      Waitress::Configure.config_target nil
+    end
+
+  end
+
+  # The Configuration Class is the object that contains a configuration
+  # of a single server instance, hosting all the methods provided by
+  # Waitress.configure!
+  class Configuration
+
+    attr_accessor :hosts
+    attr_accessor :ports
+
+    def initialize configure, *ports
+      @ports = *ports
+      @hosts = []
+      @configure = configure
+    end
+
+    # Create a new VirtualHost with the given regex, priority, and configure it
+    # inside of its own block.
+    def host regex, priority=50, &block
+      host = Waitress::Vhost.new regex, priority
+      host.set_configure @configure
+      block.call(host)
+      @hosts << host
+      host
+    end
+
+    # Over all the registered VHosts, call this method. Use this to configure
+    # a similar setting for all vhosts at once instead of duplicating code
+    # across all of them. 
+    def all_hosts &block
+      @hosts.each { |h| block.call(h) }
+    end
+
+    def to_s
+      m = lambda { |a,x| x.nil? ? "" : "\r\n#{a}=#{x.inspect}" }
+      "#<#{self.class} #{m.call('ports', @ports)} #{m.call('hosts', @hosts)}>"
+    end
+
+  end
+
+end

data/lib/waitress/handlers/dirhandler.rb

@@ -0,0 +1,39 @@
+module Waitress
+
+  # The DirHandler class is an instance of +Waitress::Handler+ that is responsible
+  # for loading files from the filesystem and serving them if they exist in the VHost's
+  # root. It automatically handles mimetypes, evaluation and almost everything about
+  # the serving process for files in the FileSystem.
+  class DirHandler < Handler
+
+    attr_accessor :priority
+    attr_accessor :directory
+
+    # Get the instance of DirHandler that will load Waitress' resources
+    # such as the default 404 and index pages, as well as CSS and JS
+    def self.resources_handler
+      @@resources_handler ||= Waitress::DirHandler.new(Waitress::Chef.resources_http, -1000)
+      @@resources_handler
+    end
+
+    # Create a new DirHandler, with the given FileSystem directory as a root
+    # and priority.
+    def initialize directory, priority=50
+      @directory = File.absolute_path(directory)
+      @priority = priority
+    end
+
+    def respond? request, vhost
+      path = File.expand_path File.join("#{directory}", request.path)
+      res = Waitress::Chef.find_file(path)[:result]
+      path.include?(directory) && (res == :ok)
+    end
+
+    def serve request, response, client, vhost
+      path = File.expand_path File.join("#{directory}", request.path)
+      file = Waitress::Chef.find_file(path)[:file]
+      Waitress::Chef.serve_file request, response, client, vhost, file
+    end
+
+  end
+end

data/lib/waitress/handlers/handler.rb

@@ -0,0 +1,57 @@
+module Waitress
+
+  # The Handler class is responsible for handling incoming HTTP requests for a
+  # given URL Path. This default class works by matching a regular expression to
+  # the request path, however subclasses may choose to use their own matching
+  # methods (see +Waitress::DirHandler+).
+  #
+  # Each Handler acts off of a priority system, where if multiple handlers
+  # can respond to the request, the one with the highest priority will be chosen.
+  class Handler
+
+    attr_accessor :priority
+
+    # Create a new Regex-Based Handler
+    # Params:
+    # +regex+:: The regex pattern to match against the request path
+    # +priority+:: Priority of the handler. Default: 50
+    # +action+:: The block to call when a match is reached. Should take args
+    # request, response, client and vhost.
+    def initialize regex=nil, priority=50, &action
+      @regex = regex
+      @action = action
+      @priority = priority
+    end
+
+    # Returns true if this handler is valid for the given request
+    def respond? request, vhost
+      (request.path =~ @regex) != nil
+    end
+
+    # Don't touch this -- this adds Kernel bindings
+    def serve! request, response, client, vhost
+      kernel_prepare
+      serve request, response, client, vhost
+    end
+
+    # If we can respond to the request, this method is called to
+    # serve a response based on this handler. Do your response logic here.
+    # Params:
+    # +request+:: The +Waitress::Request+ object
+    # +response+:: The +Waitress::Response+ object
+    # +client+:: The client socket
+    # +vhost+:: The Virtual Host responsible for the connection
+    def serve request, response, client, vhost
+      @action.call(request, response, client, vhost) unless @action.nil?
+    end
+
+  end
+
+  # The ErrorHandler has the lowest priority, as it shouldn't be triggered
+  # unless there is an error (i.e. 404, 500)
+  class ErrorHandler < Handler
+    def initialize
+      @priority = -65536
+    end
+  end
+end

data/lib/waitress/handlers/handler404.rb

@@ -0,0 +1,25 @@
+module Waitress
+  
+  # The 404 Handler is a simple "Catch-All" handler which will be triggered if
+  # a valid handler is not found for the page, and will show an error page
+  # telling the user the page cannot be found
+  class Handler404 < ErrorHandler
+
+    def serve request, response, client, vhost
+      response.status 404
+      e404page = vhost.get_404
+      if !e404page.nil? && (Waitress::Chef.find_file(e404page)[:result]==:ok)
+        Waitress::Chef.serve_file request, response, client, vhost, e404page
+      else
+        if vhost.resources?
+          h = File.join Waitress::Chef.resources_http, "404.html"
+          Waitress::Chef.serve_file request, response, client, vhost, h
+        else
+          response.mime ".html"
+          response.body "<h1> 404 - Not Found </h1> <p> The page you have requested is not here </p>"
+        end
+      end
+    end
+
+  end
+end