waistband 0.7.4 → 0.8.0

data/.rspec

@@ -1 +1,2 @@
 --color
+--debugger

data/README.md

@@ -56,7 +56,6 @@ You'll need a separate config file for each index you use, containing the index
 ```yml
 # #{APP_DIR}/config/waistband/waistband_search.yml
 development:
-  name: search
   stringify: false
   settings:
     index:
@@ -69,10 +68,10 @@ development:
 
 ## List of config settings:
 
-* `name`: name of the index.  You can (and probably should) have a different name for the index for your test environment.
-* `stringify`: determines wether whatever is stored into the index is going to be converted to a string before storage.  Usually false unless you need it to be true for specific cases, like if for some `key => value` pairs the value is of different types some times.
 * `settings`: settings for the Elastic Search index.  Refer to the ["admin indices update settings"](http://www.elasticsearch.org/guide/reference/api/admin-indices-update-settings/) document for more info.
 * `mappings`: the index mappings.  More often than not you'll want to include all of the document attribute, so you'll do something like in the example above.  For more info, refer to the [mapping reference]("http://www.elasticsearch.org/guide/reference/mapping/").
+* `name`: optional - name of the index.  You can (and probably should) have a different name for the index for your test environment.  If not specified, it defaults to the name of the yml file minus the `waistband_` portion, so in the above example, the index name would become `search_#{env}`, where env is your environment variable as defined in `Waistband::Configuration#setup` (determined by `RAILS_ENV` or `RACK_ENV`).
+* `stringify`: optional - determines wether whatever is stored into the index is going to be converted to a string before storage.  Usually false unless you need it to be true for specific cases, like if for some `key => value` pairs the value is of different types some times.
 
 ## Initializer
 
@@ -114,6 +113,8 @@ When writing tests, it would generally be advisable to destroy and create the in
 Waistband::Index.new('search').refresh
 ```
 
+Note: most index methods such as `create`, `destroy`, `read`, etc, have an equivalent bang method (`destroy!`) that will actually throw an exception if something goes wrong.  For example, `destroy` will return nil if the index doesn't exist, but will raise any other unrelated exceptions, whereas `destroy!` will raise even the Index Not Found exception.
+
 #### Writing, reading and deleting from an index
 
 ```ruby
@@ -168,6 +169,32 @@ For paginating the results, you can use the `#paginated_results` method, which r
 
 For more information and extra methods, take a peek into the class docs.
 
+### Sub-Indexes
+
+Sometimes it can be useful to sub-divide your index into smaller indexes based on dates or other partitioning schemes.  To do this, the `Index` class exposes the `subs` option on instantiation:
+
+```ruby
+index = Waistband::Index.new('events', subs: %w(2013 01))
+index.create!
+```
+
+This creates the index `events__2013_01`, which in your application logic you could design to store all event data for Jan 2013.  You'd do the same for Feb, etc., and when you no longer need one of the older ones, you could delete just that sub-index, instead of things getting more complicated.
+
+### Aliasing
+
+Part of subbing is gonna be creating the correct aliases that group up your sub-indexes.
+
+```ruby
+index = Waistband::Index.new('events', subs: %w(2013 01))
+index.create!
+index.alias!('my_super_events_alias')
+=> true
+index.fetch_alias('my_super_events_alias')
+=> {"events__2013_01"=>{"aliases"=>{"my_super_events_alias"=>{}}}}
+```
+
+The `alias!` methods receives a param to define the alias name.
+
 ## Contributing
 
 1. Fork it

data/lib/waistband/configuration.rb

@@ -9,6 +9,7 @@ module Waistband
     include Singleton
 
     attr_accessor :config_dir
+    attr_reader   :env
 
     def initialize
       @yml_config = {}

data/lib/waistband/connection.rb

@@ -6,52 +6,170 @@ require 'active_support/core_ext/hash/indifferent_access'
 module Waistband
   class Connection
 
-    class NoMoreServers < Exception; end
+    ##########
+    # Errors #
+    ##########
 
-    def initialize(options = {})
+    module Error
+
+      class Resquest < Exception
+        attr_accessor :result, :kind
+
+        def index_already_exists?
+          kind == "IndexAlreadyExistsException"
+        end
+
+        def alias_with_name_exists?
+          kind == "InvalidIndexNameException" && !!message.match("an alias with the same name already exists")
+        end
+
+        def index_missing?
+          kind == "IndexMissingException"
+        end
+
+        def key_missing?
+          kind == "KeyMissing"
+        end
+
+        def alias_not_ok?
+          kind == "AliasNotOk"
+        end
+      end
+
+      class NoMoreServers < Exception; end
+
+    end
+
+    ####################
+    # Instance methods #
+    ####################
+
+    def initialize(index, options = {})
+      @index          = index
       @blacklist      = []
       @retry_on_fail  = options.fetch :retry_on_fail, true
       @orderly        = options.fetch :orderly, false
       pick_server
     end
 
-    def create!(index)
-      execute! 'post', relative_url_for_index(index), index_json(index)
-    rescue RestClient::BadRequest => ex
-      nil
+    def mapping!
+      execute! 'get', "#{@index.config_name}/_mapping"
+    end
+
+    def mapping
+      mapping!
+    rescue Waistband::Connection::Error::Resquest => ex
+      raise ex unless ex.index_missing?
+    end
+
+    def exists?
+      !!mapping.present?
+    end
+
+    def create!
+      execute! 'post', @index.config_name, @index.config_json
     end
 
-    def destroy!(index)
-      execute! 'delete', relative_url_for_index(index)
-    rescue RestClient::ResourceNotFound => ex
-      nil
+    def create
+      create!
+    rescue Waistband::Connection::Error::Resquest => ex
+      raise ex if !ex.index_already_exists? && ! ex.alias_with_name_exists?
     end
 
-    def update_settings!(index)
-      execute! 'put', "#{relative_url_for_index(index)}/_settings", settings_json(index)
+    def destroy
+      destroy!
+    rescue ::Waistband::Connection::Error::Resquest => ex
+      raise ex unless ex.index_missing?
     end
 
-    def refresh(index)
-      execute! 'post', "#{relative_url_for_index(index)}/_refresh", {}
+    def destroy!
+      execute! 'delete', @index.config_name
     end
 
-    def read(index, key)
-      fetched = execute! 'get', relative_url_for_key(index, key)
-      JSON.parse(fetched)['_source'].with_indifferent_access
-    rescue RestClient::ResourceNotFound => ex
-      nil
+    def update_settings!
+      execute! 'put', "#{@index.config_name}/_settings", settings_json
     end
 
-    def put(index, key, data)
-      execute! 'put', relative_url_for_key(index, key), data.to_json
+    def update_settings
+      update_settings!
+    rescue ::Waistband::Connection::Error::Resquest => ex
+      raise ex unless ex.index_missing?
     end
 
-    def delete!(index, key)
-      execute! 'delete', relative_url_for_key(index, key)
+    def refresh!
+      execute! 'post', "#{@index.config_name}/_refresh", {}
     end
 
-    def search_url_for_index(index)
-      "#{url}/#{relative_url_for_index(index)}/_search"
+    def refresh
+      refresh!
+    rescue ::Waistband::Connection::Error::Resquest => ex
+      raise ex unless ex.index_missing?
+    end
+
+    def alias!(alias_name)
+      alias_name = full_alias_name alias_name
+      fetched = execute! 'put', "#{@index.config_name}/_alias/#{alias_name}"
+      parsed = JSON.parse(fetched)
+
+      error_with('Alias not OK', result: parsed, kind: 'AliasNotOk') unless parsed['ok'] == true
+
+      true
+    end
+
+    def alias(alias_name)
+      alias! alias_name
+    rescue ::Waistband::Connection::Error::Resquest => ex
+      raise ex unless ex.alias_not_ok?
+    end
+
+    def fetch_alias(alias_name)
+      alias_name = full_alias_name alias_name
+      fetched = execute! 'get', "#{@index.config_name}/_alias/#{alias_name}"
+      JSON.parse(fetched)
+    end
+
+    def full_alias_name(alias_name)
+      name = alias_name
+      name << "_#{@index.env}" unless @index.custom_name?
+      name
+    end
+
+    def read!(key)
+      fetched = execute! 'get', relative_url_for_key(key)
+      parsed = JSON.parse(fetched)
+
+      error_with('Key not found', result: parsed, kind: 'KeyMissing') if parsed['exists'] == false
+
+      parsed['_source'].with_indifferent_access
+    end
+
+    def read(key)
+      read! key
+    rescue ::Waistband::Connection::Error::Resquest => ex
+      raise ex unless ex.key_missing?
+    end
+
+    def put(key, data)
+      execute! 'put', relative_url_for_key(key), data.to_json
+    end
+
+    def delete!(key)
+      fetched = execute! 'delete', relative_url_for_key(key)
+      parsed = JSON.parse(fetched)
+
+      error_with('Key not found', result: parsed, kind: 'KeyMissing') if parsed['found'] == false
+
+      true
+    end
+
+    def delete(key)
+      delete! key
+    rescue ::Waistband::Connection::Error::Resquest => ex
+      raise ex unless ex.key_missing?
+    end
+
+    def search_url
+      "#{url}/#{@index.config_name}/_search"
     end
 
     private
@@ -60,7 +178,15 @@ module Waistband
         full_url = "#{url}/#{relative_url}"
 
         Timeout::timeout ::Waistband.config.timeout do
-          RestClient.send method_name, full_url, data
+          RestClient.send method_name, full_url, data do |response, request, result|
+            response_hash = JSON.parse(response)
+
+            if msg = response_hash['error']
+              error_with(msg, result: result, kind: msg.split('[').first)
+            end
+
+            response
+          end
         end
       rescue Timeout::Error, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ECONNRESET
         # something's wrong, lets blacklist this sucker
@@ -68,35 +194,23 @@ module Waistband
         retry if @retry_on_fail
       end
 
-      def relative_url_for_key(index, key)
-        "#{relative_url_for_index(index)}/#{index.singularize}/#{key}"
-      end
-
-      def relative_url_for_index(index)
-        "#{index_name(index)}"
+      def relative_url_for_key(key)
+        "#{@index.config_name}/#{@index.base_name.singularize}/#{key}"
       end
 
       def url
         "#{@server['host']}:#{@server['port']}"
       end
 
-      def index_name(index)
-        config(index)['name']
-      end
-
-      def index_json(index)
-        config(index).except('name', 'stringify').to_json
+      def index_json
+        @index.config.except('name', 'stringify').to_json
       end
 
-      def settings_json(index)
-        settings = config(index)['settings']['index'].except('number_of_shards')
+      def settings_json
+        settings = @index.config['settings']['index'].except('number_of_shards')
         {index: settings}.to_json
       end
 
-      def config(index)
-        Waistband.config.index(index)
-      end
-
       def blacklist!(server)
         @blacklist << server['_id'] unless @blacklist.include? server['_id']
         @blacklist
@@ -108,7 +222,7 @@ module Waistband
         @server = next_server
 
         unless @server
-          raise ::Waistband::Connection::NoMoreServers.new "No available servers remain"
+          raise ::Waistband::Connection::Error::NoMoreServers.new "No available servers remain"
         end
 
         @server
@@ -119,6 +233,13 @@ module Waistband
         available_servers.sample
       end
 
+      def error_with(msg, options = {})
+        exception = ::Waistband::Connection::Error::Resquest.new(msg)
+        exception.result = options[:result]
+        exception.kind = options[:kind]
+        raise exception
+      end
+
       def available_servers
         ::Waistband.config.servers.reject {|server| @blacklist.include? server['_id']}
       end

data/lib/waistband/index.rb

@@ -1,75 +1,92 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/keys'
+
 module Waistband
   class Index
 
-    def initialize(index)
-      @index        = index
-      @index_name   = config['name']
-      @stringify    = config['stringify']
-    end
+    delegate  :create!, :create, :destroy!, :destroy,
+              :update_settings!, :update_settings,
+              :delete!, :delete, :read!, :read,
+              :alias, :alias!,
+              :fetch_alias, :mapping, :exists?,
+              :refresh!, :refresh,
+              :search_url,
+              to: :connection
 
-    # create the index
-    def create!
-      connection.create! @index
-    end
+    attr_reader :base_name
 
-    # destroy the index
-    def destroy!
-      connection.destroy! @index
-    end
+    def initialize(index, options = {})
+      options = options.stringify_keys
 
-    def update_settings!
-      connection.update_settings! @index
-    end
+      @index          = index
+      @base_name      = index
+      @stringify      = config['stringify']
 
-    # refresh the index
-    def refresh
-      connection.refresh @index
+      @subs = [options['subs']] if options['subs'].present?
+      @subs = @subs.flatten     if @subs.is_a?(Array)
     end
 
     def store!(key, data)
       # map everything to strings
       if @stringify
         original_data = data
-
-        if data.is_a? Array
-          data = ::Waistband::StringifiedArray.new data
-        elsif data.is_a? Hash
-          data = ::Waistband::StringifiedHash.new_from data
-        end
-
-        data = data.stringify_all if data.respond_to? :stringify_all
+        data = stringify_all data
       end
 
-      result  = connection.put @index, key, data
-      data    = original_data if @stringify
+      result = connection.put key, data
+      data = original_data if @stringify
 
       result
     end
 
-    def delete!(key)
-      connection.delete! @index, key
+    def query(options = {})
+      ::Waistband::Query.new self, options
     end
 
-    def read(key)
-      connection.read @index, key
+    def name
+      @subs ? "#{@index}__#{@subs.join('_')}" : @index
     end
 
-    def query(options = {})
-      ::Waistband::Query.new @index, options
+    def config_name
+      @subs ? "#{base_config_name}__#{@subs.join('_')}" : base_config_name
+    end
+
+    def config_json
+      config.except('name', 'stringify').to_json
+    end
+
+    def base_config_name
+      return config['name'] if config['name']
+      "#{@base_name}_#{env}"
+    end
+
+    def custom_name?
+      !!config['name']
+    end
+
+    def config
+      Waistband.config.index @index
     end
 
-    def search_url
-      connection.search_url_for_index @index
+    def env
+      Waistband.config.env
     end
 
     private
 
-      def connection
-        ::Waistband::Connection.new
+      def stringify_all(data)
+        data = if data.is_a? Array
+          ::Waistband::StringifiedArray.new data
+        elsif data.is_a? Hash
+          ::Waistband::StringifiedHash.new_from data
+        end
+
+        data = data.stringify_all if data.respond_to? :stringify_all
+        data
       end
 
-      def config
-        Waistband.config.index @index
+      def connection
+        ::Waistband::Connection.new self
       end
 
     # /private

data/lib/waistband/query.rb

@@ -46,11 +46,7 @@ module Waistband
       end
 
       def url
-        index.search_url
-      end
-
-      def index
-        Waistband::Index.new(@index)
+        @index.search_url
       end
 
       def execute!

data/lib/waistband/version.rb

@@ -1,3 +1,3 @@
 module Waistband
-  VERSION = "0.7.4"
+  VERSION = "0.8.0"
 end

data/spec/config/waistband/waistband_events.yml

@@ -1,9 +1,8 @@
 development: &DEV
-  name: events
   stringify: true
   settings:
     index:
-      number_of_shards: 4
+      number_of_shards: 1
       number_of_replicas: 1
   mappings:
     event:
@@ -12,4 +11,3 @@ development: &DEV
 
 test:
   <<: *DEV
-  name: events_test

data/spec/config/waistband/waistband_events_no_name.yml

@@ -0,0 +1,13 @@
+development: &DEV
+  stringify: true
+  settings:
+    index:
+      number_of_shards: 1
+      number_of_replicas: 1
+  mappings:
+    event:
+      _source:
+        includes: ["*"]
+
+test:
+  <<: *DEV

data/spec/config/waistband/waistband_geo.yml

@@ -1,9 +1,9 @@
 development: &DEV
-  name: waistband_geo
   stringify: false
   settings:
     index:
-      number_of_shards: 4
+      number_of_shards: 1
+      number_of_replicas: 1
   mappings:
     geo:
       _source:
@@ -16,4 +16,3 @@ development: &DEV
 
 test:
   <<: *DEV
-  name: waistband_geo_test

data/spec/config/waistband/waistband_search.yml

@@ -1,9 +1,9 @@
 development: &DEV
-  name: search
   stringify: false
   settings:
     index:
-      number_of_shards: 4
+      number_of_shards: 1
+      number_of_replicas: 1
   mappings:
     event:
       _source:
@@ -11,4 +11,3 @@ development: &DEV
 
 test:
   <<: *DEV
-  name: search_test

data/spec/lib/configuration_spec.rb

@@ -12,14 +12,12 @@ describe Waistband::Configuration do
 
   it "loads indexes config" do
     config.index('search').should be_a Hash
-    config.index('search')['name'].should eql 'search_test'
-    config.index('search')['settings']['index']['number_of_shards'].should eql 4
+    config.index('search')['settings']['index']['number_of_shards'].should eql 1
   end
 
   it "loads multiple indexes config" do
     config.index('events').should be_a Hash
-    config.index('events')['name'].should eql 'events_test'
-    config.index('events')['settings']['index']['number_of_shards'].should eql 4
+    config.index('events')['settings']['index']['number_of_shards'].should eql 1
   end
 
   describe '#servers' do

data/spec/lib/connection_spec.rb

@@ -2,24 +2,227 @@ require 'spec_helper'
 
 describe Waistband::Connection do
 
-  let(:connection) { Waistband::Connection.new }
+  let(:connection) { Waistband::Connection.new(index) }
+  let(:search_connection) { Waistband::Connection.new(index_search) }
+  let(:index) { ::Waistband::Index.new('events') }
+  let(:index_search) { ::Waistband::Index.new('search') }
 
   def blacklist_server!
     connection.send(:blacklist!, Waistband.config.servers.first)
   end
 
   it "constructs the settings json" do
-    connection.send(:settings_json, 'events').should eql '{"index":{"number_of_replicas":1}}'
+    connection.send(:settings_json).should eql '{"index":{"number_of_replicas":1}}'
   end
 
   it "constructs the index json" do
-    connection.send(:index_json, 'events').should eql '{"settings":{"index":{"number_of_shards":4,"number_of_replicas":1}},"mappings":{"event":{"_source":{"includes":["*"]}}}}'
+    connection.send(:index_json).should eql '{"settings":{"index":{"number_of_shards":1,"number_of_replicas":1}},"mappings":{"event":{"_source":{"includes":["*"]}}}}'
+  end
+
+  describe 'urls for subindexes' do
+
+    let(:index) { ::Waistband::Index.new('events', subs: %w(2013 01)) }
+    let(:connection) { Waistband::Connection.new(index, orderly: true) }
+
+    describe '#destroy!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('delete', "http://localhost:9200/events_test__2013_01", nil).once
+        connection.destroy!
+      end
+
+    end
+
+    describe '#create!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('post', "http://localhost:9200/events_test__2013_01", index.config_json).once
+        connection.create!
+      end
+
+    end
+
+    describe '#update_settings!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('put', "http://localhost:9200/events_test__2013_01/_settings", connection.send(:settings_json)).once
+        connection.update_settings!
+      end
+
+    end
+
+    describe '#refresh!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('post', "http://localhost:9200/events_test__2013_01/_refresh", {}).once
+        connection.refresh!
+      end
+
+    end
+
+    describe '#read' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('get', "http://localhost:9200/events_test__2013_01/event/my_key", nil).once.and_call_original
+        connection.read 'my_key'
+      end
+
+    end
+
+    describe '#put' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('put', "http://localhost:9200/events_test__2013_01/event/my_key", {oh_yeah: true}.to_json).once.and_call_original
+        connection.put 'my_key', {oh_yeah: true}
+      end
+
+    end
+
+    describe '#delete!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('delete', "http://localhost:9200/events_test__2013_01/event/my_key", nil).once.and_call_original
+        connection.delete 'my_key'
+      end
+
+    end
+
+    describe '#search_url' do
+
+      it "targets the correct url" do
+        connection.search_url.should eql "http://localhost:9200/events_test__2013_01/_search"
+      end
+
+    end
+
+    describe '#alias!' do
+
+      it "targets the correct url with a specific alias_name" do
+        RestClient.should_receive(:send).with('put', "http://localhost:9200/events_test__2013_01/_alias/all_events_test", nil).once.and_call_original
+        connection.alias! 'all_events'
+      end
+
+    end
+
+  end
+
+  describe '#full_alias_name' do
+
+    it "returns the alias name with the env" do
+      connection.full_alias_name('all_events').should eql 'all_events_test'
+    end
+
+    it "if the index has a custom name, the alias name doesn't automatically append the env" do
+      connection.instance_variable_get('@index').stub(:config).and_return({
+        'name' => 'super_custom'
+      })
+      connection.full_alias_name('all_events').should eql 'all_events'
+    end
+
+  end
+
+  describe 'urls' do
+
+    let(:connection) { Waistband::Connection.new(index, orderly: true) }
+
+    describe '#destroy!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('delete', "http://localhost:9200/events_test", nil).once
+        connection.destroy!
+      end
+
+    end
+
+    describe '#create!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('post', "http://localhost:9200/events_test", index.config_json).once
+        connection.create!
+      end
+
+    end
+
+    describe '#update_settings!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('put', "http://localhost:9200/events_test/_settings", connection.send(:settings_json)).once
+        connection.update_settings!
+      end
+
+    end
+
+    describe '#refresh!' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('post', "http://localhost:9200/events_test/_refresh", {}).once
+        connection.refresh!
+      end
+
+    end
+
+    describe '#read' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('get', "http://localhost:9200/events_test/event/my_key", nil).once.and_call_original
+        connection.read 'my_key'
+      end
+
+    end
+
+    describe '#put' do
+
+      it "targets the correct url" do
+        RestClient.should_receive(:send).with('put', "http://localhost:9200/events_test/event/my_key", {oh_yeah: true}.to_json).once.and_call_original
+        connection.put 'my_key', {oh_yeah: true}
+      end
+
+    end
+
+    describe '#delete!' do
+
+      it "targets the correct url" do
+        connection.put 'my_key', {oh_yeah: true}
+
+        RestClient.should_receive(:send).with('delete', "http://localhost:9200/events_test/event/my_key", nil).once.and_call_original
+        connection.delete! 'my_key'
+      end
+
+    end
+
+    describe '#search_url' do
+
+      it "targets the correct url" do
+        connection.search_url.should eql "http://localhost:9200/events_test/_search"
+      end
+
+    end
+
+    describe '#alias!' do
+
+      it "targets the correct url with a specific alias_name" do
+        RestClient.should_receive(:send).with('put', "http://localhost:9200/events_test/_alias/all_events_test", nil).once.and_call_original
+        connection.alias! 'all_events'
+      end
+
+    end
+
+  end
+
+  describe '#alias!' do
+
+    it "creates an alias for the index" do
+      connection.alias! 'all_events'
+      aliases = connection.fetch_alias 'all_events'
+      aliases.should eql({"events_test"=>{"aliases"=>{"all_events_test"=>{}}}})
+    end
+
   end
 
   describe '#execute!' do
 
     it "wraps directly to rest client" do
-      connection = Waistband::Connection.new(orderly: true)
+      connection = Waistband::Connection.new(index, orderly: true)
 
       RestClient.should_receive(:get).with('http://localhost:9200/somekey', nil).once
       connection.send(:execute!, 'get', 'somekey')
@@ -29,7 +232,7 @@ describe Waistband::Connection do
 
       [Timeout::Error, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ECONNRESET].each do |exception|
         it "blacklists the server when #{exception}" do
-          connection = Waistband::Connection.new(retry_on_fail: false)
+          connection = Waistband::Connection.new(index, retry_on_fail: false)
 
           RestClient.should_receive(:get).with(kind_of(String), nil).and_raise exception
           connection.send(:execute!, 'get', 'somekey')
@@ -54,8 +257,8 @@ describe Waistband::Connection do
           ]
         )
 
-        connection = Waistband::Connection.new(orderly: true)
-        expect { connection.refresh('events') }.to_not raise_error
+        connection = Waistband::Connection.new(index, orderly: true)
+        expect { connection.refresh }.to_not raise_error
 
         connection.instance_variable_get('@blacklist').should eql ['567890a5ce74182e5cd123e299993ab510c56123']
       end
@@ -67,7 +270,7 @@ describe Waistband::Connection do
         expect {
           connection.send(:execute!, 'get', 'somekey')
         }.to raise_error(
-          Waistband::Connection::NoMoreServers,
+          Waistband::Connection::Error::NoMoreServers,
           "No available servers remain"
         )
       end
@@ -79,27 +282,15 @@ describe Waistband::Connection do
   describe '#relative_url_for_key' do
 
     it "returns the relative url for a key" do
-      url = connection.send(:relative_url_for_key, 'search', 'key123')
+      url = search_connection.send(:relative_url_for_key, 'key123')
       url.should match /^search_test\/search\/key123$/
 
-      url = connection.send(:relative_url_for_key, 'events', '9986')
+      url = connection.send(:relative_url_for_key, '9986')
       url.should match /^events_test\/event\/9986$/
     end
 
   end
 
-  describe '#relative_url_for_index' do
-
-    it "returns the url for an index" do
-      url = connection.send(:relative_url_for_index, 'search')
-      url.should match /^search_test$/
-
-      url = connection.send(:relative_url_for_index, 'events')
-      url.should match /^events_test$/
-    end
-
-  end
-
   describe '#url' do
 
     it "returns url string for the selected server" do
@@ -134,7 +325,7 @@ describe Waistband::Connection do
       expect {
         connection.send(:blacklist!, Waistband.config.servers.last)
       }.to raise_error(
-        Waistband::Connection::NoMoreServers,
+        Waistband::Connection::Error::NoMoreServers,
         "No available servers remain"
       )
     end
@@ -188,38 +379,38 @@ describe Waistband::Connection do
 
   describe "storing" do
 
-    let(:index)   { ::Waistband::Index.new('events') }
-    let(:index2)  { ::Waistband::Index.new('search') }
-    let(:attrs)   { {'ok' => {'yeah' => true}} }
-
-    before { IndexHelper.prepare! }
+    let(:attrs)   { {'other_ok' => {'yeah' => true}} }
 
     it "stores data" do
-      connection.put('events', '__test_write', {'ok' => 'yeah'})
+      connection.put('__test_write', {'ok' => 'yeah'})
       index.read('__test_write').should eql({'ok' => 'yeah'})
     end
 
     it "data is indirectly accessible" do
-      connection.put('events', '__test_not_string', attrs)
-      index.read('__test_not_string')[:ok][:yeah].should eql true
+      connection.put('__test_not_string', attrs)
+      index.read('__test_not_string')[:other_ok][:yeah].should eql true
     end
 
     it "deletes data" do
-      connection.put('events', '__test_write', attrs)
-      connection.delete!('events', '__test_write')
+      connection.put('__test_write', attrs)
+      connection.delete!('__test_write')
       index.read('__test_write').should be_nil
     end
 
+    it "blows up when trying to delete non-existent data" do
+      expect { connection.delete!('__test_write') }.to raise_error
+    end
+
     it "returns nil on 404" do
       index.read('__not_here').should be_nil
     end
 
     it "doesn't mix data between two indexes" do
-      connection.put('events', '__test_write',  {'data' => 'index_1'})
-      connection.put('search', '__test_write', {'data' => 'index_2'})
+      connection.put('__test_write',  {'data' => 'index_1'})
+      search_connection.put('__test_write', {'data' => 'index_2'})
 
       index.read('__test_write').should   eql({'data' => 'index_1'})
-      index2.read('__test_write').should  eql({'data' => 'index_2'})
+      index_search.read('__test_write').should  eql({'data' => 'index_2'})
     end
 
   end

data/spec/lib/index_spec.rb

@@ -7,21 +7,20 @@ describe Waistband::Index do
   let(:attrs)   { {'ok' => {'yeah' => true}} }
 
   it "initializes values" do
-    index.instance_variable_get('@index_name').should eql 'events_test'
     index.instance_variable_get('@stringify').should  eql true
   end
 
   it "creates the index" do
     index.destroy!
-    expect{ index.refresh }.to raise_error(RestClient::ResourceNotFound)
+    expect{ index.refresh! }.to raise_error(Waistband::Connection::Error::Resquest)
 
     index.create!
-    expect{ index.refresh }.to_not raise_error
+    expect{ index.refresh! }.to_not raise_error
   end
 
   it "destroys the index" do
     index.destroy!
-    expect{ index.refresh }.to raise_error(RestClient::ResourceNotFound)
+    expect{ index.refresh! }.to raise_error(Waistband::Connection::Error::Resquest)
     index.create!
   end
 
@@ -72,4 +71,55 @@ describe Waistband::Index do
 
   end
 
+  describe 'subindexes' do
+
+    let(:sharded_index) { Waistband::Index.new('events', subs: %w(2013 01)) }
+
+    it "permits subbing the index" do
+      sharded_index.name.should eql 'events__2013_01'
+      sharded_index.config_name.should eql 'events_test__2013_01'
+    end
+
+    it "permits sharding into singles" do
+      index = Waistband::Index.new 'events', subs: '2013'
+      index.name.should eql 'events__2013'
+      index.config_name.should eql 'events_test__2013'
+    end
+
+    it "retains the same options from the parent index config" do
+      config = sharded_index.send(:config)
+
+      sharded_index.base_config_name.should eql 'events_test'
+      config['stringify'].should be_true
+      config['settings'].should be_present
+    end
+
+    it "creates the sharded index with the same mappings as the parent" do
+      sharded_index.destroy
+
+      expect {
+        sharded_index.create!
+      }.to_not raise_error
+    end
+
+    describe 'no configged index name' do
+
+      it "gets a default name that makes sense for the index when not defined" do
+        index = Waistband::Index.new 'events_no_name', subs: %w(2013 01)
+        index.config_name.should eql 'events_no_name_test__2013_01'
+      end
+
+    end
+
+  end
+
+  describe '#base_config_name' do
+
+    it "gets a default name that makes sense for the index when not defined" do
+      index = Waistband::Index.new 'events_no_name'
+      index.base_config_name.should eql 'events_no_name_test'
+    end
+
+  end
+
 end

data/spec/lib/query_spec.rb

@@ -5,8 +5,8 @@ describe Waistband::Query do
   let(:index)     { Waistband::Index.new('search') }
   let(:geo_index) { Waistband::Index.new('geo') }
 
-  let(:query)     { Waistband::Query.new('search') }
-  let(:geo_query) { Waistband::Query.new('geo') }
+  let(:query)     { Waistband::Query.new(index) }
+  let(:geo_query) { Waistband::Query.new(geo_index) }
 
   let(:attrs) do
     {

data/spec/spec_helper.rb

@@ -19,8 +19,10 @@ RSpec.configure do |config|
     end
   end
 
-  config.before(:all) do |c|
-    IndexHelper.prepare!
+  config.around(:each) do |example|
+    IndexHelper.create_all
+    example.run
+    IndexHelper.destroy_all
   end
 
   config.after(:each) do

data/spec/support/index_helper.rb

@@ -4,21 +4,20 @@ class IndexHelper
 
   class << self
 
-    def destroy_all!
+    def destroy_all
       IndexHelper::INDEXES.each do |index|
-        Waistband::Index.new(index).destroy!
+        Waistband::Index.new(index).destroy
       end
+
+      Waistband::Index.new('events', subs: %w(2013 01)).destroy
     end
 
-    def create_all!
+    def create_all
       IndexHelper::INDEXES.each do |index|
-        Waistband::Index.new(index).create!
+        Waistband::Index.new(index).create
       end
-    end
 
-    def prepare!
-      destroy_all!
-      create_all!
+      Waistband::Index.new('events', subs: %w(2013 01)).create
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: waistband
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-29 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -118,6 +118,7 @@ files:
 - lib/waistband/version.rb
 - spec/config/waistband/waistband.yml
 - spec/config/waistband/waistband_events.yml
+- spec/config/waistband/waistband_events_no_name.yml
 - spec/config/waistband/waistband_geo.yml
 - spec/config/waistband/waistband_search.yml
 - spec/lib/configuration_spec.rb
@@ -158,6 +159,7 @@ summary: Elastic Search all the things!
 test_files:
 - spec/config/waistband/waistband.yml
 - spec/config/waistband/waistband_events.yml
+- spec/config/waistband/waistband_events_no_name.yml
 - spec/config/waistband/waistband_geo.yml
 - spec/config/waistband/waistband_search.yml
 - spec/lib/configuration_spec.rb