sdsykes_acts_as_ferret 0.4.3.1

data/lib/remote_index.rb

@@ -0,0 +1,50 @@
+require 'drb'
+module ActsAsFerret
+
+  # This index implementation connects to a remote ferret server instance. It
+  # basically forwards all calls to the remote server.
+  class RemoteIndex < AbstractIndex
+
+    def initialize(config)
+      @config = config
+      @ferret_config = config[:ferret]
+      @server = DRbObject.new(nil, config[:remote])
+    end
+
+    def method_missing(method_name, *args)
+      args.unshift model_class_name
+      @server.send(method_name, *args)
+    end
+
+    def find_id_by_contents(q, options = {}, &proc)
+      total_hits, results = @server.find_id_by_contents(model_class_name, q, options)
+      block_given? ? yield_results(total_hits, results, &proc) : [ total_hits, results ]
+    end
+
+    def id_multi_search(query, models, options, &proc)
+      total_hits, results = @server.id_multi_search(model_class_name, query, models, options)
+      block_given? ? yield_results(total_hits, results, &proc) : [ total_hits, results ]
+    end
+
+    # add record to index
+    def add(record)
+      @server.add record.class.name, record.to_doc
+    end
+    alias << add
+
+    private
+
+    def yield_results(total_hits, results)
+      results.each do |result|
+        yield result[:model], result[:id], result[:score], result[:data]
+      end
+      total_hits
+    end
+
+    def model_class_name
+      @config[:class_name]
+    end
+
+  end
+
+end

data/lib/search_results.rb

@@ -0,0 +1,53 @@
+module ActsAsFerret
+
+  # decorator that adds a total_hits accessor and will_paginate compatible 
+  # paging support to search result arrays
+  class SearchResults
+    attr_reader :current_page, :per_page, :total_hits
+
+    def initialize(results, total_hits, current_page = 1, per_page = nil)
+      @results = results
+      @total_hits = total_hits
+      @current_page = current_page
+      @per_page = (per_page || total_hits)
+      @total_pages   = @per_page > 0 ? (@total_hits / @per_page.to_f).ceil : 0
+    end
+
+    def method_missing(symbol, *args, &block)
+      @results.send(symbol, *args, &block)
+    end
+
+    def respond_to?(name)
+      self.methods.include?(name) || @results.respond_to?(name)
+    end
+
+
+    # code from here on was directly taken from will_paginate's collection.rb
+
+    #
+    # The total number of pages.
+    def page_count
+      @total_pages
+    end
+
+    # Current offset of the paginated collection. If we're on the first page,
+    # it is always 0. If we're on the 2nd page and there are 30 entries per page,
+    # the offset is 30. This property is useful if you want to render ordinals
+    # besides your records: simply start with offset + 1.
+    #
+    def offset
+      (current_page - 1) * per_page
+    end
+
+    # current_page - 1 or nil if there is no previous page
+    def previous_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+
+    # current_page + 1 or nil if there is no next page
+    def next_page
+      current_page < page_count ? (current_page + 1) : nil
+    end
+  end
+
+end

data/lib/server_manager.rb

@@ -0,0 +1,46 @@
+################################################################################
+require 'optparse'
+
+################################################################################
+$ferret_server_options = {
+  'environment' => nil,
+  'debug'       => nil,
+}
+
+################################################################################
+OptionParser.new do |optparser|
+  optparser.banner = "Usage: #{File.basename($0)} [options] {start|stop}"
+
+  optparser.on('-h', '--help', "This message") do
+    puts optparser
+    exit
+  end
+
+  optparser.on('-e', '--environment=NAME', 'Set RAILS_ENV to the given string') do |e|
+    $ferret_server_options['environment'] = e
+  end
+
+  optparser.on('--debug', 'Include full stack traces on exceptions') do
+    $ferret_server_options['debug'] = true
+  end
+
+  $ferret_server_action = optparser.permute!(ARGV)
+  (puts optparser; exit(1)) unless $ferret_server_action.size == 1
+
+  $ferret_server_action = $ferret_server_action.first
+  (puts optparser; exit(1)) unless %w(start stop).include?($ferret_server_action)
+end
+
+################################################################################
+begin
+  ENV['FERRET_USE_LOCAL_INDEX'] = 'true'
+  ENV['RAILS_ENV'] = $ferret_server_options['environment']
+  #require(File.join(File.dirname(__FILE__), '../../../../config/environment'))
+  require(File.join(File.dirname(ENV['_']), '../config/environment'))
+  require 'acts_as_ferret'
+  ActsAsFerret::Remote::Server.new.send($ferret_server_action)
+rescue Exception => e
+  $stderr.puts(e.message)
+  $stderr.puts(e.backtrace.join("\n")) if $ferret_server_options['debug']
+  exit(1)
+end

data/lib/shared_index.rb

@@ -0,0 +1,14 @@
+module ActsAsFerret
+  
+  class SharedIndex < LocalIndex
+
+    # build a ferret query matching only the record with the given id and class
+    def query_for_record(id, class_name)
+      (bq = Ferret::Search::BooleanQuery.new).tap do
+        bq.add_query(Ferret::Search::TermQuery.new(:id,         id.to_s),    :must)
+        bq.add_query(Ferret::Search::TermQuery.new(:class_name, class_name), :must)
+      end
+    end
+
+  end
+end

data/lib/shared_index_class_methods.rb

@@ -0,0 +1,90 @@
+module ActsAsFerret
+  
+  # class methods for classes using acts_as_ferret :single_index => true
+  module SharedIndexClassMethods
+
+    def find_id_by_contents(q, options = {}, &block)
+      # add class name scoping to query if necessary
+      unless options[:models] == :all # search needs to be restricted by one or more class names
+        options[:models] ||= [] 
+        # add this class to the list of given models
+        options[:models] << self unless options[:models].include?(self)
+        # keep original query 
+        original_query = q
+        
+        if original_query.is_a? String
+          model_query = options[:models].map(&:name).join '|'
+          q += %{ +class_name:"#{model_query}"}
+        else
+          q = Ferret::Search::BooleanQuery.new
+          q.add_query(original_query, :must)
+          model_query = Ferret::Search::BooleanQuery.new
+          options[:models].each do |model|
+            model_query.add_query(Ferret::Search::TermQuery.new(:class_name, model.name), :should)
+          end
+          q.add_query(model_query, :must)
+        end
+      end
+      options.delete :models
+      
+      super(q, options, &block)
+    end
+
+    # Overrides the standard find_by_contents for searching a shared index.
+    #
+    # please note that records from different models will be fetched in
+    # separate sql calls, so any sql order_by clause given with 
+    # find_options[:order] will be ignored.
+    def find_by_contents(q, options = {}, find_options = {})
+      if order = find_options.delete(:order)
+        logger.warn "using a shared index, so ignoring order_by clause #{order}"
+      end
+      total_hits, result = find_records_lazy_or_not q, options, find_options
+      # sort so results have the same order they had when originally retrieved
+      # from ferret
+      return SearchResults.new(result, total_hits)
+    end
+
+    protected
+
+    def ar_find_by_contents(q, options = {}, find_options = {})
+      total_hits, id_arrays = collect_results(q, options)
+      result = retrieve_records(id_arrays, find_options)
+      result.sort! { |a, b| id_arrays[a.class.name][a.id.to_s].first <=> id_arrays[b.class.name][b.id.to_s].first }
+      [ total_hits, result ]
+    end
+
+    def collect_results(q, options = {})
+      id_arrays = {}
+      # get object ids for index hits
+      rank = 0
+      total_hits = find_id_by_contents(q, options) do |model, id, score, data|
+        id_arrays[model] ||= {}
+        # store result rank and score
+        id_arrays[model][id] = [ rank += 1, score ]
+      end
+      [ total_hits, id_arrays ]
+    end
+
+    
+    # determine all field names in the shared index
+    # TODO unused
+#    def single_index_field_names(models)
+#      @single_index_field_names ||= (
+#          searcher = Ferret::Search::Searcher.new(class_index_dir)
+#          if searcher.reader.respond_to?(:get_field_names)
+#            (searcher.reader.send(:get_field_names) - ['id', 'class_name']).to_a
+#          else
+#            puts <<-END
+#unable to retrieve field names for class #{self.name}, please 
+#consider naming all indexed fields in your call to acts_as_ferret!
+#            END
+#            models.map { |m| m.content_columns.map { |col| col.name } }.flatten
+#          end
+#      )
+#
+#    end
+ 
+  end
+end
+

data/lib/unix_daemon.rb

@@ -0,0 +1,63 @@
+################################################################################
+module ActsAsFerret
+  module Remote
+
+    ################################################################################
+    # methods for becoming a daemon on Unix-like operating systems
+    module UnixDaemon
+
+      ################################################################################
+      def platform_daemon (&block)
+        safefork do
+          write_pid_file
+          trap("TERM") { exit(0) }
+          sess_id = Process.setsid
+          STDIN.reopen("/dev/null")
+          STDOUT.reopen("#{RAILS_ROOT}/log/ferret_server.out", "a")
+          STDERR.reopen(STDOUT)
+          block.call
+        end
+      end
+
+      ################################################################################
+      # stop the daemon, nicely at first, and then forcefully if necessary
+      def stop
+        pid = read_pid_file
+        raise "ferret_server doesn't appear to be running" unless pid
+        $stdout.puts("stopping ferret server...")
+        Process.kill("TERM", pid)
+        30.times { Process.kill(0, pid); sleep(0.5) }
+        $stdout.puts("using kill -9 #{pid}")
+        Process.kill(9, pid)
+      rescue Errno::ESRCH => e
+        $stdout.puts("process #{pid} has stopped")
+      ensure
+        File.unlink(@cfg.pid_file) if File.exist?(@cfg.pid_file)
+      end
+
+      ################################################################################
+      def safefork (&block)
+        @fork_tries ||= 0
+        fork(&block)
+      rescue Errno::EWOULDBLOCK
+        raise if @fork_tries >= 20
+        @fork_tries += 1
+        sleep 5
+        retry
+      end
+
+      #################################################################################
+      # create the PID file and install an at_exit handler
+      def write_pid_file
+        open(@cfg.pid_file, "w") {|f| f << Process.pid << "\n"}
+        at_exit { File.unlink(@cfg.pid_file) if read_pid_file == Process.pid }
+      end
+
+      #################################################################################
+      def read_pid_file
+        File.read(@cfg.pid_file).to_i if File.exist?(@cfg.pid_file)
+      end
+
+    end
+  end
+end

data/script/ferret_daemon

@@ -0,0 +1,94 @@
+# Ferret Win32 Service Daemon, called by Win 32 service, 
+# created by Herryanto Siatono <herryanto@pluitsolutions.com>
+#
+# see doc/README.win32 for usage instructions
+#
+require 'optparse'
+require 'win32/service'
+include Win32
+
+# Read options
+options = {}
+ARGV.options  do |opts|
+  opts.banner = 'Usage: ferret_daemon [options]'
+  opts.on("-l", "--log FILE", "Daemon log file") {|file| options[:log] = file }  
+  opts.on("-c","--console","Run Ferret server on console.") {options[:console] = true}
+  opts.on_tail("-h","--help", "Show this help message") {puts opts; exit}
+  opts.on("-e", "--environment ENV ", "Rails environment") {|env|
+    options[:environment] = env
+    ENV['RAILS_ENV'] = env
+  }
+  opts.parse!
+end
+
+require File.dirname(__FILE__) + '/../config/environment'
+
+# Ferret Win32 Service Daemon, called by Win 32 service, 
+# to run on the console, use -c or --console option.
+module Ferret
+  class FerretDaemon < Daemon
+    # Standard logger to redirect STDOUT and STDERR to a log file
+    class FerretStandardLogger
+      def initialize(logger)
+        @logger = logger
+      end
+      
+      def write(s)
+        @logger.info s
+      end
+    end
+    
+    def initialize(options={})
+      @options = options
+      
+      # initialize logger
+      if options[:log]      
+        @logger = Logger.new @options[:log]
+      else 
+        @logger = Logger.new RAILS_ROOT + "/log/ferret_service_#{RAILS_ENV}.log"
+      end
+      
+      # redirect stout and stderr to Ferret logger if running as windows service
+      $stdout = $stderr = FerretStandardLogger.new(@logger) unless @options[:console]
+      
+      log "Initializing FerretDaemon..."
+      if @options[:console]
+      	self.service_init
+      	self.service_main
+      end
+    end
+    
+    def service_main
+      log "Service main enterred..."
+      
+      while running?
+        log "Listening..."
+        sleep
+      end
+      
+      log "Service main exit..."
+    end
+    
+    def service_init
+      log "Starting Ferret DRb server..."
+      ActsAsFerret::Remote::Server.start
+      log "FerretDaemon started."    
+    end
+    
+    def service_stop
+      log "Stopping service..."
+      DRb.stop_service
+      log "FerretDaemon stopped."
+    end
+    
+    def log(msg)
+      @logger.info msg 
+      puts msg if @options[:console]
+    end
+  end
+end
+
+if __FILE__ == $0
+  d = Ferret::FerretDaemon.new(options)
+  d.mainloop
+end

data/script/ferret_server

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+begin
+  require File.join(File.dirname(__FILE__), '../vendor/plugins/acts_as_ferret/lib/server_manager')
+rescue LoadError
+  # try the gem
+  require 'rubygems'
+  gem 'acts_as_ferret'
+  require 'server_manager'
+end

data/script/ferret_service

@@ -0,0 +1,178 @@
+# Ferret Win32 Service Daemon install script 
+# created by Herryanto Siatono <herryanto@pluitsolutions.com>
+#
+# see doc/README.win32 for usage instructions
+#
+require 'optparse'
+require 'win32/service'
+include Win32
+
+module Ferret
+  # Parse and validate service command and options
+  class FerretServiceCommand
+    COMMANDS = ['install', 'remove', 'start', 'stop', 'help']
+    BANNER = "Usage: ruby script/ferret_service <command> [options]"
+    
+    attr_reader :options, :command
+    
+    def initialize
+      @options = {}
+    end
+    
+    def valid_command?      
+      COMMANDS.include?@command
+    end
+    
+    def valid_options?
+      @options[:name] and !@options[:name].empty?
+    end
+    
+    def print_command_list
+      puts BANNER 
+      puts "\nAvailable commands:\n"
+      puts COMMANDS.map {|cmd| " - #{cmd}\n"}
+      puts "\nUse option -h for each command to help."
+      exit
+    end
+    
+    def validate_options
+      errors = []
+      errors << "Service name is required." unless @options[:name]
+      
+      if (errors.size > 0)
+        errors << "Error found. Use: 'ruby script/ferret_service #{@command} -h' for to get help."
+        puts errors.join("\n")
+        exit
+      end
+    end
+    
+    def run(args)
+      @command = args.shift      
+      @command = @command.dup.downcase if @command
+      
+      # validate command and options      
+      print_command_list unless valid_command? or @command == 'help'
+      
+      opts_parser = create_options_parser
+      begin
+        opts_parser.parse!(args)
+      rescue OptionParser::ParseError => e
+        puts e
+        puts opts_parser
+      end
+      
+      # validate required options
+      validate_options
+    end
+    
+    def create_options_parser
+      opts_parser = OptionParser.new
+      opts_parser.banner = BANNER
+      opts_parser.on("-n", "--name=NAME", "Service name") {|name| @options[:name] = name }
+      opts_parser.on_tail("-t", "--trace",  "Display stack trace when exception thrown") { @options[:trace] = true }
+      opts_parser.on_tail("-h", "--help",   "Show this help message") { puts opts_parser; exit }
+      
+      if ['install'].include?@command
+        opts_parser.on("-d", "--display=NAME", "Service display name") {|name| @options[:display] = name }
+        
+        opts_parser.on("-l", "--log FILE", "Service log file") {|file| @options[:log] = file }  
+        opts_parser.on("-e",     "--environment ENV ",    "Rails environment") { |env|
+          @options[:environment] = env
+          ENV['RAILS_ENV'] = env
+        }    
+      end
+      opts_parser
+    end
+  end
+  
+  # Install, Remove, Start and Stop Ferret DRb server Win32 service
+  class FerretService
+    FERRET_DAEMON = 'ferret_daemon'
+    
+    def initialize
+    end
+    
+    def install
+      svc = Service.new
+      
+      begin
+        if Service.exists?(@options[:name])
+          puts "Service name '#{@options[:name]}' already exists."
+          return
+        end 
+        
+        svc.create_service do |s|
+          s.service_name = @options[:name]
+          s.display_name = @options[:display]
+          s.binary_path_name = binary_path_name
+          s.dependencies = []
+        end
+        
+        svc.close
+        puts "'#{@options[:name]}' service installed."
+      rescue => e
+        handle_error(e)
+      end
+    end
+    
+    def remove
+      begin
+        Service.stop(@options[:name])
+      rescue
+      end
+      
+      begin
+        Service.delete(@options[:name])    
+        puts "'#{@options[:name]}' service removed."
+      rescue => e      
+        handle_error(e)
+      end
+    end
+    
+    def start
+      begin
+        Service.start(@options[:name])
+        puts "'#{@options[:name]}' successfully started."
+      rescue => e
+        handle_error(e)
+      end 
+    end
+    
+    def stop
+      begin
+        Service.stop(@options[:name])
+        puts "'#{@options[:name]}' successfully stopped.\n"
+      rescue => e
+        handle_error(e)
+      end 
+    end
+    
+    def run(args)
+      svc_cmd = FerretServiceCommand.new
+      svc_cmd.run(args)
+      @options = svc_cmd.options
+      self.send(svc_cmd.command.to_sym)
+    end
+    
+    protected  
+    def handle_error(e)
+      if @options[:trace]
+        raise e
+      else
+        puts e
+      end
+    end
+    
+    def binary_path_name
+      path = ""
+      path << "#{ENV['RUBY_HOME']}/bin/" if ENV['RUBY_HOME']
+      path << "ruby.exe "
+      path << File.expand_path("script/" + FERRET_DAEMON)
+      path << " -e #{@options[:environment]} " if @options[:environment]
+      path << " -l #{@options[:log]} " if @options[:log]
+      path
+    end
+  end
+end
+
+Ferret::FerretService.new.run(ARGV)