cauchy 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: acfe1f9c387508642988f41f47e65b0ea809b6c5
+  data.tar.gz: 4b3868c009a60a3217ea04589876537ee73dfee2
+SHA512:
+  metadata.gz: dada688d444f5079b1a7a273f9d2a732d99cc5d61f1c2359edd3864fa3139c7f2a80cafb3091e9f6b0056d9cb5f4381e1d7973cd054aa3627ef6f4599903f744
+  data.tar.gz: 1def7a74c1ccc400dcbeedbda077538a88b75f8de90983718390e27d93a565e0e00fc27e84f4b86c58cdfed76682d4af8f38f3b788e46a3eb5b8fc5629302920

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.bundle
+vendor/

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.2.5
+services:
+  - elasticsearch
+env:
+  global:
+    - "ELASTICSEARCH_HOSTS=http://localhost:9200,http://127.0.0.1:9200"
+script: bundle exec rake spec

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Zinc Inc.
+
+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,63 @@
+# Cauchy
+
+[![Build Status](https://api.travis-ci.com/cotap/cauchy.svg?token=PQCDXv39wYQSK1Gnq72A&branch=master)](https://magnum.travis-ci.com/cotap/cauchy)
+
+Cauchy manages your ES Index Schemas.
+
+## Installation
+
+Install the Cauchy gem globally with
+
+    $ gem install cauchy
+
+And verify your install with
+
+    $ cauchy version
+
+## Usage
+
+### Setup
+
+To get started, create a new Cauchy project structure
+
+    $ cauchy init --path=/some/place/special
+
+This will create the following structure
+
+```
+├── config.yml
+└── schema
+```
+
+Configure Cauchy's `config.yml` with your elasticsearch settings. You can find more information about the available options at the [ElasticSearch Transport docs](http://www.rubydoc.info/gems/elasticsearch-transport).
+
+### Creating an Index Schema
+
+To create a new index schema, simply
+
+    $ cauchy new [index_schema_name]
+
+This will generate a new template schema file located in your `schemas/` directory.
+
+### Applying your schema
+
+Once you've configuring your schema, you're ready to apply it to ES with
+
+    $ cauchy apply [index_schema_name]
+
+__Note:__ the schema name is optional here, and if left blank, Cauchy will run against all your defined schemas
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cotap/cauchy.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/cauchy

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'cauchy/cli'
+
+trap('INT') { puts ''; exit }
+
+Cauchy::Cli.start ARGV

data/cauchy.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cauchy/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'cauchy'
+  s.version       = Cauchy::VERSION
+  s.authors       = ['Paul Hamera', 'Evan Owen']
+  s.email         = ['paul@zinc.it', 'evan@zinc.it']
+
+  s.summary       = 'An elasticsearch schema management tool'
+  s.description   = 'An elasticsearch schema management tool'
+  s.homepage      = 'https://github.com/cotap'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.executables = Dir['bin/*'].map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_dependency 'activesupport', '>= 4.2'
+  s.add_dependency 'diffy', '~> 3.1'
+  s.add_dependency 'elasticsearch', '~> 1.0'
+  s.add_dependency 'indentation', '~> 0.0'
+  s.add_dependency 'json', '>= 1.8'
+  s.add_dependency 'rainbow', '~> 2.1'
+  s.add_dependency 'ruby-progressbar', '~> 1.8'
+  s.add_dependency 'thor', '~> 0.18'
+
+  s.add_development_dependency 'bundler', '~> 1.11'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'rspec-its', '~> 1.2'
+  s.add_development_dependency 'pry'
+end

data/lib/cauchy/cli.rb

@@ -0,0 +1,158 @@
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/hash_with_indifferent_access'
+require 'thor'
+require 'yaml'
+
+require 'cauchy'
+
+module Cauchy
+
+  class Cli < Thor
+    include Thor::Actions
+
+    default_path = ENV.fetch('CAUCHY_PATH', '.')
+
+    class_option :path, default: default_path,
+      banner: 'project path', desc: 'CAUCHY_PATH env var will be recognized'
+
+    desc 'init', 'Create cauchy project directories'
+    def init
+      init_project
+    end
+
+    desc 'new [SCHEMA_NAME]', 'Create an empty index schema file'
+    def new(name)
+      verify_project!
+      generate_schema name
+    end
+
+    desc 'apply [SCHEMA_NAME]', 'Applys a schema'
+    method_option :reindex, default: false, type: :boolean, desc: 'Reindex data, if required'
+    method_option :close_index, default: false, type: :boolean, desc: 'Close index to update non-dynamic settings'
+    def apply(schema_name = nil)
+      verify_project!
+      Migrator.migrate(
+        client, schema_path, schema_name,
+        options.slice('reindex', 'close_index').symbolize_keys
+      )
+    rescue Elastic::CannotUpdateNonDynamicSettingsError => e
+      Cauchy.logger.warn e.to_s
+      Cauchy.logger.warn 'Provide --close-index in order to perform this update'
+    rescue MigrationError => e
+      Cauchy.logger.warn e.to_s
+    end
+
+    desc 'status [SCHEMA_NAME]', 'Displays index status'
+    def status(schema_name = nil)
+      verify_project!
+      Migrator.status(client, schema_path, schema_name)
+    rescue MigrationError => e
+      Cauchy.logger.warn e.to_s
+    end
+
+    desc 'version', 'Displays the version number'
+    def version
+      Cauchy.logger.info "Couchy v#{Cauchy::VERSION}"
+    end
+
+    private
+
+    def project_path
+      @project_path ||= File.expand_path options['path']
+    end
+
+    def config_path
+      @config_path ||= File.join project_path, 'config.yml'
+    end
+
+    def schema_path(schema_file = nil)
+      File.join *[project_path, 'schema', schema_file].compact
+    end
+
+    def client
+      @client ||= Elastic::Client.new(config)
+    end
+
+    def config
+      @config ||= begin
+        if File.exists?(config_path)
+          YAML.load_file(config_path).deep_symbolize_keys
+        else
+          { url: ENV.fetch('ELASTICSEARCH_URL', 'localhost:9200') }
+        end
+      end
+    end
+
+    def yaml_config
+
+    end
+
+    def normalize_schema_name(name)
+      name.gsub(/[^a-z0-9\-]+/i, '_').downcase
+    end
+
+    def verify_project!
+      unless Dir.exists? schema_path
+        Cauchy.logger.fatal "Unable to locate schema directory #{schema_path}"
+        Cauchy.logger.info 'Did you setup a project with `cauchy init`?'
+        exit
+      end
+    end
+
+    def init_project
+      unless Dir.exists? schema_path
+        Cauchy.logger.debug "Creating schema directory at #{schema_path}"
+        FileUtils.mkdir_p schema_path
+      end
+
+      unless File.exists? config_path
+        Cauchy.logger.debug "Creating config file at #{config_path}"
+        File.open(config_path, 'w+') { |f| f.print <<-YAML }
+# Supports elasticsearch/transport options. See: http://www.rubydoc.info/gems/elasticsearch-transport
+# This file is optional, you can also set ELASTICSEARCH_URL in your environment
+hosts:
+  - host: localhost
+    port: 9200
+    scheme: http
+YAML
+      end
+
+      Cauchy.logger.info "\nWant to run cauchy from anywhere? Add the following to your shell config:"
+      Cauchy.logger.debug "export CAUCHY_PATH=#{project_path}"
+    end
+
+    def generate_schema(name)
+      name = normalize_schema_name(name)
+      path = schema_path("#{name}.rb")
+
+      if File.exists? path
+        return unless yes? "Schema file exists at #{path}, overwrite? (y/n)?"
+      end
+
+      Cauchy.logger.info "Creating a new schema `#{name}` at #{path}"
+
+      File.open(path, 'w+') { |f| f.print <<-RB }
+Cauchy::IndexSchema.define(:#{name}) do
+
+  settings do
+    # {
+    #   number_of_replicas: 2
+    # }
+  end
+
+  mappings do
+    # {
+    #   #{name.singularize}: {
+    #     properties: {
+    #       name: { type: 'string' }
+    #     }
+    #   }
+    # }
+  end
+
+end
+RB
+    end
+  end
+end

data/lib/cauchy/elastic/client.rb

@@ -0,0 +1,29 @@
+require 'elasticsearch'
+
+require 'cauchy/elastic/index'
+
+module Cauchy
+  module Elastic
+    class Client
+
+      attr_reader :server
+
+      def initialize(config)
+        @server = Elasticsearch::Client.new(config)
+      end
+
+      def index(name)
+        Index.new(server, name)
+      end
+
+      def bulk(body)
+        server.bulk body: body
+      end
+
+      def update_aliases(body)
+        server.indices.update_aliases body: body
+      end
+
+    end
+  end
+end

data/lib/cauchy/elastic/index.rb

@@ -0,0 +1,115 @@
+module Cauchy
+  module Elastic
+
+    class ElasticError < StandardError
+      def initialize(message = nil)
+        super
+      end
+    end
+
+    class IndexAlreadyExistsError < ElasticError
+      def initialize(name)
+        super("Index \"#{name}\" already exists")
+      end
+    end
+
+    class CannotUpdateNonDynamicSettingsError < ElasticError
+      def initialize(name)
+        super("Index \"#{name}\" cannot be updated while open.")
+      end
+    end
+
+    class Index
+
+      attr_reader :server, :name
+
+      def initialize(server, name)
+        @server = server
+        @name = name
+      end
+
+      def exists?
+        server.indices.exists? index: name
+      end
+
+      def aliases
+        get 'aliases'
+      end
+
+      def mappings
+        get('mapping')[name]['mappings']
+      rescue
+        {}
+      end
+
+      def settings
+        get('settings')[name]['settings']['index']
+      rescue
+        {}
+      end
+
+      def alias=(alias_name)
+        server.indices.put_alias index: name, name: alias_name
+      end
+
+      def mappings=(mappings)
+        mappings.each do |type, mapping|
+          server.indices.put_mapping index: name, type: type,
+            body: { type => mapping }
+        end
+      end
+
+      def settings=(settings)
+        server.indices.put_settings index: name, body: settings
+      rescue Elasticsearch::Transport::Transport::Errors::BadRequest => e
+        if e.message =~ /update non dynamic settings/
+          raise CannotUpdateNonDynamicSettingsError.new(name)
+        else
+          raise
+        end
+      end
+
+      def create(settings: {}, mappings: {})
+        server.indices.create index: name,
+          body: { settings: settings, mappings: mappings }
+      rescue Elasticsearch::Transport::Transport::Errors::BadRequest => e
+        if e.message =~ /IndexAlreadyExists/
+          raise IndexAlreadyExistsError.new(name)
+        else
+          raise
+        end
+      end
+
+      def delete
+        server.indices.delete index: name
+      end
+
+      def open
+        server.indices.open index: name
+      end
+
+      def close
+        server.indices.close index: name
+      end
+
+      def scroll(options = {})
+        options = { index: name, search_type: 'scan', scroll: '5m', size: 100 }.merge(options)
+        scroll_id = server.search(options)['_scroll_id']
+        begin
+          results = server.scroll(scroll_id: scroll_id, scroll: options[:scroll])
+          documents, scroll_id = results['hits']['hits'], results['_scroll_id']
+          yield documents, results['hits']['total'] if documents.any?
+        end while documents.size > 0
+      end
+
+      private
+
+      def get(resource)
+        server.indices.send(['get', resource].join('_').to_sym, index: name)
+      rescue Elasticsearch::Transport::Transport::Errors::NotFound
+        nil
+      end
+
+    end
+  end
+end

data/lib/cauchy/index_schema/normalization.rb

@@ -0,0 +1,56 @@
+require 'active_support/core_ext/hash'
+
+module Cauchy
+  class IndexSchema
+    module Normalization
+
+      IGNORE_SETTINGS = %w[
+        creation_date
+        uuid
+        version
+      ]
+
+      def normalize_mapping(hash)
+        hash.deep_stringify_keys.sort.map do |key, field|
+          if field.key?('properties')
+            field['properties'] = normalize_mapping(field['properties'])
+            field['type'] = 'object'
+          end
+
+          if field['type'] == 'date'
+            field['format'] ||= 'dateOptionalTime'
+          end
+
+          if ['boolean', 'long', 'double', 'date'].include?(field['type'])
+            field.delete('analyzer')
+            field['index'] ||= 'not_analyzed'
+          end
+
+          if key == 'properties'
+            field = normalize_mapping(field)
+          else
+            field = normalize_value(field)
+          end
+
+          [key, field]
+        end.to_h
+      end
+
+      def normalize_settings(hash)
+        normalize_value(hash.deep_stringify_keys.except(*IGNORE_SETTINGS))
+      end
+
+      def normalize_value(value)
+        case value
+        when Hash
+          value.sort.map {|key, v| [key, normalize_value(v)] }.to_h
+        when Numeric
+          value.to_s
+        else
+          value
+        end
+      end
+
+    end
+  end
+end

data/lib/cauchy/index_schema.rb

@@ -0,0 +1,77 @@
+require 'cauchy/index_schema/normalization'
+
+module Cauchy
+  class IndexSchema
+
+    include Normalization
+
+    @@schemas = {}
+
+    class << self
+
+      def define(index_alias, &block)
+        index_alias = index_alias.to_s
+        schemas[index_alias] = new(index_alias).tap { |s| s.define(&block) }
+      end
+
+      def load_schemas(paths)
+        Dir[*Array(paths).map { |p| "#{p}/**/*.rb" }].each { |f| load f }
+      end
+
+      def schemas
+        @@schemas
+      end
+
+      def schemas=(schemas)
+        @@schemas = schemas
+      end
+
+    end
+
+    attr_accessor :index_alias
+
+    def initialize(index_alias)
+      @index_alias = index_alias
+    end
+
+    def define(&block)
+      instance_eval(&block)
+    end
+
+    def mappings(&block)
+      self.mappings = block.call || {} if block_given?
+      @mappings || {}
+    end
+
+    def mappings=(value)
+      @mappings = value.map do |type, mapping|
+        [type.to_s, normalize_mapping(mapping)]
+      end.to_h
+    end
+
+    def mapping_for(type)
+      return unless mappings.key?(type)
+      mappings[type]['properties']
+    end
+
+    def settings(&block)
+      self.settings = block.call || {} if block_given?
+      @settings || {}
+    end
+
+    def settings=(value)
+      @settings = normalize_settings(value)
+    end
+
+    def types
+      mappings.keys
+    end
+
+    def version
+      @version ||= Digest::SHA1.hexdigest(
+        { settings: settings, mappings: mappings }.to_json
+      )
+    end
+
+  end
+end

data/lib/cauchy/logging.rb

@@ -0,0 +1,58 @@
+require 'delegate'
+require 'indentation'
+require 'rainbow/ext/string'
+require 'logger'
+
+module Cauchy
+  module_function
+
+  class << self
+
+    class PrettyLogger < SimpleDelegator
+      def initialize logger
+        super
+
+        old_formatter = logger.formatter
+
+        logger.formatter =  proc do |level, time, prog, msg|
+          unless msg.start_with?("\e")
+            color = case level
+                    when 'FATAL' then :red
+                    when 'WARN'  then :yellow
+                    when 'INFO'  then :blue
+                    when 'DEBUG' then '333333'
+                    else              :default
+                    end
+            msg = msg.color(color)
+          end
+
+          old_formatter.call level, time, prog, msg
+        end
+      end
+
+      %w[ debug info warn fatal ].each do |level|
+        define_method level do |msg, opts = {}|
+          __getobj__.__send__ level, msg
+        end
+      end
+
+      def inspect object
+        info object.to_yaml[4..-1].strip.indent
+      end
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      @logger ||= begin
+        logger = Logger.new STDOUT
+        logger.level = Logger::DEBUG
+        logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+        PrettyLogger.new logger
+      end
+    end
+
+  end
+end

data/lib/cauchy/migration.rb

@@ -0,0 +1,82 @@
+require 'diffy'
+
+module Cauchy
+  class Migration
+
+    CREATION_SETTINGS = %w[
+      codec
+      number_of_shards
+    ]
+
+    attr_accessor :schema, :new_schema
+
+    def initialize(schema, new_schema)
+      @schema = schema
+      @new_schema = new_schema
+    end
+
+    def changes_mappings?
+      (new_schema.types - schema.types).any? ||
+        (new_schema.types & schema.types).any? do |type|
+          mapping, new_mapping = schema.mapping_for(type), new_schema.mapping_for(type)
+          removed_fields = mapping.keys - new_mapping.keys
+          mapping.except(*removed_fields) != new_mapping
+        end
+    end
+
+    def changes_existing_mappings?
+      (new_schema.types & schema.types).any? do |type|
+        mapping, new_mapping = schema.mapping_for(type), new_schema.mapping_for(type)
+        common_fields = mapping.keys & new_mapping.keys
+        mapping.slice(*common_fields) != new_mapping.slice(*common_fields)
+      end
+    end
+
+    def changed_settings
+      new_schema.settings.select do |name, setting|
+        schema.settings[name] != setting
+      end.to_h
+    end
+
+    def changes_settings?
+      changed_settings.present?
+    end
+
+    def changes_creation_settings?
+      schema.settings.slice(*CREATION_SETTINGS).except(*removed_settings) !=
+        new_schema.settings.slice(*CREATION_SETTINGS)
+    end
+
+    def removed_settings
+      schema.settings.keys - new_schema.settings.keys
+    end
+
+    def requires_reindex?
+      changes_creation_settings? || changes_existing_mappings?
+    end
+
+    def up_to_date?
+      !(changes_settings? || changes_mappings?)
+    end
+
+    def mappings_diffs
+      (schema.mappings.keys | new_schema.mappings.keys).map do |type|
+        diff = Diffy::Diff.new(
+          JSON.pretty_generate(schema.mappings[type] || {}) + "\n",
+          JSON.pretty_generate(new_schema.mappings[type] || {}) + "\n",
+          context: 3
+        )
+        [type, diff]
+      end.to_h
+    end
+
+    def settings_diff
+      Diffy::Diff.new(
+        JSON.pretty_generate(schema.settings.except(*removed_settings)) + "\n",
+        JSON.pretty_generate(new_schema.settings.except(*removed_settings)) + "\n",
+        context: 3
+      )
+    end
+
+  end
+end

data/lib/cauchy/migrator.rb

@@ -0,0 +1,249 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
+require 'ruby-progressbar'
+require 'json'
+
+require 'cauchy/index_schema'
+require 'cauchy/migration'
+
+module Cauchy
+
+  class MigrationError < StandardError
+  end
+
+  class UnknownIndexSchemaError < MigrationError
+    def initialize(name)
+      super("No index schema defined for \"#{name}\"")
+    end
+  end
+
+  class MultipleIndexAliasError < MigrationError
+    def initialize(name)
+      super("Multiple index aliases found for \"#{name}\"")
+    end
+  end
+
+  class NoIndexSchemasError < MigrationError
+    def initialize
+      super("No index schemas defined")
+    end
+  end
+
+  class Migrator
+
+    class << self
+
+      def migrate(client, index_paths = nil, target_index = nil, options = {})
+        with_schemas(index_paths, target_index) do |schema|
+          new(client, schema).migrate options
+        end
+      end
+
+      def status(client, index_paths = nil, target_index = nil)
+        with_schemas(index_paths, target_index) do |schema|
+          new(client, schema).status
+        end
+      end
+
+      private
+
+      def with_schemas(index_paths, target_index = nil)
+        found_target = false
+        IndexSchema.load_schemas(index_paths)
+
+        raise NoIndexSchemasError unless IndexSchema.schemas.any?
+
+        IndexSchema.schemas.each do |index_alias, schema|
+          if target_index.nil? || target_index == index_alias
+            found_target = true
+            yield schema
+          end
+        end
+
+        raise UnknownIndexSchemaError, target_index unless found_target
+      end
+
+    end
+
+    attr_reader :client, :schema
+
+    def initialize(client, schema)
+      @client = client
+      @schema = schema
+    end
+
+    delegate :index_alias, :version, to: :schema
+
+    def new_index_name
+      "#{index_alias}_#{version}"
+    end
+
+    def new_index
+      @new_index ||= client.index(new_index_name)
+    end
+
+    def old_index
+      @old_index ||= client.index(resolve_index)
+    end
+
+    def migration
+      @migration ||= Migration.new(old_schema, schema)
+    end
+
+    def migrate(options = {})
+      raise MultipleIndexAliasError, index_alias if index_aliases.keys.length > 1
+
+      if options[:reindex] || !old_index.exists?
+        return reindex(options)
+      end
+
+      if migration.up_to_date?
+        log 'Index is up-to-date.'
+        return true
+      end
+
+      if migration.requires_reindex?
+        log migration_diff, :unknown
+        log 'Requires reindexing!', :warn
+        return false
+      end
+
+      if migration.changes_settings?
+        log 'Updating index settings... ' do
+          begin
+            old_index.close if options[:close_index]
+            old_index.settings = migration.changed_settings
+          rescue Elastic::CannotUpdateNonDynamicSettingsError
+            log migration_diff, :unknown
+            raise
+          ensure
+            old_index.open if options[:close_index]
+          end
+          'done.'
+        end
+      end
+
+      if migration.changes_mappings?
+        log 'Updating index mappings... ' do
+          old_index.mappings = migration.new_schema.mappings
+          'done.'
+        end
+      end
+    end
+
+    def reindex(options = {})
+      if old_index.exists?
+        if migration.up_to_date?
+          log 'Index is up-to-date.'
+          return true
+        elsif !migration.requires_reindex?
+          log 'Does not require reindexing... skipping.'
+          return false
+        end
+      end
+
+      begin
+        log "Creating new index #{new_index_name}"
+        new_index.create settings: schema.settings, mappings: schema.mappings
+      rescue Elastic::IndexAlreadyExistsError
+        log "Index #{new_index_name} already exists, continuing...", :warn
+      end
+
+      reindex_data if old_index.exists?
+
+      cleanup options
+
+      true
+    end
+
+    def reindex_data
+      log 'Reindexing...'
+      progress_bar = nil
+      old_index.scroll do |documents, total|
+        docs = documents.map do |h|
+          {
+            index: {
+              _index: new_index.name,
+              _type: h['_type'],
+              _id: h['_id'],
+              data: h['_source']
+            }
+          }
+        end
+
+        client.bulk docs
+
+        progress_bar ||= ProgressBar.create(total: total, throttle_rate: 0.1, format: '%a |%B| %e')
+        progress_bar.progress += docs.size
+      end
+    end
+
+    def status
+      if migration.up_to_date?
+        log 'Index is up-to-date.'
+      else
+        log migration_diff, :unknown
+        log 'Requires reindexing!', :warn if migration.requires_reindex?
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}"\
+        " index_alias=\"#{index_alias}\""\
+        " version=\"#{version[0..6]}\">"
+    end
+
+    def old_schema
+      @old_schema ||= begin
+        IndexSchema.new(index_alias).tap do |schema|
+          schema.mappings = old_index.mappings
+          schema.settings = old_index.settings
+        end
+      end
+    end
+
+    private
+
+    def cleanup(options)
+      log "Aliasing #{new_index.name} => #{index_alias}"
+      if old_index.name == index_alias
+        old_index.delete if old_index.exists?
+        new_index.alias = index_alias
+      else
+        client.update_aliases({
+          actions: [
+            { add:    { alias: index_alias, index: new_index.name } },
+            { remove: { alias: index_alias, index: old_index.name } }
+          ]
+        })
+        old_index.delete if options.fetch :cleanup, true
+      end
+    end
+
+    def migration_diff
+      mappings_diff = migration.mappings_diffs.map do |type, diff|
+          diff = diff.to_s(:color).rstrip
+         "Mapping type=#{type}:\n" + diff if diff.present?
+      end.compact.join("\n")
+
+      settings_diff = migration.settings_diff.to_s(:color).rstrip
+      settings_diff = "Settings:\n" + settings_diff if settings_diff.present?
+
+      [mappings_diff, settings_diff].select(&:present?).join("\n\n")
+    end
+
+    def resolve_index
+      index_aliases.keys.first || index_alias
+    end
+
+    def index_aliases
+      client.index(index_alias).aliases
+    end
+
+    def log(msg, method = :info, &block)
+      Cauchy.logger.send(method, msg)
+      Cauchy.logger.send(method, block.call) if block_given?
+    end
+
+  end
+end

data/lib/cauchy/version.rb

@@ -0,0 +1,3 @@
+module Cauchy
+  VERSION = '0.1.1'
+end

data/lib/cauchy.rb

@@ -0,0 +1,4 @@
+require 'cauchy/elastic/client'
+require 'cauchy/migrator'
+require 'cauchy/logging'
+require 'cauchy/version'

metadata

@@ -0,0 +1,248 @@
+--- !ruby/object:Gem::Specification
+name: cauchy
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Paul Hamera
+- Evan Owen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: elasticsearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: indentation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An elasticsearch schema management tool
+email:
+- paul@zinc.it
+- evan@zinc.it
+executables:
+- cauchy
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/cauchy
+- cauchy.gemspec
+- lib/cauchy.rb
+- lib/cauchy/cli.rb
+- lib/cauchy/elastic/client.rb
+- lib/cauchy/elastic/index.rb
+- lib/cauchy/index_schema.rb
+- lib/cauchy/index_schema/normalization.rb
+- lib/cauchy/logging.rb
+- lib/cauchy/migration.rb
+- lib/cauchy/migrator.rb
+- lib/cauchy/version.rb
+homepage: https://github.com/cotap
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: An elasticsearch schema management tool
+test_files: []