harbor 0.16.1

data/Rakefile

@@ -0,0 +1,76 @@
+require "rubygems"
+require "pathname"
+require "rake"
+require "rake/rdoctask"
+require "rake/testtask"
+
+# Tests
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+# rdoc
+
+# desc "Generate RDoc documentation"
+# Rake::RDocTask.new(:rdoc) do |rdoc|
+#   rdoc.options << '--line-numbers' << '--inline-source' <<
+#     '--main' << 'README' <<
+#     '--title' << 'Harbor Documentation' <<
+#     '--charset' << 'utf-8' << "--exclude" << "lib/harbor/generator/"
+#   rdoc.rdoc_dir = "doc"
+#   rdoc.rdoc_files.include 'README'
+#   rdoc.
+#   rdoc.rdoc_files.include('lib/rack.rb')
+#   rdoc.rdoc_files.include('lib/rack/*.rb')
+#   rdoc.rdoc_files.include('lib/rack/*/*.rb')
+# end
+
+task :rdoc do
+  sh <<-EOS.strip
+rdoc -T harbor#{" --op " + ENV["OUTPUT_DIRECTORY"] if ENV["OUTPUT_DIRECTORY"]} --line-numbers --main README --title "Harbor Documentation" --exclude "lib/harbor/generator/*" lib/harbor.rb lib/harbor README
+  EOS
+end
+
+# Performance
+task :perf => :performance
+task :performance do
+  puts `ruby #{Pathname(__FILE__).dirname + "script/performance.rb"}`
+end
+
+# Gem
+
+require "lib/harbor/version"
+require "rake/gempackagetask"
+
+NAME = "harbor"
+SUMMARY = "Harbor Framework"
+GEM_VERSION = Harbor::VERSION
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.summary = s.description = SUMMARY
+  s.author = "Wieck Media"
+  s.homepage = "http://wiecklabs.com"
+  s.email = "dev@wieck.com"
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.require_path = 'lib'
+  s.files = %w(Rakefile) + Dir.glob("lib/**/*")
+  s.executables = ['harbor']
+
+  s.add_dependency "rack", "~> 1.0.0"
+  s.add_dependency "erubis"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install Harbor as a gem"
+task :install => [:repackage] do
+  sh %{gem install pkg/#{NAME}-#{GEM_VERSION}}
+end

data/bin/harbor

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require File.expand_path(File.dirname(__FILE__) + '/../lib/harbor/generator')
+
+command = ARGV.shift
+
+Harbor::Generator.run('harbor', command, ARGV)

data/lib/harbor.rb

@@ -0,0 +1,17 @@
+require "rubygems"
+require "pathname"
+
+$:.unshift(Pathname(__FILE__).dirname.expand_path)
+
+require "harbor/version"
+require "harbor/hooks"
+require "harbor/file_store"
+require "harbor/shellwords"
+require "harbor/file"
+require "harbor/container"
+require "harbor/router"
+require "harbor/application"
+require "harbor/cascade"
+require "harbor/plugin"
+require "harbor/mime"
+require "harbor/errors"

data/lib/harbor/accessor_injector.rb

@@ -0,0 +1,30 @@
+module Harbor
+  ##
+  # A simple module to facilitate accessor based injection. This is used by Harbor::Plugin
+  # to allow you to easily construct plugins from hashes, i.e.:
+  # 
+  #   <%= plugin("user/tabs", :user => @user)
+  # 
+  # It can of course be used for anything, however:
+  # 
+  #   class Dog
+  #     include Harbor::AccessorInjector
+  #     attr_accessor :owner
+  #   end
+  # 
+  #   dog = Dog.new.inject(:owner => "Tom")
+  #   dog.owner # => "Tom"
+  ##
+  module AccessorInjector
+
+    def inject(options = {})
+      options.each do |key, value|
+        setter = "#{key}="
+        send(setter, value) if respond_to?(setter)
+      end
+
+      self
+    end
+
+  end
+end

data/lib/harbor/application.rb

@@ -0,0 +1,172 @@
+gem "rack", "~> 1.0.0"
+require "rack"
+
+require "yaml"
+
+require Pathname(__FILE__).dirname + "request"
+require Pathname(__FILE__).dirname + "response"
+require Pathname(__FILE__).dirname + "block_io"
+require Pathname(__FILE__).dirname + "zipped_io"
+require Pathname(__FILE__).dirname + "events"
+require Pathname(__FILE__).dirname + "messages"
+
+module Harbor
+  class Application
+
+    include Harbor::Events
+    
+    ##
+    # Routes are defined in this method. Note that Harbor does not define any default routes,
+    # so you must reimplement this method in your application.
+    ##
+    def self.routes(services)
+      raise NotImplementedError.new("Your application must redefine #{self}::routes.")
+    end
+
+    attr_reader :router, :environment, :services
+
+    def initialize(services, *args)
+      unless services.is_a?(Harbor::Container)
+        raise ArgumentError.new("Harbor::Application#services must be a Harbor::Container")
+      end
+
+      @services = services
+
+      @router = (!args.empty? && !args[0].is_a?(String) && args[0].respond_to?(:match)) ? args.shift : self.class.routes(@services)
+      @environment = args.last || "development"
+    end
+
+    ##
+    # Request entry point called by Rack. It creates a request and response
+    # object based on the incoming request environment, checks for public
+    # files, and dispatches the request.
+    # 
+    # It returns a rack response hash.
+    ##
+    def call(env)
+      env["APP_ENVIRONMENT"] = environment
+      request = Request.new(self, env)
+      response = Response.new(request)
+
+      catch(:abort_request) do
+        if file = find_public_file(request.path_info[1..-1])
+          response.cache(nil, ::File.mtime(file), 86400) do
+            response.stream_file(file)
+          end
+
+          return response.to_a
+        end
+
+        handler = @router.match(request)
+
+        dispatch_request(handler, request, response)
+      end
+
+      response.to_a
+    end
+
+    ##
+    # Request dispatch function, which handles 404's, exceptions,
+    # and logs requests.
+    ##
+    def dispatch_request(handler, request, response)
+      start = Time.now
+
+      return handle_not_found(request, response) unless handler
+
+      handler.call(request, response)
+    rescue StandardError, LoadError, SyntaxError => e
+      handle_exception(e, request, response)
+    ensure
+      raise_event(:request_complete, request, response, start, Time.now)
+    end
+
+    ##
+    # Method used to nicely handle cases where no routes or public files
+    # match the incoming request.
+    # 
+    # By default, it will render "The page you requested could not be found".
+    # 
+    # To use a custom 404 message, create a view "exceptions/404.html.erb", and
+    # optionally create a view "layouts/exception.html.erb" to style it.
+    ##
+    def handle_not_found(request, response)
+      response.flush
+      response.status = 404
+
+      response.layout = "layouts/exception" if Harbor::View.exists?("layouts/exception")
+
+      if Harbor::View.exists?("exceptions/404.html.erb")
+        response.render "exceptions/404.html.erb"
+      else
+        response.puts "The page you requested could not be found"
+      end
+
+      raise_event(:not_found, request, response)
+    end
+
+    ##
+    # Method used to nicely handle uncaught exceptions.
+    # 
+    # Logs full error messages to the configured 'error' logger.
+    # 
+    # By default, it will render "We're sorry, but something went wrong."
+    # 
+    # To use a custom 500 message, create a view "exceptions/500.html.erb", and
+    # optionally create a view "layouts/exception.html.erb" to style it.
+    ##
+    def handle_exception(exception, request, response)
+      response.flush
+      response.status = 500
+
+      trace = build_exception_trace(exception, request)
+
+      if environment == "development"
+        response.content_type = "text/html"
+        response.puts(Rack::ShowExceptions.new(nil).pretty(request.env, exception))
+      else
+        response.layout = "layouts/exception" if Harbor::View.exists?("layouts/exception")
+
+        if Harbor::View.exists?("exceptions/500.html.erb")
+          response.render "exceptions/500.html.erb", :exception => exception
+        else
+          response.puts "We're sorry, but something went wrong."
+        end
+      end
+
+      raise_event(:exception, exception, request, response, trace)
+
+      nil
+    end
+
+    def find_public_file(file) #:nodoc:
+      public_path = Pathname(self.class.respond_to?(:public_path) ? self.class.public_path : "public")
+      path = public_path + file
+
+      path.file? ? path : nil
+    end
+
+    def default_layout
+      warn "Harbor::Application#default_layout has been deprecated. See Harbor::Layouts."
+    end
+
+    private
+
+    def build_exception_trace(exception, request)
+      trace = ""
+      trace << "="*80
+      trace << "\n"
+      trace << "== [ #{self.class}: #{exception} @ #{Time.now} ] =="
+      trace << "\n"
+      trace << exception.backtrace.join("\n")
+      trace << "\n"
+      trace << "== [ Request ] =="
+      trace << "\n"
+      trace << request.env.to_yaml
+      trace << "\n"
+      trace << "="*80
+      trace << "\n"
+    end
+
+  end
+end

data/lib/harbor/auth/basic.rb

@@ -0,0 +1,51 @@
+module Harbor
+  module Auth
+    ##
+    # Simple mechanism for implementing HTTP basic authentication.
+    # 
+    #   get("/secret-page") do |request, response|
+    #     Harbor::Auth::Basic.authenticate(request, response) { |username, password| username == "wieck" }
+    # 
+    #     response.puts "Secret Stuff"
+    #   end
+    ##
+    class Basic
+
+      AUTHORIZATION_KEYS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION']
+
+      attr_accessor :realm
+
+      ##
+      # Checks the credentials provided in the request against the provided
+      # block. If the block returns false, the request aborted.
+      ##
+      def self.authenticate(request, response) #:yields: username, password
+        auth = new(request)
+
+        unless auth.provided? && yield(auth.credentials)
+          response.headers["WWW-Authenticate"] = 'Basic realm="%s"' % auth.realm
+          response.unauthorized!
+        end
+      end
+
+      def initialize(request)
+        @request = request
+      end
+
+      def provided?
+        !!authorization_key
+      end
+
+      def credentials
+        @request.env[authorization_key].split(' ', 2).last.unpack("m*").first.split(/:/, 2)
+      end
+
+      private
+
+      def authorization_key
+        @authorization_key ||= AUTHORIZATION_KEYS.detect { |key| @request.env.has_key?(key) }
+      end
+
+    end
+  end
+end

data/lib/harbor/block_io.rb

@@ -0,0 +1,63 @@
+module Harbor
+  ##
+  # Used by Harbor::Response#send_file and Harbor::Response#stream_file to send
+  # large files or streams in chunks. This is a fallback measure for the cases
+  # where X-Sendfile cannot be used.
+  ##
+  class BlockIO
+
+    def self.block_size
+      @@block_size ||= 500_000 # 500kb
+    end
+    
+    def self.block_size=(value)
+      raise ArgumentError.new("Harbor::BlockIO::block_size value must be a Fixnum") unless value.is_a?(Fixnum)
+      @@block_size = value
+    end
+    
+    def initialize(path_or_io)
+      case path_or_io
+      when ::IO
+        @io = path_or_io
+        @size = @io.stat.size
+      when StringIO
+        @io = path_or_io
+        @size = @io.size
+      when Harbor::FileStore::File
+        @io = path_or_io
+        @size = @io.size
+        @path = path_or_io.absolute_path
+      when Pathname
+        @path = path_or_io.expand_path.to_s
+        @io = path_or_io.open('r')
+        @size = path_or_io.size
+      else
+        @path = path_or_io.to_s
+        @io = ::File::open(@path, 'r')
+        @size = ::File.size(@path)
+      end
+    end
+
+    def path
+      @path
+    end
+
+    def to_s
+      @io.read
+    end
+
+    def size
+      @size
+    end
+
+    def close
+      @io.close
+    end
+
+    def each
+      while data = @io.read(Harbor::BlockIO::block_size) do
+        yield data
+      end
+    end
+  end
+end

data/lib/harbor/cache.rb

@@ -0,0 +1,90 @@
+require "thread"
+require Pathname(__FILE__).dirname + "cache/item"
+
+module Harbor
+
+  class Cache
+
+    class PutArgumentError < ArgumentError; end
+
+    attr_accessor :logger
+
+    def initialize(store)
+      raise ArgumentError.new("Harbor::Cache.new expects a non-null 'store' parameter") unless store
+
+      @store = store
+      @semaphore = Mutex.new
+    end
+
+    def put(key, content, ttl, maximum_age = nil)
+      raise PutArgumentError.new("Harbor::Cache::Memory#put expects a String value for 'key', got #{key}") unless key.is_a?(String)
+      raise PutArgumentError.new("Harbor::Cache::Memory#put expects a Fixnum value greater than 0 for 'ttl', got #{ttl}") unless ttl.is_a?(Fixnum) && ttl > 0
+      raise PutArgumentError.new("Harbor::Cache::Memory#put expects nil, or a Fixnum value greater than 0 for 'maximum_age', got #{maximum_age}") unless maximum_age.nil? || (maximum_age.is_a?(Fixnum) && maximum_age > 0)
+      raise PutArgumentError.new("Harbor::Cache::Memory#put expects a maximum_age greater than the ttl, got ttl: #{ttl}, maximum_age: #{maximum_age}") if maximum_age && ttl && (maximum_age <= ttl)
+
+      @semaphore.synchronize do
+        # Prevent multiple writes of similar content to the cache
+        return true if (cached_item = @store.get(key)) && cached_item.fresh? && cached_item.content.hash == content.hash
+        @store.put(key, ttl, maximum_age, content, Time.now)
+      end
+    rescue
+      log("Harbor::Cache#put unable to store cached content.", $!)
+
+      raise if $!.is_a?(PutArgumentError)
+    ensure
+      content
+    end
+
+    def get(key)
+      if item = @store.get(key)
+        if item.fresh?
+          @semaphore.synchronize do
+            @store.bump(key)
+          end
+
+          item
+        else
+          delete(key)
+
+          item = nil
+        end
+      else
+        item = nil
+      end
+    rescue
+      log("Harbor::Cache#get unable to retrieve cached content.", $!)
+    ensure
+      defined?(item) ? item : nil
+    end
+
+    def delete(key)
+      @semaphore.synchronize do
+        @store.delete(key)
+      end
+    rescue
+      log("Harbor::Cache#put unable to delete cached content.", $!)
+    ensure
+      nil
+    end
+
+    def delete_matching(key)
+      @semaphore.synchronize do
+        @store.delete_matching(key)
+      end
+    rescue
+      log("Harbor::Cache#put unable to delete cached content.", $!)
+    ensure
+      nil
+    end
+
+    private
+
+    def log(message, error)
+      if @logger
+        @logger.fatal("#{message} #{$!}\n#{$!.message}\nBacktrace:\n#{$!.backtrace.join("\n")}")
+      end
+    end
+
+  end
+
+end