jberkel-solrium 0.1.0

data/README.markdown

@@ -0,0 +1,51 @@
+# Solrium
+
+A JRuby integration layer for Apache Solr/Lucene with a focus on usage from within irb.
+
+## Features
+  
+  * embed solr directly into your app
+  * convenience methods for searching using ruby idioms
+  * jetty integration
+  * bundles all necessary jars (solr, lucene & jetty)
+  
+I mainly wrote it as a tool for quickly prototyping/debugging lucene queries and solr parser plugins.
+
+Note: there's limited support for remote solr queries, searching will done in-process using a [SolrIndexSearcher](http://lucene.apache.org/solr/api/org/apache/solr/search/SolrIndexSearcher.html]), bypassing the HTTP layer. If you need to do remote queries in ruby consider using something like [sunspot](http://github.com/outoftime/sunspot) instead.
+
+## Synposis
+
+### Embedding solr into jirb
+
+    $ jirb -r lib/solr.rb
+    irb> solr = Solrium::Solr.new('/path/to/solr_home')
+    irb> solr.search("foo")
+    => [[Document: {"id"=>"1", "name_t"=>"Foomatic"}, 1.2112]] 
+    
+### Embedding jetty
+
+    $ jirb -r lib/solr.rb
+    irb> Solrium::Jetty.new('/path/to_solr_home').start(2000).join
+    2009-05-14 13:47:24.444::INFO:  jetty-7.0.0.pre5
+    ....
+    INFO: SolrDispatchFilter.init() done
+    2009-05-14 13:47:25.336::INFO:  Started SelectChannelConnector@0.0.0.0:2000
+
+## Credits
+
+Lucene, Solr, Jetty are all licensed under Apache License Version 2.0.
+
+## Contact
+
+Jan Berkel <jan.berkel@gmail.com>
+
+## License
+
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+        
+    Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
+    and limitations under the License.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "solrium"
+    gemspec.summary = "TODO"
+    gemspec.email = "jan.berkel@gmail.com"
+    gemspec.homepage = "http://github.com/jberkel/solrium"
+    gemspec.description = "A JRuby integration layer for Apache Solr/Lucene with a focus on irb integration."
+    gemspec.authors = ["Jan Berkel"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/jetty.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env jruby
+
+require 'java'
+
+Dir[File.join(File.dirname(__FILE__), 'jars', 'jetty', '*.jar')].each { |jar| require jar }
+Dir[File.join(File.dirname(__FILE__), 'jars', 'solr', '*.jar')].each { |jar| require jar }
+Dir[File.join(File.dirname(__FILE__), 'jars', 'lucene', '*.jar')].each { |jar| require jar }
+
+module Solrium
+  class Jetty
+    include_class 'org.mortbay.jetty.Server'
+    include_class 'org.mortbay.jetty.servlet.Context'
+    include_class 'org.mortbay.jetty.servlet.ServletHolder'
+    include_class 'org.mortbay.jetty.servlet.DefaultServlet'
+    include_class 'org.mortbay.jetty.handler.ResourceHandler'
+    include_class 'org.mortbay.jetty.handler.MovedContextHandler'
+    include_class 'org.mortbay.jetty.handler.HandlerList'
+    include_class 'org.apache.solr.servlet.SolrServlet'
+    include_class 'org.apache.solr.servlet.SolrUpdateServlet'
+    include_class 'org.apache.jasper.servlet.JspServlet'
+    include_class 'org.mortbay.thread.QueuedThreadPool'
+    include_class 'org.mortbay.jetty.nio.SelectChannelConnector'
+    include_class 'org.mortbay.jetty.Handler'
+  
+    
+    def initialize(dir='solr-instance')
+      Java::JavaLang::System.setProperty("solr.solr.home", dir)
+    end
+      
+    def start(port=8000, servlet_path='/solr', admin_interface=true)    
+      server = create_server(port)
+      context = create_solr_context(servlet_path, admin_interface)
+
+      hl = HandlerList.new
+      hl.add_handler(context)
+      MovedContextHandler.new(hl, '/', "#{servlet_path}/admin") if admin_interface  
+    
+      server.set_handler(hl)    
+      server.start          
+    
+      at_exit do
+        server.stop rescue nil
+      end        
+      server
+    end    
+  
+    private
+    def create_server(port)
+      server = Server.new
+
+      thread_pool = QueuedThreadPool.new
+      thread_pool.min_threads  = 5
+      thread_pool.max_threads  = 50
+      server.set_thread_pool(thread_pool)
+
+      #use the more efficient NIO connector
+      connector = SelectChannelConnector.new
+      connector.port = port 
+
+      server.add_connector(connector)
+      server
+    end
+
+    def create_solr_context(path, admin_interface=true)
+      context = Context.new(nil, path, Context::SESSIONS)
+      context.add_servlet(ServletHolder.new(DefaultServlet.new), "/")
+      context.add_servlet(ServletHolder.new(JspServlet.new), "*.jsp")
+      context.add_filter('org.apache.solr.servlet.SolrDispatchFilter', '/*', Handler::DEFAULT)
+      context.set_mime_types(Java::org.mortbay.jetty.MimeTypes.new)
+      context.mime_types.add_mime_mapping('xsl', 'application/xslt+xml')
+
+      if admin_interface
+        jsp_servlet = ServletHolder.new(JspServlet.new)
+        jsp_servlet.set_forced_path('/admin/ping.jsp')
+
+        context.add_servlet(jsp_servlet, '/admin/ping')
+        context.set_resource_base(File.join(File.dirname(__FILE__), 'webapp'))
+      end
+    
+      context          
+    end
+  end
+end

data/lib/lucene.rb

@@ -0,0 +1,33 @@
+require 'java'
+require File.join(File.dirname(__FILE__), 'queries')
+
+module Solrium
+  
+  # simple lucene integration, bypassing solr completely
+  class Lucene
+    include Queries
+        
+    include_class 'org.apache.lucene.queryParser.QueryParser'
+    include_class 'org.apache.lucene.analysis.standard.StandardAnalyzer'
+    include_class 'org.apache.lucene.search.IndexSearcher'
+
+    attr_accessor :index_path
+    
+    def initialize(solr_home = "solr-instance")      
+      @index_path = File.join(solr_home, 'data', 'index')
+    end
+
+    def analyzer
+      StandardAnalyzer.new
+    end
+
+    def with_searcher(&block)        
+      searcher = IndexSearcher.new(@index_path)
+      begin
+        block.call(searcher)
+      ensure
+        searcher.close
+      end
+    end    
+  end  
+end

data/lib/queries.rb

@@ -0,0 +1,60 @@
+require 'java'
+
+require File.join(File.dirname(__FILE__), 'solr_ext')
+
+module Solrium
+  module Queries
+    
+    include_class 'org.apache.lucene.queryParser.QueryParser'      
+    include_class 'org.apache.lucene.search.MultiPhraseQuery'
+    include_class 'org.apache.lucene.search.WildcardTermEnum'
+    
+    include_class 'org.apache.lucene.search.BooleanQuery'
+    include_class 'org.apache.lucene.search.WildcardQuery'
+    include_class 'org.apache.lucene.search.TermQuery'
+            
+      
+    # convenience search method
+    def search(q, max=10, &block)      
+      q = q.is_a?(org.apache.lucene.search.Query) ? q : parse(q.to_s)
+       
+      block ||= lambda do |doc, score, searcher|       
+        [doc, score]
+      end
+         
+      with_searcher do |searcher|  
+        searcher.search(q, nil, max).scoreDocs.map do |sd|
+          block.call(searcher.doc(sd.doc), sd.score, searcher)
+        end
+      end
+    end
+    
+    def parse(q, default='default')
+      QueryParser.new(default, analyzer).parse(q)
+    end
+        
+    #a wildcard phrase query
+    def wildcard_pq(*terms)      
+      return MultiPhraseQuery.new if terms.empty?
+            
+      if terms.size == 1
+        #only one term, do simple term+wildcard query
+        bq = BooleanQuery.new
+        bq.add(TermQuery.new(Term[terms[0]]), org.apache.lucene.search.BooleanClause::Occur::SHOULD)
+        bq.add(WildcardQuery.new(Term[terms[0] + "*"]), org.apache.lucene.search.BooleanClause::Occur::SHOULD)
+        return bq
+      end
+        
+      mpq = MultiPhraseQuery.new
+        
+      terms[0..-2].each { |t| mpq.add(Term[t]) }
+
+      with_searcher do |s|
+        completions = WildcardTermEnum.new(s.reader, Term["#{terms[-1]}*"]).to_java_array
+        return MultiPhraseQuery.new if completions.length == 0
+        mpq.add(completions) 
+      end
+      mpq
+    end
+  end
+end

data/lib/remote.rb

@@ -0,0 +1,22 @@
+require 'net/http'
+require 'uri'
+require 'cgi'
+
+module Solrium      
+  module Remote
+    extend self
+    
+    def query(q, params={}, port=8000)  
+      params['q']  = q
+      params['wt'] = 'ruby'  
+
+      url = URI.parse("http://localhost:#{port}")
+      res = Net::HTTP.start(url.host, url.port) do |http|          
+        http.get("/solr/select?" + params.map { |k,v| "#{k}=#{CGI.escape(v)}" }.join("&"))
+      end
+      res.value    
+      eval(res.body)
+    end
+    
+  end
+end

data/lib/solr.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env jruby
+require 'java'
+
+Dir[File.join(File.dirname(__FILE__), 'jars', 'lucene', '*.jar')].each { |jar| require jar } 
+Dir[File.join(File.dirname(__FILE__), 'jars', 'solr', '*.jar')].each { |jar| require jar } 
+
+require File.join(File.dirname(__FILE__), 'solr_ext')
+require File.join(File.dirname(__FILE__), 'lucene')
+require File.join(File.dirname(__FILE__), 'queries')
+require File.join(File.dirname(__FILE__), 'remote')
+require File.join(File.dirname(__FILE__), 'jetty')
+
+module Solrium      
+  #wrapper for SolrCore
+  class Solr
+    include Queries
+    include Remote
+    
+    include_class 'org.apache.solr.core.SolrCore'
+    include_class 'org.apache.solr.core.SolrConfig'
+
+    attr_accessor :config, :core
+    
+    def initialize(solr_home='solr-instance')
+      Java::JavaLang::System.setProperty("solr.solr.home", solr_home)
+      @config = SolrConfig.new
+      @core = SolrCore.new('core', nil, @config, nil, nil)
+
+      at_exit do
+        @core.close rescue nil
+      end
+    end
+
+    def analyzer
+      core.schema.analyzer
+    end
+    
+    def with_searcher(&block)
+      searcher_ref = core.searcher
+      searcher = searcher_ref.get
+      begin
+        block.call(searcher)
+      ensure
+        searcher_ref.decref
+      end
+    end    
+  end
+end

data/lib/solr_ext.rb

@@ -0,0 +1,59 @@
+# make lucene/solr a bit more rubyis
+module Solrium
+  include_class 'org.apache.lucene.index.TermEnum'
+  include_class 'org.apache.lucene.index.Term'
+  include_class 'org.apache.lucene.document.Document'
+  include_class 'org.apache.lucene.document.Field'      
+      
+  class Document
+    def [](n)
+      self.getField(n)
+    end
+    
+    def inspect
+      "Document: " + to_hash.inspect
+    end
+    
+    def to_hash
+      fields.inject({}) do |h, f|
+        h[f.name] = f.stringValue()
+        h
+      end
+    end
+  end
+  
+  class Field
+    def inspect
+      "#{name}: #{to_s}"
+    end
+    
+    def to_s
+      self.stringValue()
+    end
+  end
+  
+  # lets you use Term['foo'] ==> Term.new('default', foo)
+  class Term
+    def self.[](t)
+      new('default', t)
+    end
+  end
+   
+  #make TermEnum a bit friendlier to use          
+  class TermEnum
+    include Enumerable
+
+    def each
+     while self.next()
+       yield(self.term())
+     end
+    end
+
+    def to_java_array
+     elements = to_a
+     array = java.lang.reflect.Array.newInstance(Term.java_class, elements.length)
+     elements.each_with_index { |e,i| array[i] = e }
+     array
+    end
+  end
+end

data/lib/webapp/admin/_info.jsp

@@ -0,0 +1,110 @@
+<%--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+--%>
+<%@ page import="org.apache.solr.core.SolrConfig,
+                 org.apache.solr.core.SolrCore,
+                 org.apache.solr.schema.IndexSchema,
+                 java.io.File"%>
+<%@ page import="java.net.InetAddress"%>
+<%@ page import="java.io.StringWriter"%>
+<%@ page import="org.apache.solr.core.Config"%>
+<%@ page import="org.apache.solr.common.util.XML"%>
+<%@ page import="org.apache.solr.common.SolrException"%>
+<%@ page import="org.apache.lucene.LucenePackage"%>
+<%@ page import="java.net.UnknownHostException" %>
+<%
+  // 
+  SolrCore  core = (SolrCore) request.getAttribute("org.apache.solr.SolrCore");
+  if (core == null) {
+    response.sendError( 404, "missing core name in path" );
+    return;
+  }
+    
+  SolrConfig solrConfig = core.getSolrConfig();
+  int port = request.getServerPort();
+  IndexSchema schema = core.getSchema();
+
+  // enabled/disabled is purely from the point of a load-balancer
+  // and has no effect on local server function.  If there is no healthcheck
+  // configured, don't put any status on the admin pages.
+  String enabledStatus = null;
+  String enabledFile = solrConfig.get("admin/healthcheck/text()",null);
+  boolean isEnabled = false;
+  if (enabledFile!=null) {
+    isEnabled = new File(enabledFile).exists();
+  }
+
+  String collectionName = schema!=null ? schema.getName():"unknown";
+  InetAddress addr = null;
+  String hostname = "unknown";
+  try {
+    addr = InetAddress.getLocalHost();
+    hostname = addr.getCanonicalHostName();
+  } catch (UnknownHostException e) {
+    //default to unknown
+  }
+
+  String defaultSearch = "";
+  { 
+    StringWriter tmp = new StringWriter();
+    XML.escapeCharData
+      (solrConfig.get("admin/defaultQuery/text()", null), tmp);
+    defaultSearch = tmp.toString();
+  }
+
+  String solrImplVersion = "";
+  String solrSpecVersion = "";
+  String luceneImplVersion = "";
+  String luceneSpecVersion = "";
+
+  { 
+    Package p;
+    StringWriter tmp;
+
+    p = SolrCore.class.getPackage();
+
+    tmp = new StringWriter();
+    solrImplVersion = p.getImplementationVersion();
+    if (null != solrImplVersion) {
+      XML.escapeCharData(solrImplVersion, tmp);
+      solrImplVersion = tmp.toString();
+    }
+    tmp = new StringWriter();
+    solrSpecVersion = p.getSpecificationVersion() ;
+    if (null != solrSpecVersion) {
+      XML.escapeCharData(solrSpecVersion, tmp);
+      solrSpecVersion = tmp.toString();
+    }
+  
+    p = LucenePackage.class.getPackage();
+
+    tmp = new StringWriter();
+    luceneImplVersion = p.getImplementationVersion();
+    if (null != luceneImplVersion) {
+      XML.escapeCharData(luceneImplVersion, tmp);
+      luceneImplVersion = tmp.toString();
+    }
+    tmp = new StringWriter();
+    luceneSpecVersion = p.getSpecificationVersion() ;
+    if (null != luceneSpecVersion) {
+      XML.escapeCharData(luceneSpecVersion, tmp);
+      luceneSpecVersion = tmp.toString();
+    }
+  }
+  
+  String cwd=System.getProperty("user.dir");
+  String solrHome= solrConfig.getInstanceDir();
+%>