solr_wrapper 0.0.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad8d234af6fa4899c3f7b644e6248777e4bf06d6
-  data.tar.gz: ac6a83319475f98f193647760afd044a8c35a33a
+  metadata.gz: '092270d968ea024833bc6185caf854c05c8e623e'
+  data.tar.gz: 83d3dd71ca0de7c18ee9090a06ff051b174dbf4a
 SHA512:
-  metadata.gz: 5bc27e00fceb2043c300f75e814ba38461b279ebe7f62d522408ea8020bea031bbcc915f8a9aab921f648e269dd48573ccdafc8121a365402893ba78c14dafa6
-  data.tar.gz: b2e501bf7e1e92d57d3c11c80db9e29b4910a51057cf3b1913a6dfb8c233ae95e2f02fc3b26cabe70b7013abc5e3f8b3fa7412bc744d353a62ee65220133712a
+  metadata.gz: c4da5d83939b7d10b089d4453b79fb778aa499809cbd114d634fe8e7e790a21896c73320055fa43d3682559768fcb5729f2062bde7ab1ee9beeb92e967c1cf50
+  data.tar.gz: c7373e52dcd5520e541947655b1e95c6fcd53e9ccf7b356d7bf2efa37f60bb36555508451bc46546c92b3b1899859040453072802e54ba9fd59238fed106553d

data/.hound.yml

@@ -0,0 +1,2 @@
+ruby:
+  config_file: .rubocop.yml

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,16 @@
+inherit_from:
+  - .rubocop_todo.yml
+
+AllCops:
+  Exclude:
+  - "*.gemspec"
+
+Metrics/LineLength:
+  Enabled: false
+
+# Offense count: 61
+Metrics/AbcSize:
+  Max: 59
+
+Style/RescueModifier:
+  Enabled: false

data/.travis.yml

@@ -1,8 +1,13 @@
 language: ruby
 sudo: false
 rvm:
-  - 2.2.0
-  - jruby
-cache:
-  directories:
-  - /tmp/solr-5.0.0
+  - 2.4.1
+  - 2.3.4
+  - jruby-9.1.8.0
+
+jdk:
+  - oraclejdk8
+
+env:
+  global:
+    JRUBY_OPTS=-J-Xmx2g

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in solr_wrapper.gemspec
-gemspec
+gemspec

data/README.md

@@ -11,18 +11,93 @@ end
 Or with Solr and a solr collection:
 
 ```ruby
-  subject.wrap do |solr|
-    solr.with_collection(dir: File.join(FIXTURES_DIR, "basic_configs")) do |collection_name|
-    end
+SolrWrapper.wrap do |solr|
+  solr.with_collection(dir: File.join(FIXTURES_DIR, "basic_configs")) do |collection_name|
   end
+end
 ```
 
 ## Basic Options
 
 ```ruby
-SolrWrapper.wrap port: 8983, verbose: true, managed: true 
+SolrWrapper.wrap port: 8983,
+                 verbose: true,
+                 managed: true,
+                 instance_dir: '/opt/solr'
+```
+
+### Valid ruby and YAML options
+
+|Option         |                                         |
+|---------------|-----------------------------------------|
+| instance_dir  | Directory to store the solr index files |
+| url           | URL of the Zip file to download |
+| version       | Solr version to download and install |
+| port          | port to run Solr on |
+| version_file  | Local path to store the currently installed version |
+| download_dir  | Local path for storing the downloaded Solr zip file |
+| solr_zip_path | Local path to the Solr zip file |
+| md5sum        | Path/URL to MD5 checksum |
+| solr_xml      | Path to Solr configuration |
+| verbose       | (Boolean) |
+| managed       | (Boolean) |
+| ignore_md5sum | (Boolean) |
+| solr_options  | (Hash) |
+| env           | (Hash) |
+| persist      | (Boolean) Preserves the data in you collection between startups |
+
+```ruby
+solr.with_collection(name: 'collection_name', dir: 'path_to_solr_configs')
+```
+
+## From the command line
+
+```console
+$ solr_wrapper -p 8983
+```
+To see a list of valid options when using solr_wrapper to launch a Solr instance from the command line:
+```
+$ solr_wrapper -h
+```
+
+### Configuration file
+SolrWrapper can read configuration options from a YAML configuration file.
+By default, it looks for configuration files at `.solr_wrapper` and `~/.solr_wrapper`.
+
+You can also specify a configuration file when launching from the command line as follows:
+```
+$ solr_wrapper -config <path_to_config_file>
+```
+
+### Cleaning your repository from the command line
+
+By defualt SorlWrapper will clean out your data when it shuts down.
+If you utilize the preserve option your data will remain between runs.
+
+To clean out data that is being preserved explicitly run:
+```
+$ solr_wrapper <configuration options> clean
+```
+***Note*** You must use the same configuration options on the clean command as you do on the run command to clean the correct instance.
+
+## Rake tasks
+
+SolrWrapper provides rake tasks for installing, starting and stopping solr.  To include the tasks in your Rake environment, add this to your Rakefile
+
+```ruby
+  require 'solr_wrapper/rake_task'
 ```
 
+You can configure the tasks by setting `SolrWrapper.default_instance_options`.  For example:
+
 ```ruby
-solr.with_collection(name: 'collection_name', dir: 'path_to_solr_confiigs')
-```
+SolrWrapper.default_instance_options = {
+    verbose: true,
+    cloud: true,
+    port: '8888',
+    version: '5.3.1',
+    instance_dir: 'solr',
+    download_dir: 'tmp'
+}
+require 'solr_wrapper/rake_task'
+```

data/Rakefile

@@ -1,8 +1,7 @@
 require "bundler/gem_tasks"
 
-
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: ['spec']
+task default: ['spec']

data/exe/solr_wrapper

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+
+require 'solr_wrapper'
+require 'optparse'
+
+options = {}
+collection_options = {}
+subtext = <<HELP
+Commonly used command are:
+   clean :     cleans all data from solr and configures a clean instance based on configuration options
+   dir   :     prints the solr instance dir
+See 'solr_wrapper COMMAND --help' for more information on a specific command.
+HELP
+
+args = OptionParser.new do |opts|
+  opts.banner = "Usage: solr_wrapper [options] subcommand"
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on("--config FILE", "Load configuration from a file") do |v|
+    options[:config] = v
+  end
+
+  opts.on("--version VERSION", "Specify a Solr version to download (default: #{SolrWrapper.default_solr_version})") do |v|
+    options[:version] = v
+  end
+
+  opts.on("-pPORT", "--port PORT", "Specify the port Solr should run at (default: #{SolrWrapper.default_solr_port})") do |p|
+    if p == 'random'
+      options[:port] = nil
+    else
+      options[:port] = p
+    end
+  end
+
+  opts.on("-c", "--cloud", "Run solr in cloud mode") do |c|
+    options[:cloud] = c
+  end
+
+  opts.on("--solr_zip_path PATH", "Download/use solr at the given path") do |d|
+    options[:solr_zip_path] = d
+  end
+
+  opts.on("-iDIR", "--instance_directory DIR", "Install/use solr at the given directory") do |d|
+    options[:instance_dir] = d
+  end
+
+  opts.on("-lDIR", "--lib_directory DIR", "Grab extra libs from this directory") do |d|
+    options[:extra_lib_dir] = d
+  end
+
+  opts.on("-nNAME", "--collection_name NAME", "Create a default solr collection with the given name") do |c|
+    collection_options[:name] = c
+  end
+
+  opts.on("-dDIR", "--collection_config DIR", "Create a default solr collection with the files from the given directory") do |d|
+    collection_options[:dir] = d
+  end
+
+  opts.on("--[no-]persist", "Persist the solr connection data") do |d|
+    collection_options[:persist] = d
+  end
+
+  opts.on("--no-checksum", "Skip running checksum validation on the downloaded file") do |d|
+    options[:ignore_md5sum] = true
+  end
+
+  opts.separator ""
+  opts.separator subtext
+end
+
+
+subcommands = {
+    'clean' => OptionParser.new do |opts|
+      opts.banner = "Usage: clean"
+    end,
+    'dir' => OptionParser.new do |opts|
+      opts.banner = "Usage: dir"
+    end,
+}
+
+
+begin
+  args.order!
+  command = ARGV.shift
+  if command
+    raise "Bad subcommand: #{command}" unless subcommands[command]
+    subcommands[command].order!
+  end
+  args.parse!
+rescue => error
+  $stderr.puts "ERROR: #{error}\n"
+  $stderr.puts args.help
+  exit 1
+end
+
+instance = SolrWrapper.instance(options)
+
+case command
+when 'clean'
+  if instance.started?
+    $stderr.puts "Please stop solr before cleaning"
+    exit 1
+  end
+  $stderr.puts "cleaning #{instance.instance_dir}..."
+  instance.remove_instance_dir!
+when 'dir'
+  puts instance.instance_dir
+else
+  $stderr.print "Starting Solr #{instance.version} on port #{instance.port} ... "
+  instance.wrap do |conn|
+    conn.with_collection(collection_options) do
+      $stderr.puts "http://#{instance.host}:#{instance.port}/solr/"
+      begin
+        conn.wait
+      rescue Interrupt
+        Signal.trap("SIGTERM") {"IGNORE"}
+        Signal.trap("SIGINT") {"IGNORE"}
+        $stderr.puts "Solr is shutting down."
+      end
+    end
+  end
+end

data/lib/solr_wrapper/client.rb

@@ -0,0 +1,36 @@
+require 'faraday'
+require 'json'
+
+module SolrWrapper
+  # Solr REST API client to get status information
+  class Client
+    attr_reader :url
+
+    def initialize(url)
+      @url = url
+    end
+
+    # Check if a core or collection exists
+    def exists?(core_or_collection_name)
+      collection?(core_or_collection_name) || core?(core_or_collection_name)
+    end
+
+    private
+
+    def collection?(name)
+      response = conn.get('admin/collections?action=LIST&wt=json')
+      data = JSON.parse(response.body)
+      return if data['error'] && data['error']['msg'] == 'Solr instance is not running in SolrCloud mode.'
+      data['collections'].include? name
+    end
+
+    def core?(name)
+      response = conn.get('admin/cores?action=STATUS&wt=json&core=' + name)
+      !JSON.parse(response.body)['status'][name].empty?
+    end
+
+    def conn
+      @conn ||= Faraday.new(url: url)
+    end
+  end
+end

data/lib/solr_wrapper/configuration.rb

@@ -0,0 +1,163 @@
+require 'faraday'
+
+module SolrWrapper
+  class Configuration
+    attr_reader :options
+
+    def initialize(options = {})
+      @config = options[:config]
+      @verbose = options[:verbose]
+
+      @options = load_configs(Array(options[:config])).merge(options)
+    end
+
+    def solr_xml
+      options[:solr_xml]
+    end
+
+    def extra_lib_dir
+      options[:extra_lib_dir]
+    end
+
+    def validate
+      options[:validate]
+    end
+
+    def ignore_md5sum
+      options[:ignore_md5sum]
+    end
+
+    def md5sum
+      options[:md5sum]
+    end
+
+    def url
+      options[:url]
+    end
+
+    def port
+      # Check if the port option has been explicitly set to nil.
+      # this means to start solr wrapper on a random open port
+      return nil if options.key?(:port) && !options[:port]
+      options.fetch(:port) { SolrWrapper.default_instance_options[:port] }.to_s
+    end
+
+    def zookeeper_host
+      options[:zookeeper_host]
+    end
+
+    def zookeeper_port
+      options[:zookeeper_port]
+    end
+
+    def solr_zip_path
+      options[:solr_zip_path]
+    end
+
+    def download_dir
+      options[:download_dir] || default_download_dir
+    end
+
+    def default_download_dir
+      if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+        File.join(Rails.root, 'tmp')
+      else
+        Dir.tmpdir
+      end
+    end
+
+    def solr_options
+      options.fetch(:solr_options, {})
+    end
+
+    def env
+      options.fetch(:env, {})
+    end
+
+    def instance_dir
+      options[:instance_dir]
+    end
+
+    def version
+      @version ||= begin
+        config_version = options.fetch(:version, SolrWrapper.default_instance_options[:version])
+        if config_version == 'latest'
+          fetch_latest_version
+        else
+          config_version
+        end
+      end
+    end
+
+    def mirror_url
+      "http://www.apache.org/dyn/closer.lua/lucene/solr/#{version}/solr-#{version}.zip?asjson=true"
+    end
+
+    def cloud
+      options[:cloud]
+    end
+
+    def verbose?
+      @verbose || (options && !!options.fetch(:verbose, false))
+    end
+
+    def version_file
+      options[:version_file]
+    end
+
+    def collection_options
+      hash = options.fetch(:collection, {})
+      Configuration.slice(convert_keys(hash), :name, :dir, :persist)
+    end
+
+    def configsets
+      configsets = options[:configsets] || []
+      configsets.map { |x| convert_keys(x) }
+    end
+
+    def poll_interval
+      options.fetch(:poll_interval, 1)
+    end
+
+    private
+
+      def self.slice(source, *keys)
+        keys.each_with_object({}) { |k, hash| hash[k] = source[k] if source.has_key?(k) }
+      end
+
+      def load_configs(config_files)
+        config = {}
+
+        (default_configuration_paths + config_files.compact).each do |p|
+          path = File.expand_path(p)
+          next unless File.exist? path
+          config.merge!(read_config(path))
+        end
+
+        config
+      end
+
+      def read_config(config_file)
+        $stdout.puts "Loading configuration from #{config_file}" if verbose?
+        config = YAML.load(ERB.new(IO.read(config_file)).result(binding))
+        unless config
+          $stderr.puts "Unable to parse config #{config_file}" if verbose?
+          return {}
+        end
+        convert_keys(config)
+      end
+
+      def convert_keys(hash)
+        hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      end
+
+      def default_configuration_paths
+        ['~/.solr_wrapper.yml', '~/.solr_wrapper', '.solr_wrapper.yml', '.solr_wrapper']
+      end
+
+      def fetch_latest_version
+        response = Faraday.get('https://svn.apache.org/repos/asf/lucene/cms/trunk/content/latestversion.mdtext')
+        response.body.strip
+      end
+  end
+end

data/lib/solr_wrapper/downloader.rb

@@ -0,0 +1,25 @@
+require 'ruby-progressbar'
+
+module SolrWrapper
+  class Downloader
+    def self.fetch_with_progressbar(url, output)
+      pbar = SafeProgressBar.new(title: File.basename(url), total: nil, format: '%t: |%B| %p%% (%e )')
+      open(url, content_length_proc: ->(bytes) { pbar.total = bytes }, progress_proc: ->(bytes) { pbar.progress = bytes }) do |io|
+        IO.copy_stream(io, output)
+      end
+    rescue OpenURI::HTTPError => e
+      raise SolrWrapperError, "Unable to download solr from #{url}\n#{e.message}: #{e.io.read}"
+    end
+
+    class SafeProgressBar < ProgressBar::Base
+      def progress=(new_progress)
+        self.total = new_progress if total <= new_progress
+        super
+      end
+
+      def total=(new_total)
+        super if new_total && new_total > 0
+      end
+    end
+  end
+end