eson-core 0.7.0

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Florian Gilcher <florian.gilcher@asquera.de>, Felix Gilcher <felix.gilcher@asquera.de>
+
+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,5 @@
+# eson-core
+
+Core classes for implementing an ElasticSearch client.
+
+This is a meta-gem that provides a definition of the whole ElasticSearch API (parameter values, required parameters, etc.). It also provides a client class for working with these definitions.

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+def gemspec
+  @gemspec ||= begin
+    file = File.expand_path("eson-core.gemspec")
+    ::Gem::Specification.load(file)
+  end
+end
+
+desc "Validates the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.gem_spec = gemspec
+end
+
+task :package => :gemspec
+
+Rake::TestTask.new(:test) do |test|
+  if 'jruby' == RUBY_ENGINE
+    test.pattern = 'test/**/*_test.rb'
+  else
+    test.pattern = 'test/{http,search}/*_test.rb'
+  end 
+  
+  test.verbose = true
+end
+
+task :seed do
+  require './test/seeds/seeds'
+end

data/eson-core.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "eson-core"
+  s.version     = "0.7.0" #Echolon::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Florian Gilcher"]
+  s.email       = ["florian.gilcher@asquera.de"]
+  s.homepage    = ""
+  s.summary     = %q{A modular client for ElasticSearch - Core components}
+  s.description = %q{A modular client for ElasticSearch. It provides
+  an implementation of the Query language as well as multiple client implementations
+  for HTTP and native access.}
+
+  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"]
+  
+  s.add_dependency "multi_json"
+  s.add_development_dependency "elasticsearch-node"
+end

data/lib/eson/api.rb

@@ -0,0 +1,63 @@
+module Eson
+  module API
+    include Chainable
+    
+    def parameters(*params)
+      chainable do
+        define_method :parameters do
+          super() + params
+        end
+        
+        params.each do |p|
+          attr_accessor p
+        end
+      end
+    end
+    
+    # Designates the name of the parameter that will be used as the
+    # body of the request. Use only if the API has such a parameter (e.g. Search).
+    # You still have to list this parameter.
+    # 
+    # If multiple parameters are given, they will act as the keys in the sent
+    # JSON object.
+    #
+    # @example source_param call
+    #   source_param :settings, :mappings
+    # @example result
+    #   {
+    #     "settings" : {...},
+    #     "mappings" : {...}
+    #   }
+    def source_param(*params)
+      if params.length == 1
+        params = params.first
+      end
+      
+      define_method :source_param do
+        params
+      end
+    end
+    
+    def multi_index(bool)
+      define_method :multi_index do
+        bool
+      end
+    end
+    
+    def multi_types(bool)
+      define_method :multi_types do
+        bool
+      end
+    end
+    
+    def no_indices(bool)
+      define_method :no_indices do
+        bool
+      end
+    end
+    
+    def register(mod)
+      include(mod)
+    end
+  end
+end

data/lib/eson/chainable.rb

@@ -0,0 +1,20 @@
+# code from the datamapper project. See http://datamapper.org
+
+module Eson
+  module Chainable
+
+    # @api private
+    def chainable(&block)
+      mod = Module.new(&block)
+      include mod
+      mod
+    end
+
+    # @api private
+    def extendable(&block)
+      mod = Module.new(&block)
+      extend mod
+      mod
+    end
+  end
+end

data/lib/eson/client.rb

@@ -0,0 +1,253 @@
+module Eson
+  class Client
+    attr_accessor :server
+    attr_accessor :index_name
+    attr_accessor :default_index
+    attr_accessor :protocol
+    attr_accessor :plugins
+    attr_accessor :opts
+    attr_accessor :auto_call
+    
+    DEFAULT_OPTS = {
+                      :server => 'http://127.0.0.1:9200',
+                      :plugins => [],
+                      :logger => nil,
+                      :default_index => "default"
+                   }
+    
+    # TODO: allow multiple servers and pick them at random
+    def initialize(opts = {})
+      opts = DEFAULT_OPTS.merge(opts)
+      
+      self.server        = opts[:server]
+      self.default_index = opts[:default_index]
+      self.protocol      = opts[:protocol] || Eson::HTTP
+      self.plugins       = opts[:plugins]
+      self.logger        = opts[:logger]
+      if opts[:auto_call].nil?
+        self.auto_call = true
+      else
+        self.auto_call = opts[:auto_call]
+      end
+      self.opts          = opts
+    end
+    
+    def node
+      self.server
+    end
+    
+    def logger=(logger)
+      protocol.logger = logger
+    end
+    
+    def logger(logger)
+      protocol.logger
+    end
+    
+    def auth?
+      !!opts[:auth]
+    end
+    
+    def auth
+      opts[:auth]
+    end
+    
+    def index_name
+      @index_name || default_index
+    end
+    
+    def [](index_name)
+      c = self.clone
+      c.index_name = index_name
+      c
+    end
+    
+    def index(args = {}, immediate = auto_call)
+      request(protocol::Index, args, immediate)
+    end
+    
+    def delete(args = {}, immediate = auto_call)
+      request(protocol::Delete, args, immediate)
+    end
+    
+    def get(args = {})
+      request(protocol::Get, args)
+    end
+    
+    def mget(args = {})
+      request(protocol::MultiGet, args)
+    end
+    
+    def search(args = {}, immediate = auto_call, &block)
+      request(protocol::Search, args, immediate, &block)
+    end
+    alias :query :search
+    
+    def simple_search(args = {})
+      request(protocol::SimpleSearch, args)
+    end
+    
+    def count(args = {})
+      request(protocol::Count, args)
+    end
+    
+    def percolate(args = {}, &block)
+      request(protocol::Percolate, args, &block)
+    end
+    
+    def bulk(args = {}, &block)
+      if block_given?
+        request(protocol::Bulk, args, &block)
+      else
+        request(protocol::Bulk, args, false)
+      end
+    end
+    
+    def msearch(args = {}, &block)
+      if block_given?
+        request(protocol::MultiSearch, args, &block)
+      else
+        request(protocol::MultiSearch, args, false)
+      end
+    end
+    
+    def delete_by_query(args = {}, &block)
+      request(protocol::DeleteByQuery, args, &block)
+    end
+    
+    def more_like_this(args = {})
+      request(protocol::MoreLikeThis, args)
+    end
+    
+    def health(args = {})
+      request(protocol::Health, args)
+    end
+    
+    def state(args = {})
+      request(protocol::State, args)
+    end
+    
+    def stats(args = {})
+      request(protocol::Stats, args)
+    end
+    
+    def nodes(args = {})
+      request(protocol::Nodes, args)
+    end
+    
+    def shutdown(args = {})
+      request(protocol::Shutdown, args)
+    end
+    
+    def aliases(args = {}, &block)
+      request(protocol::Aliases, args, &block)
+    end
+    
+    def analyze(args = {})
+      request(protocol::Analyze, args)
+    end
+    
+    def clear_cache(args = {})
+      request(protocol::ClearCache, args)
+    end
+    
+    def close_index(args = {})
+      request(protocol::CloseIndex, args)
+    end
+    
+    def open_index(args = {})
+      request(protocol::OpenIndex, args)
+    end
+    
+    def create_index(args = {})
+      request(protocol::CreateIndex, args)
+    end
+    
+    def delete_index(args = {})
+      request(protocol::DeleteIndex, args)
+    end
+    
+    def delete_mapping(args = {})
+      request(protocol::DeleteMapping, args)
+    end
+    
+    def get_mapping(args = {})
+      request(protocol::GetMapping, args)
+    end
+    
+    def put_mapping(args = {})
+      request(protocol::PutMapping, args)
+    end
+    
+    def put_template(args = {})
+      request(protocol::PutTemplate, args)
+    end
+    
+    def get_template(args = {})
+      request(protocol::GetTemplate, args)
+    end
+    
+    def delete_template(args = {})
+      request(protocol::DeleteTemplate, args)
+    end
+    
+    def get_settings(args = {})
+      request(protocol::GetSettings, args)
+    end
+    
+    def update_settings(args = {})
+      request(protocol::UpdateSettings, args)
+    end
+    
+    def flush(args = {})
+      request(protocol::Flush, args)
+    end
+    
+    def optimize(args = {})
+      request(protocol::Optimize, args)
+    end
+    
+    def refresh(args = {})
+      request(protocol::Refresh, args)
+    end
+    
+    def snapshot(args = {})
+      request(protocol::Snapshot, args)
+    end
+    
+    def status(args = {})
+      request(protocol::Status, args)
+    end
+    
+    def index_stats(args = {})
+      request(protocol::IndexStats, args)
+    end
+    
+    def segments(args = {})
+      request(protocol::Segments, args)
+    end
+    
+    def exists?(args = {})
+      request(protocol::IndexExists, args)
+    rescue Eson::NotFoundError
+      false
+    end
+    
+    private
+      def request(endpoint, args, auto_call = auto_call)
+        r = protocol::Request.new(endpoint, plugins, self)
+        
+        r.params = args
+        
+        if block_given?
+          r.handle_block(&Proc.new)
+        end
+        
+        if auto_call
+          r.call
+        else
+          r
+        end
+      end
+  end
+end

data/lib/eson/error.rb

@@ -0,0 +1,14 @@
+module Eson
+  class Error < StandardError
+    attr_accessor :response
+    
+    def initialize(msg, response)
+      super(msg)
+      
+      self.response = response
+    end
+  end
+  
+  NotFoundError = Class.new(Error)
+  IndexNotFoundError = Class.new(NotFoundError)
+end

data/lib/eson/request.rb

@@ -0,0 +1,113 @@
+module Eson
+  class Request
+    attr_accessor :api, :client
+
+    attr_accessor :pretty, :source, :index, :indices, :case
+
+    def initialize(api, plugins, client)
+      self.api = api
+      self.client = client
+      self.extend(api)
+
+      Array(plugins).each do |p|
+        if pluggable?(api, p, client)
+          self.extend(p)
+        end
+      end
+    end
+
+    def handle_block
+      yield self
+    end
+
+    def params=(params)
+      params.each do |k,v|
+        begin
+          self.send("#{k}=", v)
+        rescue NoMethodError => e
+          raise NoMethodError, "Tried to set parameter `#{k}`, but request has no such parameter."
+        end
+      end
+    end
+
+    def pluggable?(api, plugin, client)
+      if plugin.respond_to? :plugin_for
+        plugin.plugin_for(client.protocol).include?(api)
+      else
+        true
+      end
+    end
+
+    def index
+      @index || client.index_name
+    end
+
+    def parameters
+      if self.respond_to?(:multi_index) && (multi_index == true)
+        [:pretty, :indices, :case]
+      elsif self.respond_to?(:multi_index) && (multi_index == false)
+        [:pretty, :index, :case]
+      else
+        [:pretty, :case]
+      end
+    end
+
+    def indices
+      if @indices
+        Array(@indices)
+      else
+        Array(self.index)
+      end
+    end
+
+    def source
+      @source || source_from_params
+    end
+
+    # TODO: woah, this needs refactoring
+
+    def source_from_params
+      return nil unless self.respond_to? :source_param
+
+      if Symbol === source_param
+        obj = self.send source_param
+        if (String === obj || obj.nil?)
+          return obj
+        else
+          return encode(obj)
+        end
+      else
+        pairs = source_param.map do |p|
+          if v = self.send(p)
+            [p, v]
+          else
+            nil
+          end
+        end
+        pairs.compact!
+
+        return nil if pairs.empty?
+
+        obj = {}
+
+        pairs.each do |p, v|
+          obj[p] = v
+        end
+
+        return encode(obj)
+      end
+    end
+
+    def encode(obj)
+      if obj.respond_to? :to_query_hash
+        obj = obj.to_query_hash
+      end
+
+      if obj.respond_to? :to_json
+        obj.to_json
+      else
+        MultiJson.encode(obj)
+      end
+    end
+  end
+end

data/lib/eson/shared/cluster/health.rb

@@ -0,0 +1,16 @@
+module Eson
+  module Shared
+    module Health
+      extend API
+      
+      multi_index true
+      
+      parameters :wait_for_status,
+                 :level,
+                 :wait_for_relocating_shards,
+                 :wait_for_nodes,
+                 :timeout
+      
+    end
+  end
+end

data/lib/eson/shared/cluster/nodes.rb

@@ -0,0 +1,15 @@
+module Eson
+  module Shared
+    module Nodes
+      extend API
+      
+      multi_index false
+      
+      parameters :nodes
+      
+      def nodes
+        Array(@nodes)
+      end
+    end
+  end
+end

data/lib/eson/shared/cluster/shutdown.rb

@@ -0,0 +1,20 @@
+module Eson
+  module Shared
+    module Shutdown
+      #TODO fully implement and test this
+      extend API
+      
+      multi_index false
+
+      parameters :nodes,
+                 :delay,
+                 :master,
+                 :local,
+                 :all
+      
+      def nodes
+        Array(@nodes)
+      end
+    end
+  end
+end

data/lib/eson/shared/cluster/state.rb

@@ -0,0 +1,17 @@
+module Eson
+  module Shared
+    module State
+      extend API
+      #TODO implement filter_indices correctly
+      
+      multi_index true
+      
+      parameters :filter_nodes,
+                 :filter_routing_table,
+                 :filter_metadata,
+                 :filter_blocks,
+                 :filter_indices
+            
+    end
+  end
+end

data/lib/eson/shared/cluster/stats.rb

@@ -0,0 +1,15 @@
+module Eson
+  module Shared
+    module Stats
+      extend API
+      
+      multi_index false
+      
+      parameters :nodes
+      
+      def nodes
+        Array(@nodes)
+      end
+    end
+  end
+end

data/lib/eson/shared/core/bulk.rb

@@ -0,0 +1,26 @@
+module Eson
+  module Shared
+    module Bulk
+      extend API
+
+      source_param :bulk
+      parameters :bulk
+
+      def bulk
+        @bulk ||= []
+      end
+
+      def <<(request)
+        bulk << request
+      end
+
+      def index(args, immediate = nil)
+        self << client.index(args, false)
+      end
+
+      def delete(args, immediate = nil)
+        self << client.delete(args, false)
+      end
+    end
+  end
+end