heliosphere 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in heliosphere.gemspec
+gemspec

data/README.md

@@ -0,0 +1,77 @@
+# Heliosphere
+
+The problem with Sunspot is that it doesn't check if Solr is really running. This means that you get
+a nasty connection refused error whenever you save or destroy a record. We don't want that, the
+search engine is usually less important than the feature that saves models.
+
+Heliosphere tries to solve that, by making the commit hooks a bit safer. It will index if Solr is
+available, but send a request to Hoptoad if its not there. You will manually have to reindex updated
+and destroyed records.
+
+The trick Heliosphere is doing is using the Unix tool `netstat` to check if Solr is really running
+and excepting requests.
+
+There are also some helpers for Rake, Cucumber and RSpec.
+
+## Installation
+
+The definition of the indexes go outside your model. Create a stub by running:
+
+    rails generate heliosphere
+
+Modify the generated initializer to get it up and running.
+
+
+## Testing Solr status by hand
+
+Although saving records won't work now, you'll want to disable search forms or show a notice to the
+user. To check manually if Solr is running:
+
+    Heliosphere.up?
+    # or ...
+    Heliosphere.down?
+
+## Rake tasks
+
+There are alternative Rake tasks for starting/stopping/reindexing safely. The rake tasks won't fire
+up and forget, but wait until the server is really running. If Solr is already running, start won't
+complain, if it isn't running than stop won't complain. This means that restart will always work, no
+matter if solr is running or not.
+
+Find them:
+
+    rake -T heliosphere
+
+## Cucumber & RSpec
+
+Add this for Cucumber:
+
+    Before("~@search") do
+      Heliosphere::Stubs.without_search
+    end
+
+    Before("@search") do
+      Heliosphere::Stubs.with_search
+    end
+
+And this for RSpec:
+
+    RSpec.configure do |config|
+      config.extend  Heliosphere::RSpec
+    end
+
+Afterwards, use `with_search` and `without_search` inside describe blocks:
+
+    describe User do
+      without_search
+      it "will update records without indexing it in Solr"
+    end
+
+## Todo
+
+* Write tests
+* Add Capistrano support
+* Maybe forcefully stop Solr within testsuite
+* Support other ways of notifying instead of just Hoptoad
+
+Copyright (c) 2011 Iain Hecker, released under the MIT license

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/heliosphere.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "heliosphere/version"
+
+Gem::Specification.new do |s|
+  s.name        = "heliosphere"
+  s.version     = Heliosphere::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Iain Hecker"]
+  s.email       = ["iain@iain.nl"]
+  s.homepage    = "https://github.com/iain/heliosphere"
+  s.summary     = %q{Heliosphere makes Sunspot less dangerous by allowing updates to occur when Solr isn't running.}
+  s.description = %q{Saving a record is usually more important than indexing it in Solr. Heliosphere will only index when Solr is running. It also includes some convenient rake tasks and a way to declare your indexes outside your model.}
+
+  s.rubyforge_project = "heliosphere"
+
+  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"]
+end

data/lib/generators/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Creates initializer stub
+
+Example:
+    rails generate heliosphere
+
+    This will create:
+        config/initializers/heliosphere.rb

data/lib/generators/heliosphere_generator.rb

@@ -0,0 +1,9 @@
+class HeliosphereGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  desc "This generator creates an initializer file at config/initializers"
+  def create_initializer_file
+    copy_file "heliosphere.rb", "config/initializers/heliosphere.rb"
+  end
+
+end

data/lib/generators/templates/heliosphere.rb

@@ -0,0 +1,7 @@
+Heliosphere.indexer.define do
+
+  # index Widget do
+  #   text :name
+  # end
+
+end

data/lib/heliosphere/config.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+module Heliosphere
+
+  class Config
+
+    DEFAULT_CONFIG_FILE = 'config/sunspot.yml'
+
+    attr_reader :config_file
+
+    def initialize(config_file = nil)
+      @config_file = config_file || DEFAULT_CONFIG_FILE
+    end
+
+    def config
+      @config ||= YAML.load(File.read(config_file))
+    end
+
+    def port
+      @port ||= config[environment]['solr']['port']
+    end
+
+    def info
+      "Running in #{environment} environment on port #{port}"
+    end
+
+    def environment
+      Rails.env.to_s
+    end
+
+  end
+
+end

data/lib/heliosphere/indexer.rb

@@ -0,0 +1,45 @@
+module Heliosphere
+
+  def self.indexer
+    @indexer ||= Indexer.new
+  end
+
+  class Indexer
+
+    SEARCH_WITHOUT_LIFECYCLE = { :auto_index => false, :auto_remove => false }
+
+    attr_accessor :block
+
+    def define(&block)
+      instance_eval(&block)
+      apply
+    end
+
+    def model_names
+      models.map { |model| model.name.underscore.to_sym }
+    end
+
+    def apply
+      options = SEARCH_WITHOUT_LIFECYCLE
+      model_definitions.each do |model, block|
+        model.instance_eval do
+          searchable(options, &block)
+        end
+      end
+    end
+
+    def index(model, &block)
+      model_definitions[model] = block
+    end
+
+    def models
+      model_definitions.keys
+    end
+
+    def model_definitions
+      @model_definitions ||= {}
+    end
+
+  end
+
+end

data/lib/heliosphere/observer.rb

@@ -0,0 +1,39 @@
+require 'heliosphere/indexer'
+
+module Heliosphere
+
+  class Observer < ActiveRecord::Observer
+
+    observe *Heliosphere.indexer.model_names
+
+    def after_save(object)
+      running? { Sunspot.index(object) }
+    end
+
+    def after_destroy(object)
+      running? { Sunspot.remove(object) }
+    end
+
+    private
+
+    def running?
+      if Heliosphere.up?
+        yield
+      else
+        notify_hoptoad if hoptoad?
+      end
+    end
+
+    def notify_hoptoad
+      HoptoadNotifier.notify(SolrNotRunning.new, :hostname => `hostname`)
+    end
+
+    def hoptoad?
+      defined?(HoptoadNotifier)
+    end
+
+    class SolrNotRunning < Exception; end
+
+  end
+
+end

data/lib/heliosphere/railtie.rb

@@ -0,0 +1,22 @@
+require 'heliosphere/observer'
+
+module Heliosphere
+
+  class Railtie < Rails::Railtie
+
+    initializer "heliosphere.add_observer" do |app|
+      ar = app.config.active_record
+      if ar.observers
+        ar.observers += [ Heliosphere::Observer ]
+      else
+        ar.observers = [ Heliosphere::Observer ]
+      end
+    end
+
+    rake_tasks do
+      load File.expand_path("../../tasks/heliosphere.rake", __FILE__)
+    end
+
+  end
+
+end

data/lib/heliosphere/rspec.rb

@@ -0,0 +1,21 @@
+require 'heliosphere/stubs'
+
+module Heliosphere
+
+  module RSpec
+
+    def without_search
+      before :all do
+        Stubs.without_search
+      end
+    end
+
+    def with_search
+      before :all do
+        Stubs.with_search
+      end
+    end
+
+  end
+
+end

data/lib/heliosphere/server.rb

@@ -0,0 +1,52 @@
+require 'heliosphere/indexer'
+
+module Heliosphere
+
+  class Server
+
+    POLL_INTERVAL = 1
+
+    attr_reader :port
+
+    def initialize(port)
+      @port = port
+    end
+
+    def start
+      Sunspot::Rails::Server.new.start if down?
+      wait(&:up?)
+      sleep POLL_INTERVAL
+    end
+
+    def stop
+      Sunspot::Rails::Server.new.stop if up?
+      wait(&:down?)
+    end
+
+    def start_and_reindex
+      start
+      reindex
+    end
+
+    def reindex
+      Heliosphere.indexer.models.each do |model|
+        model.remove_all_from_index
+        model.index
+      end
+    end
+
+    def up?
+      `netstat -an` =~ /\b#{port}\b/m
+    end
+
+    def down?
+      not up?
+    end
+
+    def wait(&block)
+      sleep POLL_INTERVAL until yield(self)
+    end
+
+  end
+
+end

data/lib/heliosphere/stubs.rb

@@ -0,0 +1,36 @@
+module Heliosphere
+
+  module Stubs
+
+    extend self
+
+    def session
+      @session ||= Sunspot.session
+    end
+
+    def without_search
+      Sunspot.session = Sunspot::Rails::StubSessionProxy.new(session)
+    end
+
+    def with_search
+      unless Heliosphere.up?
+        sunspot = Sunspot::Rails::Server.new
+        pid = fork do
+          STDERR.reopen('/dev/null')
+          STDOUT.reopen('/dev/null')
+          sunspot.run
+        end
+        # shut down the Solr server
+        at_exit { Process.kill('TERM', pid); Heliosphere.wait(&:down?) }
+        # wait for solr to start
+        Heliosphere.wait(&:up?)
+      end
+
+      Sunspot.session = session
+      Sunspot.session.remove_all
+    end
+
+  end
+
+
+end

data/lib/heliosphere/version.rb

@@ -0,0 +1,3 @@
+module Heliosphere
+  VERSION = "0.0.1"
+end

data/lib/heliosphere.rb

@@ -0,0 +1,35 @@
+require 'heliosphere/server'
+require 'heliosphere/config'
+require 'heliosphere/railtie' if defined?(Rails)
+
+module Heliosphere
+
+  def self.start
+    server.start
+  end
+
+  def self.stop
+    server.stop
+  end
+
+  def self.reindex
+    server.start_and_reindex
+  end
+
+  def self.wait(&block)
+    server.wait(&block)
+  end
+
+  def self.up?
+    server.up?
+  end
+
+  def self.server
+    @server ||= Server.new(config.port)
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+end

data/lib/tasks/heliosphere.rake

@@ -0,0 +1,30 @@
+namespace :heliosphere do
+
+  def run(command)
+    puts Heliosphere.config.info
+    puts "Executing #{command}"
+    start = Time.now
+    Heliosphere.send(command)
+    elapsed = Time.now - start
+    puts "Executed in %0.02f seconds" % elapsed
+  end
+
+  desc "Start Solr, but don't raise an error if it's already running"
+  task :start => :environment do
+    run :start
+  end
+
+  desc "Reindex Solr, starting it if needed"
+  task :reindex => :environment do
+    run :reindex
+  end
+
+  desc "Stop Solr, if running."
+  task :stop => :environment do
+    run :stop
+  end
+
+  desc "Restart Solr safely"
+  task :restart => [ :stop, :start ]
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: heliosphere
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Iain Hecker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-26 00:00:00.000000000Z
+dependencies: []
+description: Saving a record is usually more important than indexing it in Solr. Heliosphere
+  will only index when Solr is running. It also includes some convenient rake tasks
+  and a way to declare your indexes outside your model.
+email:
+- iain@iain.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- heliosphere.gemspec
+- lib/generators/USAGE
+- lib/generators/heliosphere_generator.rb
+- lib/generators/templates/heliosphere.rb
+- lib/heliosphere.rb
+- lib/heliosphere/config.rb
+- lib/heliosphere/indexer.rb
+- lib/heliosphere/observer.rb
+- lib/heliosphere/railtie.rb
+- lib/heliosphere/rspec.rb
+- lib/heliosphere/server.rb
+- lib/heliosphere/stubs.rb
+- lib/heliosphere/version.rb
+- lib/tasks/heliosphere.rake
+homepage: https://github.com/iain/heliosphere
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: heliosphere
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Heliosphere makes Sunspot less dangerous by allowing updates to occur when
+  Solr isn't running.
+test_files: []