multi-solr 01.01.05

data/lib/multi_solr/solr_filter_collection.rb

@@ -0,0 +1,97 @@
+# Filter für einfachen Wert mit Wertebereich als Collection
+# und Darstellung als Select-Box.
+# Der Wertebereich wird dabei über eine FacetSuche ermittelt (per Methode 'list_possible_values' des Searchers)
+#
+class MultiSolr::SolrFilterCollection < MultiSolr::SolrFilterSimple
+
+  # Constructor des Filters
+  # Params:
+  #   filter_name: Name des Filters als Symbol
+  #   options:     optionale Hash mit den folgenden Optionen (sind alle optional):
+  #     :render_value      siehe Optionen bei MultiSolr::SolrFilterSimple.initialize
+  #     :solr_query        siehe Optionen bei MultiSolr::SolrFilterSimple.initialize
+  #     :collection_data:  Proc, welches den Wertebereich(Array) liefert
+  #                        Wenn nicht angegeben, dann wird per 'Searcher.list_possible_values'
+  #                        mit den Name des Filters der Wertebereich ermittelt.
+  #                        Das Proc bekommt den Such-Context(Hash) als Parameter (enthält i.a. Searcher und force-query-params).
+  #                        Beispiel: :collection_data => lambda{|context| (2..10).to_a }
+  #     :after_collect:    optionales Proc, welches den Wertebereich(Array) nachbearbeitet
+  #                        Das Proc bekommt den Wertebereich(Array) als Parameter
+  #                        Beispiel: :after_collect => lambda{|data| MasterData::LockType.cached_find_for_short_names(data).map{|l| [l.full_label, l.short_name] } }
+  #
+  def initialize filter_name, options={}
+    @collection_proc = options.delete(:collection_data)
+    @after_collect_proc = options.delete(:after_collect)
+    if options[:render_value].nil?
+      options[:render_value] = lambda{|value| compact_values(value).join(' oder ') }
+    end
+    if options[:solr_query].nil?
+      options[:solr_query] = lambda do |value|
+        if value.is_a?(Array)
+          values = compact_values(value)
+          if values.empty?
+            ''
+          else
+            q = values.map{|val| "#{@name}:#{val}"}.join(' OR ')
+            "(#{q})"
+          end
+        else
+          "#{@name}:#{value}"
+        end
+      end
+    end
+    super filter_name, options
+  end
+
+
+  # Generieren Select-Box für ein Sematic-Form
+  # Params:   siehe MultiSolr::SolrFilterSimple#render_for_semantic_form
+  # returns:  HTML-Code des Input-Feldes als Select-Box
+  def render_for_semantic_form sform, value, context=nil, form_input_options={}
+    form_input_options = @options[:semantic_form].merge form_input_options if @options.key? :semantic_form
+    set_label form_input_options
+    data = self.collection_data(nil, context)
+    html_options = form_input_options[:input_html]
+    if html_options
+      if html_options[:size]
+        # size wird als max-size verstanden. wenn akt. Data-Range kleiner
+        # ist, dann darauf reduzieren
+        html_options[:size] = [data.size+1, html_options[:size].to_i].min
+      end
+    end
+    form_input_options.merge! :collection => data
+    sform.input "filter_#{@name}", form_input_options
+  end
+
+
+  # Ermittelt den Wertebereich entweder über die bei den Options angegebene Proc
+  # oder über list_possible_values des Searchers (mit den Namen des Filters als Parameter)
+  # Params:
+  #   core_handler:   Instanz des konkreten Solr-CoreHandler (MultiSolr::SingleCoreHandler)
+  #   context:        Hash mit dem Such-Context.
+  #   search_request: optional bestehendes SearchRequest (für DrillDown-Funktionalität)
+  # returns:    Array mit dem Wertebereich
+  def collection_data core_handler, context, search_request=nil
+    if @collection_proc
+      data = @collection_proc.call(context)
+    else
+      data = core_handler.cached_list_possible_values(self.name, context, search_request)
+    end
+    if @after_collect_proc
+      data = @after_collect_proc.call(data)
+      data.compact!
+    end
+    data
+  end
+
+
+  # Wandeltangegebener value in ein Array (wenn es noch keins ist)
+  # Bereinigt das Array von leeren Elementen
+
+  def compact_values value
+    value = [value] unless value.is_a?(Array)
+    value.delete_if(&:blank?)
+  end
+
+end
+

data/lib/multi_solr/solr_filter_date.rb

@@ -0,0 +1,46 @@
+# Filter für Datumsbereiche mit von- und bis-Datum
+
+class MultiSolr::SolrFilterDate < MultiSolr::SolrFilterSimple
+
+
+  # Constructor des Filters
+  # Params:
+  #   filter_name: Name des Filters als Symbol
+  #   options:     optionale Hash mit Optionen (siehe SolrFilterSimple) plus:
+  #     :mode      Type der Nutzung des ang. Datums (Symbol):
+  #                :from => Datum wird mit Zeit 00:00:00 genutzt
+  #                :to => Datum wird mit Zeit 23:59:59 genutzt
+  #                nil => Datum wird im Bereich 00:00:00 bis 23:59:59
+  #
+  def initialize filter_name, options={}
+    @mode = options.delete(:mode)
+    super(filter_name, options)
+  end
+
+
+  # Erzeugen des SolR-Query-Strings
+  def build_solr_query value
+    return nil if value.blank?
+    date_range = nil
+    case @mode
+      when :from
+        date_range = "[#{value}T00:00:00Z TO *]"
+      when :to
+        date_range = "[* TO #{value}T23:59:59Z]"
+      else
+        date_range = "[#{value}T00:00:00Z TO #{value}T23:59:59Z]"
+    end
+    "#{@field_name}:#{date_range}"
+  end
+
+
+  def render_value value
+    value.to_s
+  end
+
+
+end
+
+
+
+

data/lib/multi_solr/solr_filter_date_range.rb

@@ -0,0 +1,62 @@
+# Filter für Datumsbereiche mit von- und bis-Datum
+
+class MultiSolr::SolrFilterDateRange < MultiSolr::SolrFilterSimple
+
+  # Erzeugen des SolR-Query-Strings
+  def build_solr_query value
+    from, to = extract_from_to_in_ISO8601 value
+    return nil if from.nil? && to.nil?
+    "#{@field_name}:[#{from || '*'} TO #{to || '*'}]"
+  end
+
+
+  def render_value value
+    from, to = extract_from_to value
+    return '' if from.nil? && to.nil?
+    s = []
+    s << "&gt;=#{from}" unless from.blank?
+    s << "&lt;=#{to}" unless to.blank?
+    s.join(' und ')
+  end
+
+
+  # Generieren der 2 Input-Felder mit der Option :as => :date_picker
+  # Dadurch können diesem Felder das jQuery-Datepicker-UI nutzen
+  # Params:   siehe MultiSolr::SolrFilterSimple#render_for_semantic_form
+  # returns:  HTML-Code mit 2 Input-Feldern
+  def render_for_semantic_form sform, value, context=nil, form_input_options={}
+    set_label form_input_options
+    label = form_input_options[:label]
+    form_input_options.merge! :as => :date_picker
+    from, to = extract_from_to value
+    date_range = Struct.new("#{@name}_from".to_sym, "#{@name}_to".to_sym).new from,to
+    sform.semantic_fields_for "filter_#{@name}", date_range do |filter_form|
+      form_input_options[:label] = "#{label} ab"
+      sform.template.concat filter_form.input("#{@name}_from", form_input_options)
+      form_input_options[:label] = "#{label} bis"
+      sform.template.concat filter_form.input("#{@name}_to", form_input_options)
+    end
+  end
+
+  
+  # Aus dem 'value' von und bis extrahieren
+  # Params:
+  #   value: Hash mit from- und to-Datumsangabe (mit Filternamen als Prefix)
+  #          Beispiel: { 'create_date_from' => '2011-01-01', 'create_date_to' => '2011-06-01' }
+  # returns: Array mit von und bis ['2011-01-01', '2011-06-01']
+  def extract_from_to value
+    return nil if value.blank? || !value.is_a?(Hash) || value.empty?
+    [ value["#{@name}_from"], value["#{@name }_to"] ]
+  end
+
+  def extract_from_to_in_ISO8601 value
+    from, to = extract_from_to value
+    d_from = from.blank? ? nil : "#{from}T00:00:00Z"
+    d_to = to.blank? ? nil : "#{to}T23:59:59Z"
+    [d_from, d_to]
+  end
+end
+
+
+
+

data/lib/multi_solr/solr_filter_free_query.rb

@@ -0,0 +1,11 @@
+# Filter für eine freie Query-Eingabe die direkt so an den SOLR geht
+
+class MultiSolr::SolrFilterFreeQuery < MultiSolr::SolrFilterSimple
+
+  def build_solr_query value
+    return nil if value.blank?
+    value
+  end
+
+end
+

data/lib/multi_solr/solr_filter_simple.rb

@@ -0,0 +1,96 @@
+# Einfacher Solr-Filter mit einem String als Value
+# Ist auch Basisklasse für alle erweiterten Filter
+
+class MultiSolr::SolrFilterSimple
+
+  attr_reader :name     # Name des Filters als Symbol
+  attr_reader :options  # Options des Filters
+
+  # Constructor des Filters
+  # Params:
+  #   filter_name: Name des Filters als Symbol
+  #   options:     optionale Hash mit den folgenden Optionen  (sind alle optional):
+  #     :render_value   Proc welcher den Filter-Value in einem String zur Darstellung generiert
+  #                     Ist dieser nicht angegeben so wird 'value.to_s' benutzt
+  #                     Beispiel: :render_value => lambda{|value| ItemSize::HANDLINGS[value.to_i] }
+  #     :field_name     Name des zu nutzenden Solr-Fields, default ist filter_name
+  #     :solr_query     Proc welcher den SolR-Query-String mit den Filter-Value bildet.
+  #                     Wenn nicht angegeben wird <field_name>:<value> benutzt
+  #                     Beispiel: :solr_query => lambda{|value|  "teileanzahl:[#{value} TO *]" }
+  #
+  def initialize name, options={}
+    @name = name
+    @field_name = options[:field_name] || @name
+    @value_render_proc = options.delete(:render_value) || lambda{|value| value.to_s }
+    @solr_query_proc = options.delete(:solr_query) || lambda{|value| "#{@field_name}:#{value}"}
+    @options = options || {}
+  end
+
+
+  # Bilden des SolR-Query-Strings entweder
+  # per bei der Erzeugung angegebenen solr-query-Proc
+  # oder aus Filter-Namen und dem spezifizierten 'value'
+  # Besteht der 'value' aus mehren Worten, so wird er automatisch in Hochkomma eingeschlossen
+  # ( 'test sample' => '"test sample"')
+  # Params:
+  #   value: der konkrete Wert für diesen Filter
+  # returns: String in SOLR-Query-Syntax
+  def build_solr_query value
+    return nil if value.blank?
+    # wenn Leerzeichen vorkommen dann String in " einschliessen
+    value = "\"#{value}\"" if value =~ /\s+/
+    @solr_query_proc.call(value)
+  end
+
+
+  # Konvertieren der Wertes in den Darstellungs-String
+  # Nutzt wenn bei den Init-Options angegeben den hinterlegten Proc (value_render).
+  # Ansonsten wird nur 'value.to_s' aufgerufen.
+  # Params:
+  #   value: der konkrete Wert für diesen Filter
+  # returns: String
+  def render_value value
+    return '' if value.nil?
+    @value_render_proc.call(value)
+  end
+
+
+
+
+  # Konvertieren der Wertes in HTML-String für ein Semantic-Form
+  # Params:
+  #   sform:              das Semantic-Form-Object
+  #   value:              der konkrete Wert für diesen Filter
+  #   context:            optionaler Hash mit dem Such-Context z.B. mit;
+  #                         :solr_searcher_class => Classe des konkreten Searchers
+  #                         :force_query_params => Parameter für die SolR-Force-Query
+  #   form_input_options: optionale Formula-Input-Feld-Options.
+  #                       Diese werden 1:1 an die Semantic-Form-Methode 'input' weitergegeben
+  #
+  # returns:  HTML-Code des Input-Feldes
+  def render_for_semantic_form sform, value, context=nil, form_input_options={}
+    form_input_options = @options[:semantic_form].merge form_input_options if @options.key? :semantic_form
+    set_label form_input_options
+    sform.input "filter_#{@name}", form_input_options
+  end
+
+
+  def label
+    I18n.t("solr_search.#{@name}", :default => @name.to_s)
+  end
+
+  protected
+
+  # Setzt in die angegebebn 'form_input_options' das Label (nur wenn in diesen noch kein :label definiert ist).
+  # Dieses wird gebildet aus den Filter-Namen unter Nutzung von I18n mit den Prefiy 'solr_search.'.
+  # Beispiel:
+  #   filter-name = :lkz => I18n.t('solr_search.lkz')
+  def set_label form_input_options
+    form_input_options.merge!(:label => self.label) unless form_input_options.key?(:label)
+  end
+
+end
+
+
+
+

data/lib/multi_solr/timeline_core_handler.rb

@@ -0,0 +1,131 @@
+require "fileutils"
+
+class MultiSolr::TimelineCoreHandler
+
+  attr_reader :simple_core_handler_class
+  attr_reader :core_group_name
+  attr_reader :solr_url
+
+
+  def initialize solr_url, core_group_name, simple_core_handler_class
+    @simple_core_handler_class = simple_core_handler_class
+    @core_group_name = core_group_name
+    @solr_url = solr_url || raise("No solr-url given!")
+  end
+
+
+  def create_single_core_handler core_name=nil, options=nil
+    core_name ||= last_core_name
+    @simple_core_handler_class.new @solr_url, core_name, options
+  end
+
+
+
+  # Liefert Array mit den Namen der verfügbaren Cores, die mit dem Core-Namen (see core_name) beginnen
+  # Diese Liste wird gecached
+  def list_cores include_empties=false
+    return @cores if @cores
+    status = self.core_status
+    @cores = []
+    matcher = Regexp.new "^#{@core_group_name}"
+    status.each do |core_name, data|
+      next unless matcher.match(core_name)
+      next if data['index']['numDocs'] < 3 && !include_empties
+      @cores << core_name
+    end
+    @cores.sort!
+    MultiSolr.logger.info "MultiSolr::TimelineCoreHandler.list_cores: #{@cores.join(',')}"
+    @cores
+  end
+
+  # Rücksetzen Cache der core-liste (see list_cores)
+  def reset_cores
+    @cores = @last_core_name = nil
+  end
+
+  # Liefert Name des letzte Cores der laut alphabetischer Liste (see list_cores) existiert
+  def last_core_name
+    @last_core_name ||= list_cores.last
+  end
+
+  def base_connection
+    @_connection ||= RSolr.connect :url => @solr_url
+  end
+
+
+  def core_connection core_name=nil
+    core_name ||= last_core_name
+    RSolr.connect :url => "#{@solr_url}/#{core_name}"
+  end
+
+
+  def create_core suffix=nil
+    suffix = Time.now.strftime('%Y%m%d-%H%M') if suffix.nil?
+    new_core_name = "#{@core_group_name}-#{suffix}"
+    status = self.core_status last_core_name
+    old_name = status['name']
+    instance_dir_old = status['instanceDir']
+    instance_dir = instance_dir_old.sub(/^solr\//, '') # führendes solr im instanceDir ist zuviel, also entfernen
+    data_dir = status['dataDir'].sub(/#{old_name}\/$/, new_core_name)
+    data_dir.sub!(/^#{instance_dir_old}/, '')# führendes instanceDir im dataDir ist zuviel, also entfernen
+    res = self.base_connection.get 'admin/cores', :params => {:action => 'CREATE',
+                                                  :name => new_core_name,
+                                                  :instanceDir => instance_dir,
+                                                  :dataDir => data_dir}
+    reset_cores
+    MultiSolr.logger.info "MultiSolr::TimelineCoreHandler.create_core: Core '#{new_core_name}' created. dataDir=#{data_dir}, instanceDir=#{instance_dir}"
+    new_core_name
+  end
+
+
+  def dataimport import_handler_name, command='full-import', core_name=nil
+    core_name ||= last_core_name
+    con = core_connection core_name
+    res = con.get import_handler_name, :params => {:command => command}
+    MultiSolr.logger.info "MultiSolr::TimelineCoreHandler.dataimport: core=#{core_name}, command=#{command}, handler=#{import_handler_name}"
+    res
+  end
+
+  # Entfernen angegebenen Core aus der Core-Liste inkl. unload-Befehl an den Solr
+  # Achtung! Diese Methode löscht kann nur dann die physischen Daten des Cores löschen,
+  # wenn dieser mit einer absoluten Pfad-Angabe im solr konfiguriert ist!
+  # Parameter:
+  #   core_name:    Name des zu löschenden Cores
+  #   with_data:    optionaler Angabe ob Daten mit gelöscht werden sollen (Standardmäßig aus)
+  def remove_core core_name, with_data=false
+    status = self.core_status core_name
+    raise "no core '#{core_name}'!" if status.nil? || status['name'].nil?
+    base_connection.get 'admin/cores', :params => {:action => 'unload', :core => core_name}
+    MultiSolr.logger.info "MultiSolr::TimelineCoreHandler.remove_core: Core '#{core_name}' unloaded"
+    if with_data
+      data_dir = status['dataDir']
+      raise "No absolute DataDir-Path! Only Core was unloaded!" unless data_dir.start_with?('/')
+      FileUtils.rm_rf data_dir
+    end
+    reset_cores
+    nil
+  end
+
+
+  # Liefert Core-Status evtl. aller Cores oder wenn Core-Name angegeben des einzelnen Cores
+  # returns Hash mit den Statusdaten
+  #   Beispiel für alle Cores:
+  #      {'core-01'=>{'name'=>'core-01',
+  #                   'instanceDir'=>'solr/cobra-stock/',
+  #                   'dataDir'=>'solr/cobra-stock/../../data/cobra-stock/',
+  #                   'startTime'=>'2012-04-11T09:49:07.93Z',
+  #                   'uptime'=>7796905,
+  #                   'index'=>{'numDocs'=>1369046,'maxDoc'=>1369046,'version'=>1334134600492,'optimized'=>true,'current'=>true,'hasDeletions'=>false,'directory'=>'org.apache.lucene.store.NIOFSDirectory:org.apache.lucene.store.NIOFSDirectory@/home/bledig/Projects/lava/multi-solr/data/cobra-stock-20120411-1123/index lockFactory=org.apache.lucene.store.NativeFSLockFactory@1896a4c','lastModified'=>'2012-04-11T09:43:32Z'}},
+  #                  },...
+  #      }
+  def core_status core_name=nil
+    params = {:action => 'STATUS' }
+    params[:core] = core_name if core_name
+    res = base_connection.get 'admin/cores', :params => params
+    status = res && res['status']
+    raise 'No status for cores available' if status.nil?
+    return status[core_name] if core_name
+    status
+  end
+
+end

data/lib/multi_solr/version.rb

@@ -0,0 +1,3 @@
+module MultiSolr
+  VERSION = "01.01.05"
+end

data/lib/multi_solr.rb

@@ -0,0 +1,43 @@
+
+require 'logger'
+require 'active_support/cache'
+
+require 'multi_solr/version'
+require 'multi_solr/solr_filter_simple'
+require 'multi_solr/solr_filter_collection'
+require 'multi_solr/solr_filter_date'
+require 'multi_solr/solr_filter_date_range'
+require 'multi_solr/solr_filter_free_query'
+require 'multi_solr/filter_value_composite'
+require 'multi_solr/search_request'
+require 'multi_solr/search_result'
+require 'multi_solr/base_searcher'
+require 'multi_solr/single_core_handler'
+require 'multi_solr/timeline_core_handler'
+
+module MultiSolr
+
+  @@logger = nil
+  @@cache = nil
+
+  def logger
+    return Rails.logger if defined? Rails
+    if @@logger.nil?
+      @@logger = Logger.new($stdout)
+    end
+    @@logger
+  end
+
+
+  def cache
+    return Rails.cache if defined? Rails
+    if @@cache.nil?
+      @@cache = ActiveSupport::Cache::MemoryStore.new
+    end
+    @@cache
+  end
+
+  module_function :logger, :cache
+
+end
+

data/multi-solr.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "multi_solr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "multi-solr"
+  s.version     = MultiSolr::VERSION
+  s.authors     = ["Bernd Ledig"]
+  s.email       = ["bernd.ledig@ottogroup.com"]
+  s.homepage    = ""
+  s.summary     = %q{SOLR-Framework with support for multiple SOLR-Cores}
+  s.description = %q{SOLR-Framework wit multi-core supoort and filters}
+
+  s.rubyforge_project = "multi-solr"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_runtime_dependency "rsolr", '>1.0', '<2.0'
+  s.add_runtime_dependency "activesupport", '>3.0', '<4.0'
+  s.add_runtime_dependency "i18n"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", '>2.7', '<3.0'
+end

data/spec/fixtures/solr-testdata.yml

@@ -0,0 +1,13 @@
+---
+- id: 101
+  lager_id: 8
+  menge: 7
+  artikelnr: 124536
+- id: 102
+  lager_id: 8
+  menge: 7
+  artikelnr: 847362
+- id: 103
+  lager_id: 24
+  menge: 1
+  artikelnr: 895466