watson-acts_as_ferret 0.4.8.2

data/lib/server_manager.rb

@@ -0,0 +1,71 @@
+################################################################################
+require 'optparse'
+
+################################################################################
+$ferret_server_options = {
+  'environment' => nil,
+  'debug'       => nil,
+  'root'        => nil
+}
+
+################################################################################
+OptionParser.new do |optparser|
+  optparser.banner = "Usage: #{File.basename($0)} [options] {start|stop|run}"
+
+  optparser.on('-h', '--help', "This message") do
+    puts optparser
+    exit
+  end
+  
+  optparser.on('-R', '--root=PATH', 'Set RAILS_ROOT to the given string') do |r|
+    $ferret_server_options['root'] = r
+  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 run).include?($ferret_server_action)
+end
+
+################################################################################
+
+def determine_rails_root
+  possible_rails_roots = [
+    $ferret_server_options['root'],
+    (defined?(FERRET_SERVER) ? File.join(File.dirname(FERRET_SERVER), '..') : nil),
+    File.join(File.dirname(__FILE__), *(['..']*4)),
+    '.'
+  ].compact
+  # take the first dir where environment.rb can be found
+  possible_rails_roots.find{ |dir| File.readable?(File.join(dir, 'config', 'environment.rb')) }
+end
+
+begin
+  ENV['FERRET_USE_LOCAL_INDEX'] = 'true'
+  ENV['RAILS_ENV'] = $ferret_server_options['environment']
+  # determine RAILS_ROOT unless already set
+  RAILS_ROOT = determine_rails_root unless defined?(RAILS_ROOT)
+  
+  begin
+    require File.join(RAILS_ROOT, 'config', 'environment')
+  rescue LoadError
+    puts "Unable to find Rails environment.rb in any of these locations:\n#{possible_rails_roots.join("\n")}\nPlease use the --root option of ferret_server to point it to your RAILS_ROOT."
+    raise $!
+  end
+
+  # 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/unix_daemon.rb

@@ -0,0 +1,86 @@
+################################################################################
+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
+        ensure_stopped
+        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
+
+      #################################################################################
+      def ensure_stopped
+        if pid = read_pid_file
+          if process_exists(pid)
+            raise "ferret_server may already be running, a pid file exists: #{@cfg.pid_file} and a ferret_server process exists with matching pid #{pid}"
+          else
+            $stdout.puts("removing stale pid file...")
+            File.unlink(@cfg.pid_file) if File.exist?(@cfg.pid_file)
+          end
+        end
+      end
+
+      #################################################################################
+      # Check for existence of ferret_server process with PID from pid file
+      # checked on ubuntu and OSX only
+      def process_exists(pid)
+        ps = IO.popen("ps -fp #{pid}", "r")
+        process = ps.to_a[1]
+        ps.close
+        process =~ /ferret_server/
+      end
+
+    end
+  end
+end

data/lib/without_ar.rb

@@ -0,0 +1,52 @@
+module ActsAsFerret
+
+  # Include this module to use acts_as_ferret with model classes 
+  # not based on ActiveRecord. 
+  #
+  # Implement the find_for_id(id) class method in your model class in
+  # order to make search work.
+  module WithoutAR
+    def self.included(target)
+      target.extend ClassMethods
+      target.extend ActsAsFerret::ActMethods
+      target.send :include, InstanceMethods
+    end
+
+    module ClassMethods
+      def logger
+        RAILS_DEFAULT_LOGGER
+      end
+      def table_name
+        self.name.underscore
+      end
+      def primary_key
+        'id'
+      end
+      def find(what, args = {})
+        case what
+        when :all
+          ids = args[:conditions][1]
+          ids.map { |id| find id }
+        else
+          find_for_id what
+        end
+      end
+      def find_for_id(id)
+        raise NotImplementedError.new("implement find_for_id in class #{self.name}")
+      end
+      def count
+        0
+      end
+    end
+
+    module InstanceMethods
+      def logger
+        self.class.logger
+      end
+      def new_record?
+        false
+      end
+    end
+  end
+        
+end

data/recipes/aaf_recipes.rb

@@ -0,0 +1,116 @@
+# Ferret DRb server Capistrano tasks
+# 
+# Usage:
+# in your Capfile, add acts_as_ferret's recipes directory to your load path and
+# load the ferret tasks:
+#
+# load_paths << 'vendor/plugins/acts_as_ferret/recipes'
+# load 'aaf_recipes'
+#
+# This will hook aaf's DRb start/stop tasks into the standard
+# deploy:{start|restart|stop} tasks so the server will be restarted along with
+# the rest of your application.
+# Also an index directory in the shared folder will be created and symlinked
+# into current/ when you deploy.
+#
+# In order to use the ferret:index:rebuild task, declare the indexes you intend to
+# rebuild remotely in config/deploy.rb:
+#
+# set :ferret_indexes, %w( model another_model shared )
+#
+# HINT: To be very sure that your DRb server and application are always using
+# the same model and schema versions, and you never lose any index updates because
+# of the DRb server being restarted in that moment, use the following sequence
+# to update your application:
+#
+# cap deploy:stop deploy:update deploy:migrate deploy:start
+#
+# That will stop the DRb server after stopping your application, and bring it
+# up before starting the application again. Plus they'll never use different
+# versions of model classes (which might happen otherwise)
+# Downside: Your downtime is a bit longer than with the usual deploy, so be sure to
+# put up some maintenance page for the meantime. Obviously this won't work if
+# your migrations need acts_as_ferret (i.e. if you update model instances which
+# would lead to index updates). In this case bring up the DRb server before
+# running your migrations:
+#
+# cap deploy:stop deploy:update ferret:start deploy:migrate ferret:stop deploy:start
+#
+# Chances are that you're still not safe if your migrations not only modify the index, 
+# but also change the structure of your models. So just don't do both things in
+# one go - I can't think of an easy way to handle this case automatically.
+# Suggestions and patches are of course very welcome :-)
+
+namespace :ferret do
+
+  desc "Stop the Ferret DRb server"
+  task :stop, :roles => :app do
+    rails_env = fetch(:rails_env, 'production')
+    ruby = fetch(:ruby, '/usr/bin/env ruby')
+    run "cd #{current_path}; #{ruby} script/ferret_server -e #{rails_env} --root #{current_path} stop || true"
+  end
+
+  desc "Start the Ferret DRb server"
+  task :start, :roles => :app do
+    rails_env = fetch(:rails_env, 'production')
+    ruby = fetch(:ruby, '/usr/bin/env ruby')
+    run "cd #{current_path}; #{ruby} script/ferret_server -e #{rails_env} --root #{current_path} start"
+  end
+
+  desc "Restart the Ferret DRb server"
+  task :restart, :roles => :app do
+    top.ferret.stop
+    sleep 1
+    top.ferret.start
+  end
+
+  namespace :index do
+
+    desc "Rebuild the Ferret index. See aaf_recipes.rb for instructions."
+    task :rebuild, :roles => :app do
+      rake = fetch(:rake, 'rake')
+      rails_env = fetch(:rails_env, 'production')
+      indexes = fetch(:ferret_indexes, [])
+      if indexes.any?
+        run "cd #{current_path}; LANG=da_DK.UTF-8 RAILS_ENV=#{rails_env} INDEXES='#{indexes.join(' ')}' #{rake} ferret:rebuild"
+      end
+    end
+
+    desc "purges all indexes for the current environment"
+    task :purge, :roles => :app do
+      run "rm -fr #{shared_path}/index/#{rails_env}"
+    end
+
+    desc "symlinks index folder"
+    task :symlink, :roles => :app do
+      run "mkdir -p  #{shared_path}/index && rm -rf #{release_path}/index && ln -nfs #{shared_path}/index #{release_path}/index"
+    end
+
+    desc "Clean up old index versions"
+    task :cleanup, :roles => :app do
+    	indexes = fetch(:ferret_indexes, [])
+    	indexes.each do |index|
+    	  ferret_index_path = "#{shared_path}/index/#{rails_env}/#{index}"
+    	  releases = capture("ls -x #{ferret_index_path}").split.sort
+    	  count = 2
+    	  if count >= releases.length
+    	    logger.important "no old indexes to clean up"
+    	  else
+    	    logger.info "keeping #{count} of #{releases.length} indexes"
+    	    directories = (releases - releases.last(count)).map { |release|
+    	      File.join(ferret_index_path, release) }.join(" ")
+    	    sudo "rm -rf #{directories}"
+    	  end
+    	end
+    end
+  end
+
+end
+
+after  "deploy:stop",    "ferret:stop"
+before "deploy:start",   "ferret:start"
+
+before "deploy:restart", "ferret:stop"
+after  "deploy:restart", "ferret:start"
+after "deploy:symlink", "ferret:index:symlink"
+

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,12 @@
+#!/usr/bin/env ruby
+
+FERRET_SERVER = File.expand_path(__FILE__)
+
+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)