thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/callbacks/appender.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Callbacks::Appender
+  def self.call(model, reference, options, &block)
+    new(model, reference, options, &block).call
+  end
+
+  def initialize(model, reference, options, &block)
+    @model = model
+    @reference = reference
+    @options = options
+    @block = block
+  end
+
+  def call
+    add_core_callbacks
+    add_delta_callbacks     if behaviours.include?(:deltas)
+    add_real_time_callbacks if behaviours.include?(:real_time)
+    add_update_callbacks    if behaviours.include?(:updates)
+  end
+
+  private
+
+  attr_reader :model, :reference, :options, :block
+
+  def add_core_callbacks
+    model.after_commit(
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks,
+      on: :destroy
+    )
+  end
+
+  def add_delta_callbacks
+    if path.empty?
+      model.before_save  ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
+      model.after_commit ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
+    else
+      model.after_commit(
+        ThinkingSphinx::ActiveRecord::Callbacks::AssociationDeltaCallbacks
+          .new(path)
+      )
+    end
+  end
+
+  def add_real_time_callbacks
+    model.after_commit(
+      ThinkingSphinx::RealTime.callback_for(reference, path, &block),
+      on: [:create, :update]
+    )
+  end
+
+  def add_update_callbacks
+    model.after_update ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks
+  end
+
+  def behaviours
+    options[:behaviours] || []
+  end
+
+  def path
+    options[:path] || []
+  end
+end

data/lib/thinking_sphinx/callbacks.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Callbacks
+  attr_reader :instance
+
+  def self.append(model, reference = nil, options, &block)
+    reference ||= ThinkingSphinx::Configuration.instance.index_set_class.
+      reference_name(model)
+
+    ThinkingSphinx::Callbacks::Appender.call(model, reference, options, &block)
+  end
+
+  def self.callbacks(*methods)
+    mod = Module.new
+    methods.each do |method|
+      mod.send(:define_method, method) { |instance| new(instance).send(method) }
+    end
+    extend mod
+  end
+
+  def self.resume!
+    @suspended = false
+  end
+
+  def self.suspend(&block)
+    suspend!
+    yield
+    resume!
+  end
+
+  def self.suspend!
+    @suspended = true
+  end
+
+  def self.suspended?
+    @suspended
+  end
+
+  def initialize(instance)
+    @instance = instance
+  end
+end
+
+require "thinking_sphinx/callbacks/appender"

data/lib/thinking_sphinx/capistrano/v2.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+Capistrano::Configuration.instance(:must_exist).load do
+  _cset(:thinking_sphinx_roles)   { :db }
+  _cset(:thinking_sphinx_options) { {:roles => fetch(:thinking_sphinx_roles)} }
+
+  namespace :thinking_sphinx do
+    desc 'Generate the Sphinx configuration file.'
+    task :configure, fetch(:thinking_sphinx_options) do
+      rake 'ts:configure'
+    end
+
+    desc 'Build Sphinx indexes into the shared path.'
+    task :index, fetch(:thinking_sphinx_options) do
+      rake 'ts:index'
+    end
+
+    desc 'Generate Sphinx indexes into the shared path.'
+    task :generate, fetch(:thinking_sphinx_options) do
+      rake 'ts:generate'
+    end
+
+    desc 'Start the Sphinx search daemon.'
+    task :start, fetch(:thinking_sphinx_options) do
+      rake 'ts:start'
+    end
+    before 'thinking_sphinx:start', 'thinking_sphinx:configure'
+
+    desc 'Stop the Sphinx search daemon.'
+    task :stop, fetch(:thinking_sphinx_options) do
+      rake 'ts:stop'
+    end
+
+    desc 'Restart the Sphinx search daemon.'
+    task :restart, fetch(:thinking_sphinx_options) do
+      rake 'ts:stop ts:configure ts:start'
+    end
+
+    desc <<-DESC
+Stop, reindex, and then start the Sphinx search daemon. This task must be executed \
+if you alter the structure of your indexes.
+    DESC
+    task :rebuild, fetch(:thinking_sphinx_options) do
+      rake 'ts:rebuild'
+    end
+
+    desc 'Stop Sphinx, clear Sphinx index files, generate configuration file, start Sphinx, repopulate all data.'
+    task :regenerate, fetch(:thinking_sphinx_options) do
+      rake 'ts:regenerate'
+    end
+
+    def rake(tasks)
+      rails_env = fetch(:rails_env, 'production')
+      rake = fetch(:rake, 'rake')
+      tasks += ' INDEX_ONLY=true' if ENV['INDEX_ONLY'] == 'true'
+
+      run "if [ -d #{release_path} ]; then cd #{release_path}; else cd #{current_path}; fi; if [ -f Rakefile ]; then #{rake} RAILS_ENV=#{rails_env} #{tasks}; fi;"
+    end
+  end
+end

data/lib/thinking_sphinx/capistrano/v3.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+namespace :load do
+  task :defaults do
+    set :thinking_sphinx_roles, :db
+    set :thinking_sphinx_rails_env, -> { fetch(:rails_env) || fetch(:stage) }
+  end
+end
+
+namespace :thinking_sphinx do
+  desc <<-DESC
+Stop, reindex, and then start the Sphinx search daemon. This task must be executed \
+if you alter the structure of your indexes.
+  DESC
+  task :rebuild do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:thinking_sphinx_rails_env) do
+          execute :rake, "ts:rebuild"
+        end
+      end
+    end
+  end
+
+  desc 'Stop Sphinx, clear Sphinx index files, generate configuration file, start Sphinx, repopulate all data.'
+  task :regenerate do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:thinking_sphinx_rails_env) do
+          execute :rake, 'ts:regenerate'
+        end
+      end
+    end
+  end
+
+  desc 'Build Sphinx indexes into the shared path.'
+  task :index do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:thinking_sphinx_rails_env) do
+          execute :rake, 'ts:index'
+        end
+      end
+    end
+  end
+
+  desc 'Generate Sphinx indexes into the shared path.'
+  task :generate do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:thinking_sphinx_rails_env) do
+          execute :rake, 'ts:generate'
+        end
+      end
+    end
+  end
+
+  desc 'Restart the Sphinx search daemon.'
+  task :restart do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:thinking_sphinx_rails_env) do
+          %w(stop configure start).each do |task|
+            execute :rake, "ts:#{task}"
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Start the Sphinx search daemon.'
+  task :start do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:thinking_sphinx_rails_env) do
+          execute :rake, 'ts:start'
+        end
+      end
+    end
+  end
+  before :start, 'thinking_sphinx:configure'
+
+  desc 'Generate the Sphinx configuration file.'
+  task :configure do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:thinking_sphinx_rails_env) do
+          execute :rake, 'ts:configure'
+        end
+      end
+    end
+  end
+
+  desc 'Stop the Sphinx search daemon.'
+  task :stop do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:thinking_sphinx_rails_env) do
+          execute :rake, 'ts:stop'
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/capistrano.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+if defined?(Capistrano::VERSION)
+  if Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+    recipe_version = 3
+  end
+end
+
+recipe_version ||= 2
+require_relative "capistrano/v#{recipe_version}"

data/lib/thinking_sphinx/commander.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commander
+  def self.call(command, configuration, options, stream = STDOUT)
+    raise ThinkingSphinx::UnknownCommand unless registry.keys.include?(command)
+
+    registry[command].call configuration, options, stream
+  end
+
+  def self.registry
+    @registry ||= {
+      :clear_real_time  => ThinkingSphinx::Commands::ClearRealTime,
+      :clear_sql        => ThinkingSphinx::Commands::ClearSQL,
+      :configure        => ThinkingSphinx::Commands::Configure,
+      :index_sql        => ThinkingSphinx::Commands::IndexSQL,
+      :index_real_time  => ThinkingSphinx::Commands::IndexRealTime,
+      :merge            => ThinkingSphinx::Commands::Merge,
+      :merge_and_update => ThinkingSphinx::Commands::MergeAndUpdate,
+      :prepare          => ThinkingSphinx::Commands::Prepare,
+      :rotate           => ThinkingSphinx::Commands::Rotate,
+      :running          => ThinkingSphinx::Commands::Running,
+      :start_attached   => ThinkingSphinx::Commands::StartAttached,
+      :start_detached   => ThinkingSphinx::Commands::StartDetached,
+      :stop             => ThinkingSphinx::Commands::Stop
+    }
+  end
+end

data/lib/thinking_sphinx/commands/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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(command, extra_options = {})
+    ThinkingSphinx::Commander.call(
+      command, configuration, options.merge(extra_options), stream
+    )
+  end
+
+  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 || 1)
+  end
+
+  def log(message)
+    return if options[:silent]
+
+    stream.puts message
+  end
+
+  def skip_directories?
+    configuration.settings['skip_directory_creation']
+  end
+end

data/lib/thinking_sphinx/commands/clear_real_time.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::ClearRealTime < ThinkingSphinx::Commands::Base
+  def call
+    options[:indices].each do |index|
+      index.render
+      Dir["#{index.path}.*"].each { |path| FileUtils.rm path }
+    end
+
+    FileUtils.rm_rf(binlog_path) if File.exist?(binlog_path)
+  end
+
+  private
+
+  def binlog_path
+    configuration.searchd.binlog_path
+  end
+
+  def type
+    'clear_realtime'
+  end
+end

data/lib/thinking_sphinx/commands/clear_sql.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::ClearSQL < ThinkingSphinx::Commands::Base
+  def call
+    options[:indices].each do |index|
+      index.render
+      Dir["#{index.path}.*"].each { |path| FileUtils.rm path }
+    end
+
+    FileUtils.rm_rf Dir["#{configuration.indices_location}/ts-*.tmp"]
+  end
+
+  private
+
+  def type
+    'clear_sql'
+  end
+end

data/lib/thinking_sphinx/commands/configure.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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_real_time.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::IndexRealTime < ThinkingSphinx::Commands::Base
+  def call
+    ThinkingSphinx::RealTime.processor.call options[:indices] do
+      command :rotate
+    end
+  end
+
+  private
+
+  def type
+    'indexing'
+  end
+end

data/lib/thinking_sphinx/commands/index_sql.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::IndexSQL < ThinkingSphinx::Commands::Base
+  def call
+    if indices.empty?
+      ThinkingSphinx.before_index_hooks.each { |hook| hook.call }
+    end
+
+    configuration.indexing_strategy.call(indices) do |index_names|
+      configuration.guarding_strategy.call(index_names) do |names|
+        controller.index *names, :verbose => options[:verbose]
+      end
+    end
+  end
+
+  private
+
+  def indices
+    options[:indices] || []
+  end
+
+  def type
+    'indexing'
+  end
+end

data/lib/thinking_sphinx/commands/merge.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::Merge < ThinkingSphinx::Commands::Base
+  def call
+    return unless indices_exist?
+
+    controller.merge(
+      options[:core_index].name,
+      options[:delta_index].name,
+      :filters => options[:filters],
+      :verbose => options[:verbose]
+    )
+  end
+
+  private
+
+  delegate :controller, :to => :configuration
+
+  def indices_exist?
+    File.exist?("#{options[:core_index].path}.spi") &&
+    File.exist?("#{options[:delta_index].path}.spi")
+  end
+
+  def type
+    'merging'
+  end
+end

data/lib/thinking_sphinx/commands/merge_and_update.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::MergeAndUpdate < ThinkingSphinx::Commands::Base
+  def call
+    configuration.preload_indices
+    configuration.render
+
+    index_pairs.each do |(core_index, delta_index)|
+      command :merge,
+        :core_index  => core_index,
+        :delta_index => delta_index,
+        :filters     => {:sphinx_deleted => 0}
+
+      core_index.model.where(:delta => true).update_all(:delta => false)
+    end
+  end
+
+  private
+
+  delegate :controller, :to => :configuration
+
+  def core_indices
+    indices.select { |index| !index.delta? }.select do |index|
+      name_filters.empty? ||
+      name_filters.include?(index.name.gsub(/_core$/, ''))
+    end
+  end
+
+  def delta_for(core_index)
+    name = core_index.name.gsub(/_core$/, "_delta")
+    indices.detect { |index| index.name == name }
+  end
+
+  def index_pairs
+    core_indices.collect { |core_index|
+      [core_index, delta_for(core_index)]
+    }
+  end
+
+  def indices
+    @indices ||= configuration.indices.select { |index|
+      index.type == "plain" && index.options[:delta_processor]
+    }
+  end
+
+  def indices_exist?(*indices)
+    indices.all? { |index| File.exist?("#{index.path}.spi") }
+  end
+
+  def name_filters
+    @name_filters ||= options[:index_names] || []
+  end
+
+  def type
+    'merging_and_updating'
+  end
+end

data/lib/thinking_sphinx/commands/prepare.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::Prepare < ThinkingSphinx::Commands::Base
+  def call
+    return if skip_directories?
+
+    FileUtils.mkdir_p configuration.indices_location
+  end
+
+  private
+
+  def type
+    'prepare'
+  end
+end

data/lib/thinking_sphinx/commands/rotate.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::Rotate < ThinkingSphinx::Commands::Base
+  def call
+    controller.rotate
+  end
+
+  private
+
+  def type
+    'rotate'
+  end
+end

data/lib/thinking_sphinx/commands/running.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::Running < ThinkingSphinx::Commands::Base
+  def call
+    return true if configuration.settings['skip_running_check']
+
+    controller.running?
+  end
+
+  private
+
+  def type
+    'running'
+  end
+end

data/lib/thinking_sphinx/commands/start_attached.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::StartAttached < ThinkingSphinx::Commands::Base
+  def call
+    FileUtils.mkdir_p configuration.indices_location unless skip_directories?
+
+    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,21 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::StartDetached < ThinkingSphinx::Commands::Base
+  def call
+    FileUtils.mkdir_p configuration.indices_location unless skip_directories?
+
+    result = controller.start :verbose => options[:verbose]
+
+    if command :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,24 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Commands::Stop < ThinkingSphinx::Commands::Base
+  def call
+    unless command :running
+      log 'searchd is not currently running.'
+      return
+    end
+
+    pid = controller.pid
+    until !command :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/commands.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Commands
+  #
+end
+
+require 'thinking_sphinx/commands/base'
+require 'thinking_sphinx/commands/clear_real_time'
+require 'thinking_sphinx/commands/clear_sql'
+require 'thinking_sphinx/commands/configure'
+require 'thinking_sphinx/commands/index_sql'
+require 'thinking_sphinx/commands/index_real_time'
+require 'thinking_sphinx/commands/merge'
+require 'thinking_sphinx/commands/merge_and_update'
+require 'thinking_sphinx/commands/prepare'
+require 'thinking_sphinx/commands/rotate'
+require 'thinking_sphinx/commands/running'
+require 'thinking_sphinx/commands/start_attached'
+require 'thinking_sphinx/commands/start_detached'
+require 'thinking_sphinx/commands/stop'