acts_as_ferret 0.4.8.2 → 0.5

data/lib/server_manager.rb

@@ -1,71 +0,0 @@
-################################################################################
-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/script/ferret_daemon

@@ -1,94 +0,0 @@
-# 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_service

@@ -1,178 +0,0 @@
-# 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)