sunspot_rails 2.0.0.pre.120720 → 2.0.0.pre.120924

data/sunspot_solr/bin/sunspot-installer

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'sunspot', 'solr', 'installer')
+
+home = ARGV.select { |arg| arg !~ /^-/ }.last || File.join(Dir.pwd, "solr")
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: sunspot-installer [options] [solr-home]"
+  opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
+    options[:verbose] = v
+  end
+  opts.on('-f', '--[no-]force', 'Overwrite schema and solrconfig files with Sunspot default, instead of modifying them (recommended for new Solr installation)') do |f|
+    options[:force] = f
+  end
+end.parse!
+
+Sunspot::Solr::Installer.execute(home, options)
+puts "Installed to #{home}"

data/sunspot_solr/bin/sunspot-solr

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+begin
+  require 'fileutils'
+  require 'tempfile'
+  require 'tmpdir'
+  require 'optparse'
+  require File.join(File.dirname(__FILE__), '..', 'lib', 'sunspot', 'solr', 'server')
+rescue LoadError => e
+  if require 'rubygems'
+    retry
+  else
+    raise(e)
+  end
+end
+
+server = Sunspot::Solr::Server.new
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: sunspot-solr (start|stop|run) [options]"
+
+  opts.on '-p', '--port=PORT', 'Port on which to run Solr (default 8983)' do |p|
+    server.port = p
+  end
+
+  opts.on '-b', '--bind-address=address', 'Interface on which to run Solr (default 0.0.0.0)' do |b|
+    server.bind_address = b
+  end
+
+  opts.on '-d', '--data-directory=DIRECTORY', 'Solr data directory' do |d|
+    server.solr_data_dir = File.expand_path(d)
+  end
+
+  opts.on '-s', '--solr-home=HOME', 'Solr home directory (should contain conf/ directory)' do |s|
+    server.solr_home = File.expand_path(s)
+  end
+
+  opts.on '-j', '--solr-jar=JAR', 'Solr start jar' do |j|
+    server.solr_jar = File.expand_path(j)
+  end
+
+  opts.on '--pid-dir=PID_DIR', 'Directory for pid files' do |pd|
+    server.pid_dir = File.expand_path(pd)
+  end
+
+  opts.on '-l', '--log-level=LOG_LEVEL', 'Solr logging level' do |l|
+    server.log_level = l
+  end
+
+  opts.on '--log-file=LOG_FILE', 'Path to Solr log file' do |lf|
+    server.log_file = File.expand_path(lf)
+  end
+
+  opts.on '--max-memory=MEMORY', 'Specify the maximum size of the memory allocation pool' do |mm|
+    server.max_memory = mm
+  end
+
+  opts.on '--min-memory=MEMORY', 'Specify the initial size of the memory allocation pool' do |mm|
+    server.min_memory = mm
+  end
+end
+
+opts.parse!
+
+begin
+  case ARGV[0]
+  when 'start'
+    server.start
+  when 'run'
+    server.run
+  when 'stop'
+    server.stop
+  when 'restart'
+    server.stop
+    server.start
+  else
+    abort(opts.help)
+  end
+rescue Sunspot::Solr::Server::ServerError => e
+  abort(e.message)
+end

data/sunspot_solr/lib/sunspot/solr/installer.rb

@@ -0,0 +1,25 @@
+%w(task_helper config_installer).each do |file|
+  require File.join(File.dirname(__FILE__), 'installer', file)
+end
+
+module Sunspot
+  module Solr
+    class Installer
+      class <<self
+        def execute(solr_home, options = {})
+          new(solr_home, options).execute
+        end
+
+        private :new
+      end
+
+      def initialize(solr_home, options)
+        @solr_home, @options = solr_home, options
+      end
+
+      def execute
+        ConfigInstaller.execute(File.join(@solr_home, 'conf'), @options)
+      end
+    end
+  end
+end

data/sunspot_solr/lib/sunspot/solr/installer/config_installer.rb

@@ -0,0 +1,46 @@
+require 'fileutils'
+
+module Sunspot
+  module Solr
+    class Installer
+      class ConfigInstaller
+        include TaskHelper
+
+        class <<self
+          def execute(config_path, options = {})
+            new(config_path, options).execute
+          end
+        end
+
+        def initialize(config_path, options)
+          @config_path = config_path
+          @verbose = !!options[:verbose]
+          @force   = !!options[:force]
+        end
+
+        def execute
+          sunspot_config_path = File.join(File.dirname(__FILE__), '..', '..',
+                                          '..', '..', 'solr', 'solr', 'conf')
+          return if File.expand_path(sunspot_config_path) == File.expand_path(@config_path)
+
+          FileUtils.mkdir_p(@config_path)
+          Dir.glob(File.join(sunspot_config_path, '*.*')).each do |file|
+            file = File.expand_path(file)
+            dest = File.join(@config_path, File.basename(file))
+
+            if File.exist?(dest)
+              if @force
+                say("Removing existing file #{dest}")
+              else
+                next
+              end
+            end
+
+            say("Copying #{file} => #{dest}")
+            FileUtils.cp(file, dest)
+          end
+        end
+      end
+    end
+  end
+end

data/sunspot_solr/lib/sunspot/solr/installer/task_helper.rb

@@ -0,0 +1,13 @@
+module Sunspot
+  module Solr
+    class Installer
+      module TaskHelper
+        def say(message)
+          if @verbose
+            STDOUT.puts(message)
+          end
+        end
+      end
+    end
+  end
+end

data/sunspot_solr/lib/sunspot/solr/java.rb

@@ -0,0 +1,10 @@
+module Sunspot
+  module Solr
+    module Java
+      def self.installed?
+        `java -version`
+        $?.success?
+      end
+    end
+  end
+end

data/sunspot_solr/lib/sunspot/solr/railtie.rb

@@ -0,0 +1,15 @@
+module Sunspot
+  module Solr
+    class Railtie < ::Rails::Railtie
+	    
+      rake_tasks do
+        load 'sunspot/solr/tasks.rb'
+      end
+      
+      # generators do
+      #   load "generators/sunspot_rails.rb"
+      # end
+
+    end
+  end
+end

data/sunspot_solr/lib/sunspot/solr/server.rb

@@ -0,0 +1,223 @@
+require 'set'
+require 'tempfile'
+require 'sunspot/solr/java'
+require 'sunspot/solr/installer'
+
+module Sunspot
+  module Solr
+    class Server #:nodoc:
+      # Raised if #stop is called but the server is not running
+      ServerError = Class.new(RuntimeError)
+      AlreadyRunningError = Class.new(ServerError)
+      NotRunningError = Class.new(ServerError)
+      JavaMissing = Class.new(ServerError)
+
+      # Name of the sunspot executable (shell script)
+      SOLR_START_JAR = File.expand_path(
+        File.join(File.dirname(__FILE__), '..', '..', '..', 'solr', 'start.jar')
+      )
+
+      LOG_LEVELS = Set['SEVERE', 'WARNING', 'INFO', 'CONFIG', 'FINE', 'FINER', 'FINEST']
+
+      attr_accessor :min_memory, :max_memory, :bind_address, :port, :solr_data_dir, :solr_home, :log_file
+      attr_writer :pid_dir, :pid_file, :log_level, :solr_data_dir, :solr_home, :solr_jar
+
+      def initialize(*args)
+        ensure_java_installed
+        super(*args)
+      end
+
+      #
+      # Bootstrap a new solr_home by creating all required
+      # directories. 
+      #
+      # ==== Returns
+      #
+      # Boolean:: success
+      #
+      def bootstrap
+        unless @bootstrapped
+          install_solr_home
+          create_solr_directories
+          @bootstrapped = true
+        end
+      end
+
+      #
+      # Start the sunspot-solr server. Bootstrap solr_home first,
+      # if neccessary.
+      #
+      # ==== Returns
+      #
+      # Boolean:: success
+      #
+      def start
+        bootstrap
+
+        if File.exist?(pid_path)
+          existing_pid = IO.read(pid_path).to_i
+          begin
+            Process.kill(0, existing_pid)
+            raise(AlreadyRunningError, "Server is already running with PID #{existing_pid}")
+          rescue Errno::ESRCH
+            STDERR.puts("Removing stale PID file at #{pid_path}")
+            FileUtils.rm(pid_path)
+          end
+        end
+        fork do
+          pid = fork do
+            Process.setsid
+            STDIN.reopen('/dev/null')
+            STDOUT.reopen('/dev/null', 'a')
+            STDERR.reopen(STDOUT)
+            run
+          end
+          FileUtils.mkdir_p(pid_dir)
+          File.open(pid_path, 'w') do |file|
+            file << pid
+          end
+        end
+      end
+
+      #
+      # Run the sunspot-solr server in the foreground. Boostrap
+      # solr_home first, if neccessary.
+      #
+      # ==== Returns
+      #
+      # Boolean:: success
+      #
+      def run
+        bootstrap
+
+        command = ['java']
+        command << "-Xms#{min_memory}" if min_memory
+        command << "-Xmx#{max_memory}" if max_memory
+        command << "-Djetty.port=#{port}" if port
+        command << "-Djetty.host=#{bind_address}" if bind_address
+        command << "-Dsolr.data.dir=#{solr_data_dir}" if solr_data_dir
+        command << "-Dsolr.solr.home=#{solr_home}" if solr_home
+        command << "-Djava.util.logging.config.file=#{logging_config_path}" if logging_config_path
+        command << '-jar' << File.basename(solr_jar)
+        FileUtils.cd(File.dirname(solr_jar)) do
+          exec(*command)
+        end
+      end
+
+      #
+      # Stop the sunspot-solr server.
+      #
+      # ==== Returns
+      #
+      # Boolean:: success
+      #
+      def stop
+        if File.exist?(pid_path)
+          pid = IO.read(pid_path).to_i
+          begin
+            Process.kill('TERM', pid)
+          rescue Errno::ESRCH
+            raise NotRunningError, "Process with PID #{pid} is no longer running"
+          ensure
+            FileUtils.rm(pid_path)
+          end
+        else
+          raise NotRunningError, "No PID file at #{pid_path}"
+        end
+      end
+
+      def log_level=(level)
+        unless LOG_LEVELS.include?(level.to_s.upcase)
+          raise(ArgumentError, "#{level} is not a valid log level: Use one of #{LOG_LEVELS.to_a.join(',')}")
+        end
+        @log_level = level.to_s.upcase
+      end
+
+      def log_level
+        @log_level || 'WARNING'
+      end
+
+      def pid_path
+        File.join(pid_dir, pid_file)
+      end
+
+      def pid_file
+        @pid_file || 'sunspot-solr.pid'
+      end
+
+      def pid_dir
+        File.expand_path(@pid_dir || FileUtils.pwd)
+      end
+
+      def solr_data_dir
+        File.expand_path(@solr_data_dir || Dir.tmpdir)
+      end
+
+      def solr_home
+        File.expand_path(@solr_home || File.join(File.dirname(solr_jar), 'solr'))
+      end
+
+      def solr_jar
+        @solr_jar || SOLR_START_JAR
+      end
+
+      #
+      # Copy default solr configuration files from sunspot
+      # gem to the new solr_home/config directory
+      #
+      # ==== Returns
+      #
+      # Boolean:: success
+      #
+      def install_solr_home
+        unless File.exists?(solr_home)
+          Sunspot::Solr::Installer.execute(
+            solr_home,
+            :force => true,
+            :verbose => true
+          )
+        end
+      end
+
+      # 
+      # Create new solr_home, config, log and pid directories
+      #
+      # ==== Returns
+      #
+      # Boolean:: success
+      #
+      def create_solr_directories
+        [solr_data_dir, pid_dir].each do |path|
+          FileUtils.mkdir_p(path) unless File.exists?(path)
+        end
+      end
+
+      private
+
+      def ensure_java_installed
+        unless defined?(@java_installed)
+          @java_installed = Sunspot::Solr::Java.installed?
+          unless @java_installed
+            raise JavaMissing.new("You need a Java Runtime Environment to run the Solr server")
+          end
+        end
+        @java_installed
+      end
+
+      def logging_config_path
+        return @logging_config_path if defined?(@logging_config_path)
+        @logging_config_path =
+          if log_file
+            logging_config = Tempfile.new('logging.properties')
+            logging_config.puts("handlers = java.util.logging.FileHandler")
+            logging_config.puts("java.util.logging.FileHandler.level = #{log_level.to_s.upcase}")
+            logging_config.puts("java.util.logging.FileHandler.pattern = #{log_file}")
+            logging_config.puts("java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter")
+            logging_config.flush
+            logging_config.close
+            logging_config.path
+          end
+      end
+    end
+  end
+end

data/sunspot_solr/lib/sunspot/solr/tasks.rb

@@ -0,0 +1,49 @@
+namespace :sunspot do
+  namespace :solr do
+    desc 'Start the Solr instance'
+    task :start => :environment do
+      case RUBY_PLATFORM
+      when /w(in)?32$/, /java$/
+        abort("This command is not supported on #{RUBY_PLATFORM}. " +
+              "Use rake sunspot:solr:run to run Solr in the foreground.")
+      end
+
+      if defined?(Sunspot::Rails::Server)
+        Sunspot::Rails::Server.new.start
+      else
+        Sunspot::Solr::Server.new.start
+      end
+
+      puts "Successfully started Solr ..."
+    end
+
+    desc 'Run the Solr instance in the foreground'
+    task :run => :environment do
+      if defined?(Sunspot::Rails::Server)
+        Sunspot::Rails::Server.new.run
+      else
+        Sunspot::Solr::Server.new.run
+      end
+    end
+
+    desc 'Stop the Solr instance'
+    task :stop => :environment do
+      case RUBY_PLATFORM
+      when /w(in)?32$/, /java$/
+        abort("This command is not supported on #{RUBY_PLATFORM}. " +
+              "Use rake sunspot:solr:run to run Solr in the foreground.")
+      end
+
+      if defined?(Sunspot::Rails::Server)
+        Sunspot::Rails::Server.new.stop
+      else
+        Sunspot::Solr::Server.new.stop
+      end
+
+      puts "Successfully stopped Solr ..."
+    end
+
+    # for backwards compatibility
+    task :reindex => :"sunspot:reindex"
+  end
+end