thinking-sphinx 3.3.0 → 3.4.0

data/lib/thinking_sphinx/commands/base.rb

@@ -0,0 +1,41 @@
+class ThinkingSphinx::Commands::Base
+  include ThinkingSphinx::WithOutput
+
+  def self.call(configuration, options, stream = STDOUT)
+    new(configuration, options, stream).call_with_handling
+  end
+
+  def call_with_handling
+    call
+  rescue Riddle::CommandFailedError => error
+    handle_failure error.command_result
+  end
+
+  private
+
+  delegate :controller, :to => :configuration
+
+  def command_output(output)
+    return "See above\n" if output.nil?
+
+    "\n\t" + output.gsub("\n", "\n\t")
+  end
+
+  def handle_failure(result)
+    stream.puts <<-TXT
+
+The Sphinx #{type} command failed:
+  Command: #{result.command}
+  Status:  #{result.status}
+  Output:  #{command_output result.output}
+There may be more information about the failure in #{configuration.searchd.log}.
+    TXT
+    exit result.status
+  end
+
+  def log(message)
+    return if options[:silent]
+
+    stream.puts message
+  end
+end

data/lib/thinking_sphinx/commands/configure.rb

@@ -0,0 +1,13 @@
+class ThinkingSphinx::Commands::Configure < ThinkingSphinx::Commands::Base
+  def call
+    log "Generating configuration to #{configuration.configuration_file}"
+
+    configuration.render_to_file
+  end
+
+  private
+
+  def type
+    'configure'
+  end
+end

data/lib/thinking_sphinx/commands/index.rb

@@ -0,0 +1,11 @@
+class ThinkingSphinx::Commands::Index < ThinkingSphinx::Commands::Base
+  def call
+    controller.index :verbose => options[:verbose]
+  end
+
+  private
+
+  def type
+    'indexing'
+  end
+end

data/lib/thinking_sphinx/commands/start_attached.rb

@@ -0,0 +1,20 @@
+class ThinkingSphinx::Commands::StartAttached < ThinkingSphinx::Commands::Base
+  def call
+    FileUtils.mkdir_p configuration.indices_location
+
+    unless pid = fork
+      controller.start :verbose => options[:verbose], :nodetach => true
+    end
+
+    Signal.trap('TERM') { Process.kill(:TERM, pid) }
+    Signal.trap('INT')  { Process.kill(:TERM, pid) }
+
+    Process.wait(pid)
+  end
+
+  private
+
+  def type
+    'start'
+  end
+end

data/lib/thinking_sphinx/commands/start_detached.rb

@@ -0,0 +1,19 @@
+class ThinkingSphinx::Commands::StartDetached < ThinkingSphinx::Commands::Base
+  def call
+    FileUtils.mkdir_p configuration.indices_location
+
+    result = controller.start :verbose => options[:verbose]
+
+    if controller.running?
+      log "Started searchd successfully (pid: #{controller.pid})."
+    else
+      handle_failure result
+    end
+  end
+
+  private
+
+  def type
+    'start'
+  end
+end

data/lib/thinking_sphinx/commands/stop.rb

@@ -0,0 +1,22 @@
+class ThinkingSphinx::Commands::Stop < ThinkingSphinx::Commands::Base
+  def call
+    unless controller.running?
+      log 'searchd is not currently running.'
+      return
+    end
+
+    pid = controller.pid
+    until !controller.running? do
+      controller.stop options
+      sleep(0.5)
+    end
+
+    log "Stopped searchd daemon (pid: #{pid})."
+  end
+
+  private
+
+  def type
+    'stop'
+  end
+end

data/lib/thinking_sphinx/configuration.rb

@@ -84,9 +84,8 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
         end
       end
 
-      if settings['distributed_indices'].nil? || settings['distributed_indices']
-        ThinkingSphinx::Configuration::DistributedIndices.new(indices).reconcile
-      end
+      normalise
+      verify
 
       @preloaded_indices = true
     end
@@ -95,10 +94,6 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
   def render
     preload_indices
 
-    ThinkingSphinx::Configuration::ConsistentIds.new(indices).reconcile
-    ThinkingSphinx::Configuration::MinimumFields.new(indices).reconcile
-    ThinkingSphinx::Configuration::DuplicateNames.new(indices).reconcile
-
     super
   end
 
@@ -137,6 +132,16 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
 
   private
 
+  def apply_sphinx_settings!
+    sphinx_sections.each do |object|
+      settings.each do |key, value|
+        next unless object.class.settings.include?(key.to_sym)
+
+        object.send("#{key}=", value)
+      end
+    end
+  end
+
   def configure_searchd
     configure_searchd_log_files
 
@@ -153,12 +158,21 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
     searchd.query_log = log_root.join("#{environment}.searchd.query.log").to_s
   end
 
+  def framework_root
+    Pathname.new(framework.root)
+  end
+
   def log_root
     real_path 'log'
   end
 
-  def framework_root
-    Pathname.new(framework.root)
+  def normalise
+    if settings['distributed_indices'].nil? || settings['distributed_indices']
+      ThinkingSphinx::Configuration::DistributedIndices.new(indices).reconcile
+    end
+
+    ThinkingSphinx::Configuration::ConsistentIds.new(indices).reconcile
+    ThinkingSphinx::Configuration::MinimumFields.new(indices).reconcile
   end
 
   def real_path(*arguments)
@@ -166,25 +180,21 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
     path.exist? ? path.realpath : path
   end
 
-  def settings_to_hash
-    input    = File.read settings_file
-    input    = ERB.new(input).result if defined?(ERB)
-
-    contents = YAML.load input
-    contents && contents[environment] || {}
+  def reset
+    @settings = nil
+    setup
   end
 
   def settings_file
     framework_root.join 'config', 'thinking_sphinx.yml'
   end
 
-  def reset
-    @settings = nil
-    setup
-  end
+  def settings_to_hash
+    input    = File.read settings_file
+    input    = ERB.new(input).result if defined?(ERB)
 
-  def tmp_path
-    real_path 'tmp'
+    contents = YAML.load input
+    contents && contents[environment] || {}
   end
 
   def sphinx_sections
@@ -193,14 +203,12 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
     sections
   end
 
-  def apply_sphinx_settings!
-    sphinx_sections.each do |object|
-      settings.each do |key, value|
-        next unless object.class.settings.include?(key.to_sym)
+  def tmp_path
+    real_path 'tmp'
+  end
 
-        object.send("#{key}=", value)
-      end
-    end
+  def verify
+    ThinkingSphinx::Configuration::DuplicateNames.new(indices).reconcile
   end
 end
 

data/lib/thinking_sphinx/configuration/minimum_fields.rb

@@ -6,8 +6,8 @@ class ThinkingSphinx::Configuration::MinimumFields
   def reconcile
     return unless no_inheritance_columns?
 
-    sources.each do |source|
-      source.fields.delete_if do |field|
+    field_collections.each do |collection|
+      collection.fields.delete_if do |field|
         field.name == 'sphinx_internal_class_name'
       end
     end
@@ -17,15 +17,18 @@ class ThinkingSphinx::Configuration::MinimumFields
 
   attr_reader :indices
 
+  def field_collections
+    indices_of_type('plain').collect(&:sources).flatten +
+    indices_of_type('rt')
+  end
+
+  def indices_of_type(type)
+    indices.select { |index| index.type == type }
+  end
+
   def no_inheritance_columns?
     indices.select { |index|
       index.model.column_names.include?(index.model.inheritance_column)
     }.empty?
   end
-
-  def sources
-    @sources ||= @indices.select { |index|
-      index.respond_to?(:sources)
-    }.collect(&:sources).flatten
-  end
 end

data/lib/thinking_sphinx/connection.rb

@@ -26,7 +26,7 @@ module ThinkingSphinx::Connection
   def self.pool
     @pool ||= Innertube::Pool.new(
       Proc.new { ThinkingSphinx::Connection.new },
-      Proc.new { |connection| connection.close }
+      Proc.new { |connection| connection.close! }
     )
   end
 
@@ -63,125 +63,8 @@ module ThinkingSphinx::Connection
   end
 
   @persistent = true
-
-  class Client
-    def close
-      client.close unless ThinkingSphinx::Connection.persistent?
-    end
-
-    def execute(statement)
-      check_and_perform(statement).first
-    end
-
-    def query_all(*statements)
-      check_and_perform statements.join('; ')
-    end
-
-    private
-
-    def check(statements)
-      if statements.length > ThinkingSphinx::MAXIMUM_STATEMENT_LENGTH
-        exception           = ThinkingSphinx::QueryLengthError.new
-        exception.statement = statements
-        raise exception
-      end
-    end
-
-    def check_and_perform(statements)
-      check statements
-      perform statements
-    end
-
-    def close_and_clear
-      client.close
-      @client = nil
-    end
-
-    def perform(statements)
-      results_for statements
-    rescue => error
-      message           = "#{error.message} - #{statements}"
-      wrapper           = ThinkingSphinx::QueryExecutionError.new message
-      wrapper.statement = statements
-      raise wrapper
-    ensure
-      close_and_clear unless ThinkingSphinx::Connection.persistent?
-    end
-  end
-
-  class MRI < Client
-    def initialize(options)
-      @options = options
-    end
-
-    def base_error
-      Mysql2::Error
-    end
-
-    private
-
-    attr_reader :options
-
-    def client
-      @client ||= Mysql2::Client.new({
-        :flags => Mysql2::Client::MULTI_STATEMENTS
-      }.merge(options))
-    rescue base_error => error
-      raise ThinkingSphinx::SphinxError.new_from_mysql error
-    end
-
-    def results_for(statements)
-      results  = [client.query(statements)]
-      results << client.store_result while client.next_result
-      results
-    end
-  end
-
-  class JRuby < Client
-    attr_reader :address, :options
-
-    def initialize(options)
-      @address = "jdbc:mysql://#{options[:host]}:#{options[:port]}/?allowMultiQueries=true"
-      @options = options
-    end
-
-    def base_error
-      Java::JavaSql::SQLException
-    end
-
-    private
-
-    def client
-      @client ||= java.sql.DriverManager.getConnection address,
-        options[:username], options[:password]
-    rescue base_error => error
-      raise ThinkingSphinx::SphinxError.new_from_mysql error
-    end
-
-    def results_for(statements)
-      statement = client.createStatement
-      statement.execute statements
-
-      results   = [set_to_array(statement.getResultSet)]
-      results  << set_to_array(statement.getResultSet) while statement.getMoreResults
-      results.compact
-    end
-
-    def set_to_array(set)
-      return nil if set.nil?
-
-      meta = set.getMetaData
-      rows = []
-
-      while set.next
-        rows << (1..meta.getColumnCount).inject({}) do |row, index|
-          name      = meta.getColumnName index
-          row[name] = set.getObject(index)
-          row
-        end
-      end
-
-      rows
-    end
-  end
 end
+
+require 'thinking_sphinx/connection/client'
+require 'thinking_sphinx/connection/jruby'
+require 'thinking_sphinx/connection/mri'

data/lib/thinking_sphinx/connection/client.rb

@@ -0,0 +1,48 @@
+class ThinkingSphinx::Connection::Client
+  def close
+    close! unless ThinkingSphinx::Connection.persistent?
+  end
+
+  def close!
+    client.close
+  end
+
+  def execute(statement)
+    check_and_perform(statement).first
+  end
+
+  def query_all(*statements)
+    check_and_perform statements.join('; ')
+  end
+
+  private
+
+  def check(statements)
+    if statements.length > ThinkingSphinx::MAXIMUM_STATEMENT_LENGTH
+      exception           = ThinkingSphinx::QueryLengthError.new
+      exception.statement = statements
+      raise exception
+    end
+  end
+
+  def check_and_perform(statements)
+    check statements
+    perform statements
+  end
+
+  def close_and_clear
+    client.close
+    @client = nil
+  end
+
+  def perform(statements)
+    results_for statements
+  rescue => error
+    message           = "#{error.message} - #{statements}"
+    wrapper           = ThinkingSphinx::QueryExecutionError.new message
+    wrapper.statement = statements
+    raise wrapper
+  ensure
+    close_and_clear unless ThinkingSphinx::Connection.persistent?
+  end
+end