harbor 0.16.1

data/lib/harbor/contrib/session/data_mapper.rb

@@ -0,0 +1,74 @@
+require "dm-core"
+require "dm-timestamps"
+
+module Harbor
+  module Contrib
+    class Session
+      ##
+      # This is a database backed session handle for DataMapper. You can use it
+      # instead of the builtin Harbor::Session::Cookie by doing:
+      # 
+      # Harbor::Session.configure do |session|
+      #   session.store = Harbor::Contrib::Session::DataMapper
+      # end
+      # 
+      # A basic Session resource is defined for you.
+      ##
+      class DataMapper < Harbor::Session::Abstract
+
+        class SessionHash < Hash
+          def initialize(instance)
+            super()
+            @instance = instance
+            merge!(@instance.data)
+          end
+
+          def [](key)
+            key == :session_id ? @instance.id : super
+          end
+
+          def []=(key, value)
+            raise ArgumentError.new("You cannot manually set the session_id for a session.") if key == :session_id
+
+            super
+          end
+
+          def to_hash
+            {}.merge(reject { |key,| key == :session_id })
+          end
+
+          def instance
+            @instance
+          end
+        end
+
+        def self.load_session(cookie)
+          session = if expire_after = Harbor::Session.options[:expire_after]
+            ::Session.first(:id => cookie, :created_at.gte => Time.now - expire_after)
+          else
+            ::Session.get(cookie)
+          end
+
+          session ||= ::Session.create
+
+          SessionHash.new(session)
+        end
+
+        def self.commit_session(data)
+          record = data.instance
+          record.update_attributes(:data => data.to_hash)
+          record.id
+        end
+      end
+    end
+
+    class ::Session #:nodoc:
+      include DataMapper::Resource
+
+      property :id, String, :key => true, :default => lambda { `uuidgen`.chomp }
+      property :data, Object, :default => {}
+      property :created_at, DateTime
+      property :updated_at, DateTime
+    end
+  end
+end

data/lib/harbor/daemon.rb

@@ -0,0 +1,105 @@
+module Harbor
+
+  class Daemon
+    
+    START_CONTEXT = {
+      :argv => ARGV.map { |arg| arg.dup },
+      :cwd => `/bin/sh -c pwd`.chomp("\n"),
+      :cmd => $0.dup
+    }
+
+    DEFAULT_SLEEP_SECONDS = 60
+
+    attr_accessor :logger
+    attr_reader :worker, :options
+
+    def initialize(worker, log_file, seconds_between_runs = DEFAULT_SLEEP_SECONDS)
+      @worker = worker
+
+      # The template may include the tag %PID to be replaced with
+      # the PID of the forked worker process.  Don't use @log_file
+      # directly, use self.log_file
+      @log_file_template = log_file
+      
+      @seconds_between_runs = seconds_between_runs
+    end
+    
+    def log_file
+      @log_file ||= @log_file_template.gsub('%PID', Process.pid.to_s)      
+    end
+    
+    def detach
+      srand
+      fork and exit
+      Process.setsid # detach -- we want to be able to close our shell!
+
+      log_directory = ::File.dirname(self.log_file)
+      ::File.mkdir_p(log_directory) unless ::File.directory?(log_directory)
+
+      redirect_io(@log_file)
+    end
+    
+    def run
+      @restart = false
+      @alive = true
+    
+      # graceful restart
+      trap(:HUP) do
+        logger.info "Restarting gracefully." if logger
+        @restart = true
+        @alive = nil
+        @worker.alive = nil
+      end
+    
+      # graceful shutdown
+      trap(:QUIT) do
+        logger.info "Shutting down gracefully." if logger
+        @alive = nil
+        @worker.alive = nil
+      end
+    
+      # quick exit
+      [:TERM, :INT].each do |sig|
+        trap(sig) do
+          logger.info "Shutting down NOW" if logger
+          cleanup!
+    
+          exit!(0)
+        end
+      end
+      
+      begin
+        @worker.run
+        sleep(@seconds_between_runs) if @alive
+      end while @alive
+        
+      if @restart
+        logger.info "Starting new daemon..."
+        fork do
+          Dir.chdir(START_CONTEXT[:cwd])
+          exec(START_CONTEXT[:cmd], *START_CONTEXT[:argv])
+        end
+      end
+
+      logger.info "Shutting down..." if logger
+      cleanup!
+    end
+    
+    def cleanup!
+      worker.cleanup! if worker.respond_to?(:cleanup!)
+    end
+
+    private
+    
+    def redirect_io(file = nil)
+      STDIN.reopen "/dev/null"
+      STDOUT.reopen file || "/dev/null"
+      STDOUT.sync = true
+
+      STDERR.reopen STDOUT
+      STDERR.sync = true
+    end
+
+  end
+
+end

data/lib/harbor/errors.rb

@@ -0,0 +1,49 @@
+module Harbor
+
+  class Errors
+  
+    include Enumerable
+  
+    def initialize(errors = [])
+      @errors = errors
+    end
+  
+    def [](index)
+      errors[index]
+    end
+  
+    def <<(message)
+      if message.is_a?(String)
+        errors << message
+      elsif message.is_a?(Enumerable)
+        message.each do |error_message|
+          errors << error_message
+        end
+      else
+        errors << message
+      end
+    end
+  
+    def each
+      errors.each do |error|
+        yield error
+      end
+    end
+  
+    def size
+      errors.size
+    end
+  
+    def +(other)
+      Errors.new((errors + other.errors).uniq)
+    end
+
+    protected
+  
+    def errors
+      @errors
+    end
+
+  end
+
+end

data/lib/harbor/events.rb

@@ -0,0 +1,45 @@
+module Harbor
+  module Events
+
+    def self.included(target)
+      target.extend(ClassMethods)
+    end
+    
+    def raise_event(name, *args)
+      if self.class.events[name].nil?
+        return false
+      else
+        self.class.events[name].each do |event|
+          event.call(*args)
+        end
+        return true
+      end
+    end
+    
+    module ClassMethods
+      
+      def events
+        class_variable_defined?(:@@events) ? class_variable_get(:@@events) : class_variable_set(:@@events, {})
+      end
+      
+      def events=(hash)
+        events.replace(hash)
+      end
+      
+      def register_event(name, &block)
+        events[name] ||= []
+        events[name] << block
+      end
+      
+      def clear_events!(name=nil)
+        if name
+          events[name] = nil
+        else
+          events = {}
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/harbor/exception_notifier.rb

@@ -0,0 +1,59 @@
+module Harbor
+  ##
+  # Utility class for receiving email notifications of exceptions in
+  # non-development environments.
+  # 
+  #   services.register("mailer", Harbor::Mailer)
+  #   services.register("mail_server", Harbor::SendmailServer)
+  #   
+  #   require 'harbor/exception_notifier'
+  # 
+  # You will then receive email alerts for all 500 errors in the format of:
+  # 
+  #   From:     errors@request_host
+  #   Subject:  [ERROR] [request_host] [environment] Exception description
+  #   Body:     stack trace found in log, with request details.
+  ##
+  class ExceptionNotifier
+
+    def self.notification_address=(address)
+      @@notification_address = address
+    end
+
+    def self.notification_address
+      @@notification_address
+    rescue NameError
+      raise "Harbor::ExceptionMailer.notification_address not set."
+    end
+
+    def self.notification_address?
+      defined?(@@notification_address)
+    end
+
+    def self.notify(exception, request, response, trace)
+      return if request.environment == "development" 
+
+      mailer = request.application.services.get("mailer")
+      mailer.to = notification_address
+
+      host = request.env["HTTP_X_FORWARDED_HOST"] || request.host
+      mailer.from = "errors@#{host}"
+
+      subject = exception.to_s
+
+      # We can't have multi-line subjects, so we chop off extra lines
+      if subject[$/]
+        subject = subject.split($/, 2)[0] + "..."
+      end
+
+      mailer.subject = "[ERROR] [#{request.host}] [#{request.environment}] #{subject}"
+      mailer.text = trace
+      mailer.set_header("X-Priority", 1)
+      mailer.set_header("X-MSMail-Priority", "High")
+      mailer.send!
+    end
+
+  end
+end
+
+Harbor::Application.register_event(:exception) { |*args| Harbor::ExceptionNotifier.notify(*args) }

data/lib/harbor/file.rb

@@ -0,0 +1,66 @@
+require 'fileutils'
+
+module Harbor
+
+  class File
+
+    attr_accessor :path, :name
+
+    def initialize(path, name = nil)
+      @path = path
+      @name = name || ::File.basename(@path)
+    end
+    
+    def read(block_size)
+      @io ||= File.open(@path, "rb")
+      yield @io.read(block_size)
+    end
+    
+    def rewind
+      @io ||= File.open(@path, "rb")
+      @io.rewind
+    end
+
+    def size
+      ::File.size(@path)
+    end
+
+    ##
+    # The file is first copied, and then the provided block is run.
+    # If no errors occur, the source file is deleted. If an error
+    # occurs, the copied file is removed and the directory cleaned.
+    ##
+    def self.move_safely(from, to, mode = 0666 - ::File.umask)
+      raise ArgumentError.new("no block given") unless block_given?
+
+      FileUtils.mkdir_p(::File.dirname(to))
+      FileUtils.cp(from, to)
+      FileUtils.chmod(mode, to)
+      begin
+        yield
+        FileUtils.rm(from)
+      rescue
+        FileUtils.rm(to)
+        rmdir_p(::File.dirname(to))
+        raise $!
+      end
+    end
+
+    ##
+    # Recursively delete empty directories as mkdir -p recursively
+    # creates directories.
+    ##
+    def self.rmdir_p(directory)
+      `rmdir -p #{Shellwords.escape(directory)} &> /dev/null`
+    end
+
+    ##
+    # Moves a file and gives it the default file permissions minus the
+    # declared umask unless another mode is specified.
+    ##
+    def self.move(from, to, mode = 0666 - ::File.umask)
+      FileUtils.mv(from, to)
+      FileUtils.chmod(mode, to)
+    end
+  end
+end

data/lib/harbor/file_store.rb

@@ -0,0 +1,69 @@
+module Harbor
+  class FileStore
+
+    require Pathname(__FILE__).dirname + "file_store/file"
+    require Pathname(__FILE__).dirname + "file_store/local"
+    
+    @@registrations = []
+
+    def self.register(name, store)
+      @@registrations.push name
+      file_stores[name] = store
+    end
+
+    def self.file_stores
+      @@file_stores ||= {}
+    end
+
+    def self.[](name)
+      file_stores[name]
+    end
+    
+    def self.exists?(path)
+      @@registrations.each do |registration|
+        if file_stores[registration].exists?(path) == true
+          return true
+        end
+      end
+      false
+    end
+    
+    def self.get(path)
+      @@registrations.each do |registration|
+        if file_stores[registration].exists?(path) == true
+          return file_stores[registration].get(path)
+        end
+      end
+      nil
+    end
+
+    def put(path, file)
+      raise NotImplementedError.new("You must define your own implementation of FileStore#put")
+    end
+
+    def delete(path)
+      raise NotImplementedError.new("You must define your own implementation of FileStore#delete")
+    end
+
+    def exists?(path)
+      raise NotImplementedError.new("You must define your own implementation of FileStore#exists?")
+    end
+
+    def open(path)
+      raise NotImplementedError.new("You must define your own implementation of FileStore#open")
+    end
+
+    def size(path)
+      raise NotImplementedError.new("You must define your own implementation of FileStore#size")
+    end
+
+    ##
+    # Defines whether a file store is local, and thus could be directly copied rather
+    # than read and then written.
+    ##
+    def local?
+      raise NotImplementedError.new("You must define your own implementation of FileStore#local?")
+    end
+
+  end
+end