es_client 0.1.0

data/lib/es_client/active_record/shortcuts.rb

@@ -0,0 +1,17 @@
+module EsClient
+  module ActiveRecord
+    module Shortcuts
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method :es_doc, :es_client_document
+      end
+
+      module ClassMethods
+        def es_find(*args)
+          es_client.find(*args)
+        end
+      end
+    end
+  end
+end

data/lib/es_client/client.rb

@@ -0,0 +1,71 @@
+module EsClient
+  class Client
+    RETRY_TIMES = 1
+
+    def initialize(host, options)
+      @host = host
+      @options = options
+    end
+
+    def get(path, options={})
+      request options.merge(method: :get, path: path)
+    end
+
+    def post(path, options={})
+      request options.merge(method: :post, path: path)
+    end
+
+    def put(path, options={})
+      request options.merge(method: :put, path: path)
+    end
+
+    def delete(path, options={})
+      request options.merge(method: :delete, path: path)
+    end
+
+    def head(path, options={})
+      request options.merge(method: :head, path: path)
+    end
+
+    def request(options)
+      retry_times = 0
+      begin
+        raw_response = http.request(options)
+        response = ::EsClient::Response.new(raw_response.body, raw_response.status, raw_response.headers)
+        EsClient.logger.request(http, response, options) if EsClient.logger.try!(:debug?)
+        response
+      rescue Excon::Errors::SocketError => e
+        if retry_times >= RETRY_TIMES
+          exception = ::EsClient::Client::Error.new(e, self)
+          EsClient.logger.exception(exception, http, options) if EsClient.logger
+          raise exception
+        end
+        retry_times += 1
+        reconnect!
+        retry
+      end
+    end
+
+    def http
+      @http ||= Excon.new(@host, @options)
+    end
+
+    def reconnect!
+      @http = nil
+    end
+
+    def log(message, level=:info)
+      EsClient.logger.try!(level, message)
+    end
+
+    class Error < StandardError
+      attr_reader :transport
+
+      def initialize(excon_error, transport)
+        @transport = transport
+        super("#{excon_error.message} (#{excon_error.class})")
+        set_backtrace(excon_error.backtrace)
+      end
+    end
+  end
+end

data/lib/es_client/index.rb

@@ -0,0 +1,93 @@
+module EsClient
+  class Index
+    attr_reader :name, :options
+
+    def initialize(name, options={})
+      @name = build_name(name)
+      @options = options
+    end
+
+    def build_name(name)
+      return name unless EsClient.index_prefix
+      "#{EsClient.index_prefix}_#{name}"
+    end
+
+    def exists?
+      EsClient.client.head("/#{name}").success?
+    end
+
+    def recreate
+      delete
+      create
+    end
+
+    def create
+      request_options = @options.present? ? {body: @options.to_json} : {}
+      EsClient.client.post("/#{name}", request_options)
+    end
+
+    def delete
+      EsClient.client.delete("/#{name}")
+    end
+
+    def refresh
+      EsClient.client.post("/#{name}/_refresh")
+    end
+
+    def search(query, options={})
+      http_options = options.slice(:query, :headers)
+      http_options[:body] = query.to_json
+      EsClient.client.get("/#{name}/#{options[:type]}/_search", http_options)
+    end
+
+    def get_settings
+      EsClient.client.get("/#{name}/_settings").decoded[name]['settings']
+    end
+
+    def put_settings(settings)
+      EsClient.client.put("/#{name}/_settings", body: settings.to_json)
+    end
+
+    def get_mapping
+      EsClient.client.get("/#{name}/_mapping").decoded[name]['mappings']
+    end
+
+    def put_mapping(type, mapping)
+      json = {type => mapping}.to_json
+      EsClient.client.put("/#{name}/_mapping/#{type}", body: json)
+    end
+
+    def save_document(type, id, document)
+      EsClient.client.post("/#{name}/#{type}/#{id}", body: document.to_json)
+    end
+
+    def update_document(type, id, document)
+      EsClient.client.post("/#{name}/#{type}/#{id}/_update", body: {doc: document}.to_json)
+    end
+
+    def destroy_document(type, id)
+      EsClient.client.delete("/#{name}/#{type}/#{id}")
+    end
+
+    def find(type, id)
+      EsClient.client.get("/#{name}/#{type}/#{id}").decoded['_source']
+    end
+
+    def bulk(action, type, documents)
+      payload = []
+      documents.each do |document|
+        payload << {action => {_index: name, _type: type, _id: document[:id]}}
+        case action
+          when :index
+            payload << document
+          when :update
+            document_for_update = {doc: document}
+            document_for_update.update(document[:bulk_options]) if document[:bulk_options]
+            payload << document_for_update
+        end
+      end
+      serialized_payload = "\n" + payload.map(&:to_json).join("\n") + "\n"
+      EsClient.client.post("/#{name}/#{type}/_bulk", body: serialized_payload)
+    end
+  end
+end

data/lib/es_client/logger.rb

@@ -0,0 +1,57 @@
+module EsClient
+  class Logger < ::Logger
+    def initialize(path, options)
+      super(path)
+      @options = options
+    end
+
+    def request(http, response, options)
+      return unless debug?
+      took = response.try!(:decoded).try!(:[], 'took') ? response.decoded['took'] : 'N/A'
+      message = "[#{response.code}](#{took} msec) #{to_curl(http, options)}"
+      message << "\n#{JSON.pretty_generate(response.decoded)}" if @options[:log_response] && response.try!(:decoded)
+      debug message
+    end
+
+    def exception(e, http=nil, options=nil)
+      backtrace = e.backtrace.map { |l| "#{' ' * 2}#{l}" }.join("\n")
+      curl = "\n  #{to_curl(http, options)}" if options && http
+      error "#{e.class} #{e.message} #{curl}\n#{backtrace}\n\n"
+    end
+
+    private
+
+    def to_curl(http, options)
+      res = 'curl -i -X '
+      res << options[:method].to_s.upcase
+
+      res << " '#{http.data[:scheme]}://#{http.data[:host]}"
+      res << ":#{http.data[:port]}" if http.data[:port]
+      res << options[:path]
+      if options[:query].present?
+        res << '?'
+        res << options[:query].is_a?(String) ? options[:query] : options[:query].to_query
+      elsif @options[:pretty]
+        res << '?'
+      end
+      res << '&pretty' if @options[:pretty]
+      res << "'"
+
+      if options[:body]
+        if options[:path].include?('/_bulk')
+          binary_data = @options[:log_binary] ? options[:body] : '... data omitted ...'
+          res << " --data-binary '#{binary_data}'"
+        else
+          res << " -d '#{pretty_json(options[:body])}'"
+        end
+      end
+      res
+    end
+
+    def pretty_json(string)
+      return if string.blank?
+      return string unless @options[:pretty]
+      JSON.pretty_generate(JSON.parse(string)).gsub("'", '\u0027')
+    end
+  end
+end

data/lib/es_client/response.rb

@@ -0,0 +1,24 @@
+module EsClient
+  class Response
+    attr_reader :body, :code, :headers
+
+    def initialize(body, code, headers={})
+      @body = body
+      @code = code.to_i
+      @headers = headers
+    end
+
+    def success?
+      code > 0 && code < 400
+    end
+
+    def failure?
+      !success?
+    end
+
+    def decoded
+      return if @body.blank?
+      @decoded ||= JSON.parse(@body)
+    end
+  end
+end

data/lib/es_client/version.rb

@@ -0,0 +1,3 @@
+module EsClient
+  VERSION = '0.1.0'
+end

data/spec/es_client/active_record/adapter_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe EsClient::ActiveRecord::Adapter do
+  describe 'index name' do
+    it 'determine index name from model' do
+      expect(RspecUser.es_client.index_name).to eq 'rspec_users'
+    end
+
+    it 'allow to define custom index name' do
+      RspecUser.es_client.index_name('custom_index_name')
+      expect(RspecUser.es_client.index_name).to eq 'custom_index_name'
+      RspecUser.es_client.instance_variable_set(:@index_name, nil)
+    end
+  end
+
+  describe 'document type' do
+    it 'determine document type from model' do
+      expect(RspecUser.es_client.document_type).to eq 'rspec_user'
+    end
+
+    it 'allow to define custom document type' do
+      RspecUser.es_client.document_type('custom_document_type')
+      expect(RspecUser.es_client.document_type).to eq 'custom_document_type'
+      RspecUser.es_client.instance_variable_set(:@document_type, nil)
+    end
+  end
+
+  it 'save document' do
+    expect(RspecUser.es_client.index).to receive(:save_document).with('rspec_user', 1, {id: 1, name: 'bob'})
+    RspecUser.es_client.save_document(RspecUser.new(id: 1, name: 'bob'))
+  end
+
+  describe 'update document' do
+    it 'update document' do
+      expect(RspecUser.es_client.index).to receive(:update_document).with('rspec_user', 1, {name: 'arnold'})
+      record = RspecUser.new(id: 1, name: 'bob')
+      allow(record).to receive(:changes).and_return({name: %w(bob arnold)})
+      RspecUser.es_client.update_document(record)
+    end
+  end
+
+  it 'destroy document' do
+    expect(RspecUser.es_client.index).to receive(:destroy_document).with('rspec_user', 1)
+    RspecUser.es_client.destroy_document(1)
+  end
+
+  describe 'find' do
+    it 'find document' do
+      expect(RspecUser.es_client.index).to receive(:find).with('rspec_user', 1)
+      RspecUser.es_client.find(1)
+    end
+
+    it 'find multiple documents' do
+      expect(RspecUser.es_client.index).to receive(:search).with({query: {ids: {values: [1], type: 'rspec_user'}}, size: 1}, type: 'rspec_user')
+      RspecUser.es_client.find([1])
+    end
+  end
+
+  describe 'import' do
+    it 'import batch of records' do
+      expect(RspecUser.es_client.index).to receive(:bulk).with(:index, 'rspec_user', [{id: 1}])
+      RspecUser.es_client.import([RspecUser.new(id: 1)])
+    end
+  end
+
+  describe 'mapping' do
+    it 'fetch mapping' do
+      expect(RspecUser.es_client.index).to receive(:get_mapping)
+      RspecUser.es_client.mapping
+    end
+
+    it 'set mapping' do
+      RspecUser.es_client.index.options[:mappings] = {}
+      RspecUser.es_client.mapping(test: {properties: {notes: {type: 'string'}}})
+      expect(RspecUser.es_client.index.options[:mappings]).to include(test: {properties: {notes: {type: 'string'}}})
+    end
+
+    it 'set append mapping' do
+      RspecUser.es_client.index.options[:mappings] = {}
+      RspecUser.es_client.mapping(test: {properties: {prop1: {type: 'string'}}})
+      RspecUser.es_client.mapping(test: {properties: {prop2: {type: 'string'}}})
+      expect(RspecUser.es_client.index.options[:mappings][:test][:properties]).to include(prop1: {type: 'string'})
+      expect(RspecUser.es_client.index.options[:mappings][:test][:properties]).to include(prop2: {type: 'string'})
+    end
+  end
+
+  describe 'settings' do
+    it 'fetch settings' do
+      expect(RspecUser.es_client.index).to receive(:get_settings)
+      RspecUser.es_client.settings
+    end
+
+    it 'set settings' do
+      RspecUser.es_client.index.options[:settings] = {}
+      RspecUser.es_client.settings(refresh_interval: '3s')
+      expect(RspecUser.es_client.index.options[:settings]).to include(refresh_interval: '3s')
+    end
+  end
+
+  describe 'search' do
+    it 'perform search query' do
+      expect(RspecUser.es_client.index).to receive(:search).with({query: {query_string: {query: 'test'}}}, type: 'rspec_user')
+      RspecUser.es_client.search(query: {query_string: {query: 'test'}})
+    end
+  end
+end

data/spec/es_client/active_record/glue_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe EsClient::ActiveRecord::Glue do
+  describe 'callbacks' do
+    it 'save document after save' do
+      expect(RspecUser.es_client).to receive(:save_document).with(instance_of(RspecUser))
+      RspecUser.new(id: 1, name: 'bob').save
+    end
+
+    it 'destroy document after destroy' do
+      expect(RspecUser.es_client).to receive(:destroy_document).with(1)
+      RspecUser.new(id: 1, name: 'bob').destroy
+    end
+
+    it 'allow to disable callbacks' do
+      allow(EsClient).to receive(:callbacks_enabled).and_return(false)
+      expect(RspecUser.es_client).not_to receive(:save_document)
+      RspecUser.new(id: 1, name: 'bob').save
+    end
+  end
+
+  describe 'update' do
+    it 'update es document' do
+      expect(RspecUser.es_client).to receive(:update_document)
+      RspecUser.new(id: 1, name: 'bob').es_client_update
+    end
+
+    it 'do not update new record document' do
+      expect(RspecUser.es_client).not_to receive(:update_document)
+      record = RspecUser.new(id: 1, name: 'bob')
+      allow(record).to receive(:new_record?).and_return(true)
+      record.es_client_update
+    end
+  end
+
+  describe 'record es document' do
+    it 'return es document' do
+      expect(RspecUser.es_client).to receive(:find).with(1)
+      RspecUser.new(id: 1, name: 'bob').es_client_document
+    end
+
+    it 'fetch es document once' do
+      expect(RspecUser.es_client).to receive(:find).with(1).once
+      record = RspecUser.new(id: 1, name: 'bob')
+      record.es_client_document
+      record.es_client_document
+    end
+
+    it 'force fetch es document' do
+      expect(RspecUser.es_client).to receive(:find).with(1).twice
+      record = RspecUser.new(id: 1, name: 'bob')
+      record.es_client_document
+      record.es_client_document(true)
+    end
+  end
+
+  describe 'reindex' do
+    it 'reindex current scope' do
+      expect(RspecUser.es_client).to receive(:import).twice.with(instance_of(Array))
+      RspecUser.es_client_reindex
+    end
+
+    it 'reindex current scope with progress' do
+      expect(RspecUser.es_client).to receive(:import).twice.with(instance_of(Array))
+      RspecUser.es_client_reindex_with_progress(batch_size: 1)
+    end
+  end
+end