supernova-core 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tobias Schwab
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Supernova::Core
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'supernova-core'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install supernova-core
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/bin/solr_admin

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$:<<File.expand_path("../../lib", __FILE__)
+require "supernova/solr/cli"
+
+Supernova::Solr::CLI.new(ARGV).execute

data/lib/functional_delegator.rb

@@ -0,0 +1,44 @@
+module FunctionalDelegator
+  module ClassMethods
+    # class Page
+    #   attr_reader :url, :protocol
+    #
+    #   def initialize(url, protocol)
+    #     @url = url
+    #     @protocol = protocol
+    #   end
+    #
+    #   def self.get(url)
+    #     Net::HTTP.get(URI.parse(url))
+    #   end
+    #
+    #   def self.post(url, body)
+    #     Net::HTTP.post(URI.parse(url))
+    #   end
+    #
+    #   def self.head(url, protocol)
+    #     Net::HTTP.head(URI.parse(url), protocol)
+    #   end
+    #
+    #   functional_delegate :get, :post,  :attributes => :url
+    #   functional_delegate :head,        :attributes => [:url, :protocol]
+    # end
+    #
+    # Page.new("http://www.dynport.de").get                # delegates to Page.get("http://www.dynport.de")
+    # Page.new("http://www.dynport.de").post("the body")   # delegates to Page.post("http://www.dynport.de", "the body")
+    # Page.new("http://www.dynport.de", "HTTP/1.1").head   # delegates to Page.head("http://www.dynport.de", "HTTP/1.1")
+    def functional_delegate(*keys)
+      raise "ERROR: last argument must be e.g. :attributes => [:url]" if !keys.last.is_a?(Hash) || !keys.last.has_key?(:attributes)
+      keys[0..-2].each do |method|
+        define_method(method) do |*args|
+          all_args = [keys.last[:attributes]].flatten.map { |att| self.send(att) } + args
+          self.class.send(method, *all_args)
+        end
+      end
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+end

data/lib/supernova-core.rb

@@ -0,0 +1,7 @@
+require "supernova-core/version"
+
+module Supernova
+  module Core
+    # Your code goes here...
+  end
+end

data/lib/supernova-core/version.rb

@@ -0,0 +1,5 @@
+module Supernova
+  module Core
+    VERSION = "0.0.1"
+  end
+end

data/lib/supernova.rb

@@ -0,0 +1,18 @@
+module Supernova
+  class << self
+    attr_accessor :logger
+    private :logger
+
+    def log(message, method = :info)
+      logger.send(method, message) if logger
+    end
+  end
+
+  module Solr
+    class << self
+      def remove_trailing_slash(url)
+        url.gsub(/[\/]+$/, "")
+      end
+    end
+  end
+end

data/lib/supernova/batch_indexer.rb

@@ -0,0 +1,40 @@
+class Supernova::BatchIndexer
+  def initialize(index, batch_size = 1_000)
+    @index = index
+    @batch_size = batch_size
+    @docs = []
+    if block_given?
+      yield(self)
+      finish
+    end
+  end
+
+  def index_doc(doc)
+    @docs << doc
+    if should_index?
+      do_index
+    end
+  end
+
+  def finish
+    do_index
+  end
+
+  private
+
+  def should_index?
+    @docs.count >= @batch_size
+  end
+
+  def do_index
+    started = Time.now
+    @index.index_docs(@docs) if @docs.any?
+    Supernova.log(do_index_log_message(started, Time.now, @docs))
+    @docs = []
+  end
+
+  def do_index_log_message(started, finished, docs)
+    diff = finished - started
+    "indexed #{docs.count} docs in %.3f seconds (%.1f docs/second)" % [diff, docs.count / diff]
+  end
+end

data/lib/supernova/solr/cli.rb

@@ -0,0 +1,169 @@
+require "optparse"
+require "supernova"
+require "supernova/solr/server"
+require "supernova/solr/core"
+
+class Supernova::Solr::CLI
+  SOLR_URL = "http://localhost:8983/solr"
+  SOLR_VERSION = "3.5.0"
+
+  attr_accessor :options
+
+  def initialize(args)
+    self.options = {}
+    opts.parse(args)
+  end
+
+  def opts
+    OptionParser.new do |o|
+      o.on("--core CORE", String) do |core_name|
+        self.options[:core] = core_name
+      end
+
+      o.on("--server SERVER", String) do |server_name|
+        self.options[:server] = server_name
+      end
+
+      o.separator ""
+      o.separator "Server ACTIONS"
+
+
+      o.on("--start-server", "Start SOLR server") do |solr_bin|
+        self.options[:action] = :start
+      end
+
+      o.on("--server-status", "SOLR server status") do |solr_bin|
+        self.options[:action] = :server_status
+      end
+
+      o.on("--stop-server", "Stop SOLR server") do |solr_bin|
+        self.options[:action] = :stop
+      end
+
+      o.separator ""
+      o.separator "Core ACTIONS"
+
+      o.on("--list-cores", "List Cores") do
+        self.options[:action] = :list
+      end
+
+      o.on("--create", "Create Core") do
+        self.options[:action] = :create
+      end
+
+      o.on("--commit", "Commit Core") do
+        self.options[:action] = :commit
+      end
+
+      o.on("--optimize", "Optimize Core") do
+        self.options[:action] = :optimize
+      end
+
+      o.on("--unload", "Unload Core") do
+        self.options[:action] = :unload
+      end
+
+      o.separator ""
+      o.separator "OPTIONS"
+
+      o.on("--solr-bin SOLR_BIN", "Path to SOLR jarfile") do |solr_bin|
+        self.options[:solr_bin] = solr_bin
+      end
+    end
+  end
+
+  def core
+    Supernova::Solr::Core.new(solr_url, core_name)
+  end
+
+  def server
+    Supernova::Solr::Server.new(solr_url)
+  end
+
+  def execute
+    if action = options[:action]
+      send(action)
+    else
+      puts opts
+    end
+  end
+
+  def commit
+    handle_response core.commit
+  end
+
+  def optimize
+    handle_response core.optimize
+  end
+
+  def unload
+    handle_response core
+  end
+
+  def create
+    handle_response core.create(options[:data], options[:instance])
+  end
+
+  def list
+    server.core_names.sort.each do |name|
+      puts name
+    end
+  end
+
+  def start
+    puts "starting SOLR"
+    exec start_solr_cmd
+  end
+
+  def server_status
+    if solr_pid
+      puts "SOLR running with pid #{solr_pid}"
+    else
+      puts "SOLR NOT running"
+    end
+  end
+
+  def stop
+    if solr_pid
+      system("kill #{solr_pid}")
+      puts "solr killed"
+    else
+      puts "solr not running"
+    end
+  end
+
+  def handle_response(response)
+    puts response.to_json
+  end
+
+  def start_solr_cmd
+    "cd #{File.dirname(solr_bin_path)} && /usr/bin/env java -Dsolr.solr.home=#{solr_home} -jar #{File.basename(solr_bin_path)} > /opt/solr/solr.log 2>&1 &"
+  end
+
+  def solr_pid
+    @solr_pid ||= get_solr_pid
+  end
+
+  def get_solr_pid
+    cmd = %(ps ax | grep "\\-Dsolr" | grep -v "grep" | grep -v " cd ")
+    if pid_s = `#{cmd}`[/^(\d+)/, 1]
+      pid_s.to_i
+    end
+  end
+
+  def solr_home
+    "/opt/solr"
+  end
+
+  def solr_bin_path
+    options[:solr_bin] || "/usr/local/Cellar/solr/#{SOLR_VERSION}/libexec/example/start.jar"
+  end
+
+  def solr_url
+    options[:server] || SOLR_URL
+  end
+
+  def core_name
+    options[:core]
+  end
+end

data/lib/supernova/solr/core.rb

@@ -0,0 +1,41 @@
+require "supernova"
+require "supernova/solr/server"
+require "typhoeus"
+require "json"
+
+class Supernova::Solr::Core < Supernova::Solr::Server
+  attr_reader :solr_url, :name
+  DEFAULT_SOLR_PATH = "/opt/solr"
+
+  def initialize(solr_url, name)
+    @solr_url = Supernova::Solr.remove_trailing_slash(solr_url)
+    @name = name
+  end
+
+  def url
+    "#{solr_url}/#{name}"
+  end
+
+  # add instance methods which call class methods with :attributes + original attributes
+  functional_delegate :create, :unload, :status, :exists?, :attributes => [:solr_url, :name]
+
+  class << self
+    def create(solr_url, core_name, instance_dir = nil, data_dir = nil)
+      instance_dir ||= DEFAULT_SOLR_PATH
+      data_dir ||= "#{DEFAULT_SOLR_PATH}/data/#{core_name}"
+      admin_action(solr_url, "CREATE", "name=#{core_name}&instanceDir=#{instance_dir}&dataDir=#{data_dir}")
+    end
+
+    def unload(solr_url, core_name)
+      admin_action(solr_url, "UNLOAD", "core=#{core_name}&deleteIndex=true")
+    end
+
+    def status(solr_url, core_name)
+      admin_action(solr_url, "STATUS", "core=#{core_name}")
+    end
+
+    def exists?(solr_url, core_name)
+      !status(solr_url, core_name)["status"][core_name].empty?
+    end
+  end
+end

data/lib/supernova/solr/mapper.rb

@@ -0,0 +1,31 @@
+class Supernova::Solr::Mapper
+
+  DEFAULT_MAPPINGS = { :id => :id }
+  SUFFIXES = {
+    :string => :s,
+    :integer => :i,
+    :float => :f,
+    :boolean => :b,
+    :multi_string => :ms,
+    :time => :dt,
+    :date => :dt,
+  }
+
+  def initialize(mapping = {})
+    @mapping = DEFAULT_MAPPINGS.merge(mapping).inject({}) do |hash, (from, to)|
+      hash[from] = SUFFIXES[to] ? :"#{from}_#{SUFFIXES[to]}" : to
+      hash
+    end
+  end
+
+  def map(hash)
+    mapping.inject({}) do |solr_hash, (from, to)|
+      solr_hash[to] = hash[from]
+      solr_hash
+    end
+  end
+
+  private
+
+  attr_reader :mapping
+end