cehoffman-acts_as_ferret 0.4.4

data/lib/unix_daemon.rb

@@ -0,0 +1,64 @@
+################################################################################
+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
+        raise "ferret_server may already be running, a pid file exists: #{@cfg.pid_file}" if read_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/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/rakefile

@@ -0,0 +1,141 @@
+# rakefile for acts_as_ferret. 
+# use to create a gem or generate rdoc api documentation.
+#
+# RELEASE creation:
+# rake release REL=x.y.z 
+
+require 'pathname'
+require 'yaml'
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/contrib/rubyforgepublisher'
+
+def announce(msg='')
+  STDERR.puts msg
+end
+
+
+PKG_NAME      = 'acts_as_ferret'
+PKG_VERSION   = ENV['REL']
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBYFORGE_PROJECT = 'actsasferret'
+RUBYFORGE_USER    = 'jkraemer'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_ferret plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_ferret plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.title    = "acts_as_ferret - Ferret based full text search for any ActiveRecord model"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.options << '--main' << 'README'
+  rdoc.rdoc_files.include('README', 'LICENSE')
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do
+  Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, RUBYFORGE_USER).upload
+end
+
+if PKG_VERSION
+  spec = Gem::Specification.new do |s|
+    s.name            = PKG_NAME
+    s.version         = PKG_VERSION
+    s.platform        = Gem::Platform::RUBY
+    s.summary         = "acts_as_ferret - Ferret based full text search for any ActiveRecord model"
+    s.files  = Dir.glob('**/*', File::FNM_DOTMATCH).reject do |f| 
+      [ /\.$/, /sqlite$/, /\.log$/, /^pkg/, /\.svn/, /\.git/, /\.\w+\.sw.$/,
+        /^html/, /\~$/, /\/\._/, /\/#/ ].any? {|regex| f =~ regex }
+    end
+    #s.files           = FileList["{lib,test}/**/*"].to_a + %w(README MIT-LICENSE CHANGELOG)
+  # s.files.delete  ...    
+    s.require_path    = 'lib'
+    s.bindir          = "bin"
+    s.executables     = ["aaf_install"]
+    s.default_executable = "aaf_install"
+    s.autorequire     = 'acts_as_ferret'
+    s.has_rdoc        = true
+  # s.test_files      = Dir['test/**/*_test.rb']
+    s.author          = "Jens Kraemer"
+    s.email           = "jk@jkraemer.net"
+    s.homepage        = "http://projects.jkraemer.net/acts_as_ferret"
+  end
+  
+  desc "Update the gemspec for GitHub's gem server"
+  task :gemspec do
+    Pathname("#{spec.name}.gemspec").open('w') {|f| f << YAML.dump(spec) }
+  end
+
+  package_task = Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+  end
+
+  # Validate that everything is ready to go for a release.
+  task :prerelease do
+    announce 
+    announce "**************************************************************"
+    announce "* Making RubyGem Release #{PKG_VERSION}"
+    announce "**************************************************************"
+    announce  
+    # Are all source files checked in?
+    if ENV['RELTEST']
+      announce "Release Task Testing, skipping checked-in file test"
+    else
+      announce "Pulling in svn..."
+      `svk pull .`
+      announce "Checking for unchecked-in files..."
+      data = `svk st`
+      unless data =~ /^$/
+        fail "SVK status is not clean ... do you have unchecked-in files?"
+      end
+      announce "No outstanding checkins found ... OK"
+#      announce "Pushing to svn..."
+#      `svk push .`
+    end
+  end
+  
+  
+  desc "tag the new release"
+  task :tag => [ :prerelease ] do
+    reltag = "REL_#{PKG_VERSION.gsub(/\./, '_')}"
+    reltag << ENV['REUSE'].gsub(/\./, '_') if ENV['REUSE']
+    announce "Tagging with [#{PKG_VERSION}]"
+    if ENV['RELTEST']
+      announce "Release Task Testing, skipping tagging"
+    else
+      `svn copy -m 'tagging version #{PKG_VERSION}' svn://projects.jkraemer.net/acts_as_ferret/trunk/plugin svn://projects.jkraemer.net/acts_as_ferret/tags/#{PKG_VERSION}`
+      `svn del -m 'remove old stable' svn://projects.jkraemer.net/acts_as_ferret/tags/stable`
+      `svn copy -m 'tagging version #{PKG_VERSION} as stable' svn://projects.jkraemer.net/acts_as_ferret/tags/#{PKG_VERSION} svn://projects.jkraemer.net/acts_as_ferret/tags/stable`
+    end
+  end
+  
+  # Upload release to rubyforge
+  desc "Upload release to rubyforge"
+  task :prel => [ :tag, :prerelease, :package ] do
+    `rubyforge login`
+    release_command = "rubyforge add_release #{RUBYFORGE_PROJECT} #{PKG_NAME} '#{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.gem"
+    puts release_command
+    system(release_command)
+    `rubyforge config #{RUBYFORGE_PROJECT}`
+    release_command = "rubyforge add_file #{RUBYFORGE_PROJECT} #{PKG_NAME} '#{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.tgz"
+    puts release_command
+    system(release_command)
+  end
+  
+  desc 'Publish the gem and API docs'
+  task :release => [:pdoc, :prel ]
+  
+end

data/recipes/aaf_recipes.rb

@@ -0,0 +1,114 @@
+# 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')
+    run "cd #{current_path}; script/ferret_server -e #{rails_env} stop || true"
+  end
+
+  desc "Start the Ferret DRb server"
+  task :start, :roles => :app do
+    rails_env = fetch(:rails_env, 'production')
+    run "cd #{current_path}; script/ferret_server -e #{rails_env} 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}; 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