elasticsnap 0.1.0

data/lib/elasticsnap/freeze_elasticsearch.rb

@@ -0,0 +1,72 @@
+module Elasticsnap
+  class FreezeElasticsearch
+    class Error < StandardError; end
+    class FlushFailed < Error; end
+    class DisableFlushFailed < Error; end
+    class EnableFlushFailed < Error; end
+
+    attr_accessor :url
+
+    def initialize(url: nil)
+      raise ArgumentError, 'url required' if url.nil?
+
+      @url = url
+    end
+
+    def freeze(&block)
+      begin
+        flush
+        disable_flush
+
+        block.call unless block.nil?
+      ensure
+        enable_flush
+      end
+    end
+
+    def flush
+      Flex::Configuration.http_client.base_uri = url
+      result = Flex.flush_index(index: '_all')
+
+      raise FlushFailed unless result.fetch('ok', false) == true
+
+      result
+    end
+
+    def disable_flush
+      Flex::Configuration.http_client.base_uri = url
+      result = Flex.update_index_settings(
+        index: '_all',
+        data: {
+          index: {
+            translog: {
+              disable_flush: true
+            }
+          }
+        }
+      )
+
+      raise DisableFlushFailed unless result.fetch('ok', false) == true
+
+      result
+    end
+
+    def enable_flush
+      Flex::Configuration.http_client.base_uri = url
+      result = Flex.update_index_settings(
+        index: '_all',
+        data: {
+          index: {
+            translog: {
+              disable_flush: false
+            }
+          }
+        }
+      )
+
+      raise EnableFlushFailed unless result.fetch('ok', false) == true
+
+      result
+    end
+  end
+end

data/lib/elasticsnap/freeze_fs.rb

@@ -0,0 +1,55 @@
+require 'capistrano/cli'
+
+module Elasticsnap
+  class FreezeFs
+    attr_accessor :mount
+    attr_accessor :security_group
+    attr_accessor :ssh_user
+
+    def initialize(mount: nil, security_group: nil, ssh_user: nil)
+      raise ArgumentError, 'mount required' if mount.nil?
+      raise ArgumentError, 'security_group required' if security_group.nil?
+
+      @mount = mount
+      @security_group = security_group
+      @ssh_user = ssh_user
+    end
+
+    def freeze(&block)
+      begin
+        sync
+        freeze_fs
+
+        block.call unless block.nil?
+      ensure
+        unfreeze_fs
+      end
+    end
+
+    def sync
+      run_command('sudo sync')
+    end
+
+    def freeze_fs
+      run_command 'sudo fsfreeze', '-f', mount
+    end
+
+    def unfreeze_fs
+      run_command 'sudo fsfreeze', '-u', mount
+    end
+
+    private
+    def run_command(*command)
+      stream(*command)
+    end
+
+    def stream(*command)
+      command = [command].flatten.join(' ')
+      capistrano_config.stream(command, hosts: SecurityGroup.new(name: security_group).ssh_hosts(ssh_user: ssh_user))
+    end
+
+    def capistrano_config
+      @cap_config ||= Capistrano::Configuration.new
+    end
+  end
+end

data/lib/elasticsnap/security_group.rb

@@ -0,0 +1,50 @@
+require 'elasticsnap/config'
+
+module Elasticsnap
+  class SecurityGroup
+    attr_accessor :name
+
+    def initialize(name: nil)
+      raise ArgumentError, 'name required' if name.nil?
+
+      @name = name
+    end
+
+    def hosts
+      @hosts ||= connection.servers.all('group-id' => id)
+    end
+
+    def ssh_hosts(ssh_user: nil)
+      hosts.map do |host|
+        if ssh_user
+          "#{ssh_user}@#{host.dns_name}"
+        else
+          host.dns_name
+        end
+      end
+    end
+
+    def volumes(cluster_name: nil)
+      filters = { 'attachment.instance-id' => hosts.map(&:id) }
+      filters.merge!('tag:ClusterName' => cluster_name) if cluster_name
+      connection.volumes.all(filters)
+    end
+
+    def fog_group
+      @fog_group ||= connection.security_groups.all('group-name' => name).first
+    end
+
+    def id
+      @id ||= fog_group.group_id
+    end
+
+    def reload
+      @hosts = @id = nil
+    end
+
+    private
+    def connection
+      Config.fog_connection
+    end
+  end
+end

data/lib/elasticsnap/snapshot.rb

@@ -0,0 +1,56 @@
+require 'elasticsnap/verify_es_cluster_status'
+require 'elasticsnap/freeze_elasticsearch'
+require 'elasticsnap/freeze_fs'
+require 'elasticsnap/ebs_snapshot'
+
+module Elasticsnap
+  class Snapshot
+    attr_accessor :security_group
+    attr_accessor :url
+    attr_accessor :mount
+    attr_accessor :quorum_nodes
+    attr_accessor :wait_timeout
+    attr_accessor :cluster_name
+    attr_accessor :ssh_user
+
+    def initialize(security_group: nil, url: nil, mount: nil, quorum_nodes: nil, wait_timeout: 30, cluster_name: nil, ssh_user: nil)
+      raise ArgumentError, "security_group required" if security_group.nil?
+      raise ArgumentError, "url required" if url.nil?
+      raise ArgumentError, "mount required" if mount.nil?
+      raise ArgumentError, "quorum_nodes required" if quorum_nodes.nil?
+
+      @security_group = security_group
+      @url = url
+      @mount = mount
+      @quorum_nodes = quorum_nodes
+      @wait_timeout = wait_timeout
+      @cluster_name = cluster_name
+      @ssh_user = ssh_user
+    end
+
+    def call
+      verify_es_cluster_status!
+      freeze_es do
+        freeze_fs do
+          ebs_snapshot!
+        end
+      end
+    end
+
+    def verify_es_cluster_status!
+      VerifyEsClusterStatus.new(url: url, quorum_nodes: quorum_nodes, wait_timeout: wait_timeout).verify!
+    end
+
+    def freeze_es(&block)
+      FreezeElasticsearch.new(url: url).freeze(&block)
+    end
+
+    def freeze_fs(&block)
+      FreezeFs.new(mount: mount, security_group: security_group, ssh_user: ssh_user).freeze(&block)
+    end
+
+    def ebs_snapshot!
+      EbsSnapshot.new(security_group: security_group, cluster_name: cluster_name).snapshot
+    end
+  end
+end

data/lib/elasticsnap/snapshot_volume_tags.rb

@@ -0,0 +1,13 @@
+require 'elasticsnap/config'
+
+module Elasticsnap
+  module SnapshotVolumeTags
+    def add_volume_tags(volume)
+      connection.create_tags(self.id, volume.tags)
+    end
+
+    def connection
+      Config.fog_connection
+    end
+  end
+end

data/lib/elasticsnap/verify_es_cluster_status.rb

@@ -0,0 +1,42 @@
+require 'flex'
+
+module Elasticsnap
+  class VerifyEsClusterStatus
+    class Error < StandardError; end
+    class StatusRed < Error; end
+    class NoQuorum < Error; end
+
+    attr_accessor :url
+    attr_accessor :quorum_nodes
+    attr_accessor :wait_timeout
+
+    def initialize(url: nil, quorum_nodes: nil, wait_timeout: 30)
+      raise ArgumentError, 'url required' if url.nil?
+      raise ArgumentError, 'quorum_nodes required' if quorum_nodes.nil?
+
+      @url = url
+      @quorum_nodes = quorum_nodes
+      @wait_timeout = wait_timeout
+    end
+
+    def verify!
+      wait_for_green_quorum!
+    end
+
+    def wait_for_green_quorum!
+      Flex::Configuration.http_client.base_uri = url
+      health = Flex.cluster_health(
+        params: {
+          wait_for_status: 'yellow',
+          wait_for_nodes: "gt(#{quorum_nodes})",
+          timeout: "#{wait_timeout}s"
+        }
+      )
+
+      raise StatusRed if health['status'] == 'red'
+      raise NoQuorum if health['number_of_nodes'] < quorum_nodes
+
+      health
+    end
+  end
+end

data/lib/elasticsnap/version.rb

@@ -0,0 +1,3 @@
+module Elasticsnap
+  VERSION = "0.1.0"
+end

data/spec/acceptance/snapshot_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe 'Snapshots' do
+  before do
+    WebMock.disable_net_connect!
+    #WebMock.allow_net_connect!
+  end
+
+  let(:timeout) { 2 }
+  let(:quorum) { 2 }
+  let(:args) { "-u localhost:9200 -v /dev/sda -q #{quorum} -t #{timeout}" }
+
+  it 'User creates snapshot' do
+    pending 'Add stubs for ssh connections and fog'
+    health_check = stub_request(:get, 'localhost:9200/_cluster/health/').with(
+      query: hash_including({
+        wait_for_nodes: "gt(#{quorum})",
+        wait_for_status: 'yellow'
+      })
+    ).to_return(
+      body: MultiJson.dump({
+        'cluster_name' => 'foobar',
+        'status' => 'green',
+        'timed_out' => false,
+        'number_of_nodes' => 2,
+        'number_of_data_nodes' => 2,
+        'active_primary_shards' => 5,
+        'active_shards' => 10,
+        'relocating_shards' => 0,
+        'initializing_shards' => 0,
+        'unassigned_shards' => 0
+      })
+    )
+
+    flush = stub_request(:post, 'localhost:9200/_all/_flush').to_return(
+      body: MultiJson.dump({
+        'ok' => true
+      })
+    )
+
+    disable_flush = stub_request(:put, 'localhost:9200/_all/_settings').with(
+      body: MultiJson.dump({
+        index: {
+          translog: {
+            disable_flush: true
+          }
+        }
+      })
+    ).to_return(
+      body: MultiJson.dump({
+        'ok' => true
+      })
+    )
+
+    enable_flush = stub_request(:put, 'localhost:9200/_all/_settings').with(
+      body: MultiJson.dump({
+        index: {
+          translog: {
+            disable_flush: false
+          }
+        }
+      })
+    ).to_return(
+      body: MultiJson.dump({
+        'ok' => true
+      })
+    )
+
+    start(:snapshot, args)
+    expect(health_check).to have_been_requested
+    expect(flush).to have_been_requested
+    expect(disable_flush).to have_been_requested
+    expect(enable_flush).to have_been_requested
+  end
+end

data/spec/elasticsnap/ebs_snapshot_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Elasticsnap::EbsSnapshot do
+  it 'requires security group' do
+    expect { described_class.new }.to raise_error ArgumentError
+  end
+
+  let(:security_group) { double(:security_group, name: 'elasticsearch') }
+  let(:snapshotter) { described_class.new(security_group: security_group.name) }
+  let(:snapshots) { [double(:snapshot1, add_volume_tags: true), double(:snapshot2, add_volume_tags: true)] }
+  let(:volumes) { [double(:volume1, id: 'vol-123', snapshot: snapshots[0]), double(:volume2, id: 'vol-234', snapshot: snapshots[1])] }
+
+  describe '#snapshot' do
+    before do
+      allow(snapshotter).to receive(:wrap_snapshot) do |snapshot|
+        snapshot
+      end
+
+      allow(Elasticsnap::SecurityGroup).to receive(:new).with(name: security_group.name).and_return(security_group)
+      allow(security_group).to receive(:volumes).and_return(volumes)
+    end
+
+    it 'gets a list of volumes from the security group' do
+      snapshotter.snapshot
+      expect(Elasticsnap::SecurityGroup).to have_received(:new).with(name: security_group.name)
+      expect(security_group).to have_received(:volumes)
+    end
+
+    it 'snapshots each volume' do
+      snapshotter.snapshot
+      volumes.each do |volume|
+        expect(volume).to have_received(:snapshot)
+      end
+    end
+
+    it 'adds volume tags to each snapshot' do
+      snapshotter.snapshot
+      snapshots.each do |snapshot|
+        expect(snapshot).to have_received(:add_volume_tags)
+      end
+    end
+  end
+
+  describe '#wrap_snapshot' do
+    let(:snapshot_body) { double(:snapshot_body) }
+    let(:snapshot_response) { double(:snapshot_response, body: snapshot_body) }
+    let(:snapshot) { double(:snapshot) }
+
+    before do
+      allow(Fog::Compute::AWS::Snapshot).to receive(:new).with(snapshot_body).and_return(snapshot)
+    end
+
+    it 'bundles the response in a snapshot model' do
+      snapshotter.wrap_snapshot(snapshot_response)
+      expect(Fog::Compute::AWS::Snapshot).to have_received(:new)
+    end
+
+    it 'extends the snapshot instance with SnapshotVolumeTags' do
+      expect(snapshot).to receive(:extend).with(Elasticsnap::SnapshotVolumeTags)
+      snapshotter.wrap_snapshot(snapshot_response)
+    end
+  end
+end

data/spec/elasticsnap/freeze_elasticsearch_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Elasticsnap::FreezeElasticsearch do
+  it 'requires url' do
+    expect { described_class.new }.to raise_error ArgumentError
+  end
+
+  let(:freeze) { described_class.new(url: 'localhost:9200')}
+  let(:disable_flush_hash) do
+    {
+      index: '_all',
+      data: {
+        index: {
+          translog: {
+            disable_flush: true
+          }
+        }
+      }
+    }
+  end
+  let(:enable_flush_hash) do
+    {
+      index: '_all',
+      data: {
+        index: {
+          translog: {
+            disable_flush: false
+          }
+        }
+      }
+    }
+  end
+
+  before do
+    allow(Flex).to receive(:flush_index).and_return({'ok' => true})
+    allow(Flex).to receive(:update_index_settings).with(disable_flush_hash).and_return({'ok' => true})
+    allow(Flex).to receive(:update_index_settings).with(enable_flush_hash).and_return({'ok' => true})
+  end
+
+  it 'flushes elasticsearch' do
+    freeze.freeze
+    expect(Flex).to have_received(:flush_index).with(index: '_all')
+  end
+
+  context 'when flushing fails' do
+    before do
+      allow(Flex).to receive(:flush_index).and_return({'ok' => false})
+    end
+
+    it 'raises FlushFailed' do
+      expect { freeze.freeze }.to raise_error Elasticsnap::FreezeElasticsearch::FlushFailed
+    end
+  end
+
+  it 'disables flushing' do
+    freeze.freeze
+    expect(Flex).to have_received(:update_index_settings).with(disable_flush_hash)
+  end
+
+  context 'when disable flushing fails' do
+    before do
+      allow(Flex).to receive(:update_index_settings).with(disable_flush_hash).and_return({'ok' => false})
+    end
+
+    it 'raises DisableFlushFailed' do
+      expect { freeze.freeze }.to raise_error Elasticsnap::FreezeElasticsearch::DisableFlushFailed
+    end
+  end
+
+  it 'calls the passed block' do
+    block_called = false
+    freeze.freeze do
+      block_called = true
+    end
+
+    expect(block_called).to be_true
+  end
+
+  it 'enables flushing' do
+    freeze.freeze
+    expect(Flex).to have_received(:update_index_settings).with(enable_flush_hash)
+  end
+
+  context 'when enable flushing fails' do
+    before do
+      allow(Flex).to receive(:update_index_settings).with(enable_flush_hash).and_return({'ok' => false})
+    end
+
+    it 'raises EnableFlushFailed' do
+      expect { freeze.freeze }.to raise_error Elasticsnap::FreezeElasticsearch::EnableFlushFailed
+    end
+  end
+
+  context 'when an exception is raised from the block' do
+    it 'enables flushing' do
+      expect { freeze.freeze do
+        raise 'BOOM'
+      end }.to raise_error 'BOOM'
+      expect(Flex).to have_received(:update_index_settings).with(enable_flush_hash)
+    end
+  end
+end