auto-consul 0.0.1

data/spec/cluster_spec.rb

@@ -0,0 +1,100 @@
+require 'spec-helper'
+
+describe AutoConsul::Cluster do
+  let(:uri) { "s3://some-bucket-#{double.object_id}/some/prefix/#{double.object_id}" }
+  let(:servers_uri) { "#{uri}/servers" }
+  let(:agents_uri) { "#{uri}/agents" }
+  let(:registry_lookup) { AutoConsul::Cluster.should_receive(:get_provider_for_uri) }
+
+  subject { AutoConsul::Cluster.new uri }
+
+  it 'should get provider for */servers' do
+    registry_lookup.once.with(servers_uri).and_return(provider = double("S3Provider"))
+    expect(subject.servers).to equal(provider)
+    expect(subject.servers).to equal(provider)
+  end
+
+  it 'should get provider for */agents' do
+    registry_lookup.once.with(agents_uri).and_return(provider = double("S3Provider"))
+    subject.agents
+    expect(subject.agents).to equal(provider)
+    expect(subject.agents).to equal(provider)
+  end
+
+  describe 'set_mode!' do
+    let(:agents) { [] }
+    let(:servers) { [] }
+    let(:expiry) { double }
+    let(:local_state) { double }
+
+    before do
+      subject.stub(:agents).and_return(agents_reg = double)
+      agents_reg.stub(:members).with(expiry).and_return agents
+      subject.stub(:servers).and_return(servers_reg = double)
+      servers_reg.stub(:members).with(expiry).and_return servers
+    end
+
+    describe 'with no active servers' do
+      before do
+        # Default desired servers of 1.
+        local_state.should_receive(:set_server!)
+      end
+
+      it 'should set_server! with no server count specified' do
+        subject.set_mode! local_state, expiry
+      end
+
+      it 'should set_server! with a server count specified' do
+        subject.set_mode! local_state, expiry, 2
+      end
+    end
+
+    describe 'without enough active servers' do
+      before do
+        local_state.should_receive(:set_server!).with
+        local_state.should_not_receive(:set_agent!)
+      end
+
+      it 'should set_server! given 1 server but wanting 3' do
+        servers << double
+        subject.set_mode! local_state, expiry, 3
+      end
+
+      it 'should set_server! given 3 servers but wanting 4' do
+        servers << double
+        servers << double
+        servers << double
+        subject.set_mode! local_state, expiry, 4
+      end
+    end
+
+    describe 'with enough active servers' do
+      before do
+        servers << double
+        local_state.should_receive(:set_agent!).with
+        local_state.should_not_receive(:set_server!)
+      end
+
+      it 'should set_agent! given 1 server, wanting default' do
+        subject.set_mode! local_state, expiry
+      end
+
+      it 'should set_agent! given 1 server, wanting 1' do
+        subject.set_mode! local_state, expiry, 1
+      end
+
+      it 'should set_agent! given 3 servers, wanting 3' do
+        servers << double
+        servers << double
+        subject.set_mode! local_state, expiry, 3
+      end
+
+      it 'should set_agent! given 3 servers, wanting 2' do
+        servers << double
+        servers << double
+        subject.set_mode! local_state, expiry, 2
+      end
+    end
+  end
+end
+

data/spec/local_state_spec.rb

@@ -0,0 +1,110 @@
+require 'spec-helper'
+
+shared_examples_for 'a server' do
+  it 'should use "PATH/server" for data path' do
+    subject.data_path.should == File.join(tempdir.path 'server')
+  end
+
+  it 'should be true for server?' do
+    subject.should be_server
+  end
+
+  it 'should be false for agent?' do
+    subject.should_not be_agent
+  end
+end
+
+shared_examples_for 'an agent' do
+  it 'should use "PATH/agent" for data path' do
+    subject.data_path.should == File.join(tempdir.path 'agent')
+  end
+
+  it 'should be false for server?' do
+    subject.should_not be_server
+  end
+
+  it 'should be true for agent?' do
+    subject.should be_agent
+  end
+end
+
+tempdir_context AutoConsul::Local do
+  subject { AutoConsul::Local.bind_to_path path }
+
+  let(:path) { tempdir.path }
+
+  context 'given a non-existent path' do
+    let(:path) { tempdir.path 'faux', 'state', 'directory' }
+
+    it 'should create the desired path' do
+      File.directory?(subject.path).should be_true
+    end
+  end
+
+  it 'should use "PATH/mode" for mode_path' do
+    subject.mode_path.should == File.join(path, 'mode')
+  end
+
+  context 'set to server mode' do
+    before do
+      subject.set_server!
+    end
+
+    it 'should enter "server" in mode file' do
+      File.open(tempdir.path('mode'), 'r').read.should == 'server'
+    end
+
+    it_should_behave_like 'a server'
+  end
+
+  context 'set to agent mode' do
+    before do
+      subject.set_agent!
+    end
+
+    it 'should enter "agent" in mode file' do
+      File.open(tempdir.path('mode'), 'r').read.should == 'agent'
+    end
+
+    it_should_behave_like 'an agent'
+  end
+
+  context 'given a server mode file' do
+    before do
+      File.open(File.join(path, 'mode'), 'w') {|f| f.write 'server'}
+    end
+
+    it_should_behave_like 'a server'
+  end
+
+  context 'given an agent mode file' do
+    before do
+      File.open(File.join(path, 'mode'), 'w') {|f| f.write 'agent'}
+    end
+
+    it_should_behave_like 'an agent'
+  end
+
+  context 'given a bogus mode file' do
+    before do
+      File.open(File.join(path, 'mode'), 'w') {|f| f.write 'shmerver'}
+    end
+
+    it 'should have a nil mode' do
+      subject.mode.should be_nil
+    end
+
+    it 'should be false for server?' do
+      subject.should_not be_server
+    end
+
+    it 'should be false for agent?' do
+      subject.should_not be_agent
+    end
+
+    it 'should have a nil data_path' do
+      subject.data_path.should be_nil
+    end
+  end
+end
+

data/spec/run_state_cli_provider_spec.rb

@@ -0,0 +1,82 @@
+require 'spec-helper'
+
+def mock_output name
+  File.open(File.join(File.dirname(__FILE__), name), 'r') do |f|
+    f.read
+  end
+end
+
+shared_examples_for 'a running cli agent' do
+  it 'should be running' do
+    expect(subject).to be_running
+  end
+
+  it 'should be a running cli agent' do
+    expect(subject).to be_agent
+  end
+end
+
+describe AutoConsul::RunState::CLIProvider do
+  subject do
+    AutoConsul::RunState::CLIProvider.new
+  end
+
+  let :consul_fail do
+    c = subject.should_receive(:system).with do |cmd, opts|
+      cmd.should == 'consul info'
+    end
+    c.and_return false
+    c
+  end
+
+  let :consul_call do
+    subject.should_receive(:system) do |cmd, opts|
+      cmd.should == 'consul info'
+      opts[:out].write(output)
+    end
+  end
+
+  describe 'with no running consul' do
+    before do
+      consul_fail
+    end
+
+    it 'should not be running' do
+      expect(subject).not_to be_running
+    end
+
+    it 'should not be a running cli agent' do
+      expect(subject).not_to be_agent
+    end
+
+    it 'should not be a server' do
+      expect(subject).not_to be_server
+    end
+  end
+
+  describe 'with running consul' do
+    before do
+      consul_call
+    end
+
+    describe 'as normal agent' do
+      let(:output) { mock_output 'agent-output.txt' }
+
+      it_should_behave_like 'a running cli agent'
+
+      it 'should not be a server' do
+        expect(subject).not_to be_server
+      end
+    end
+
+    describe 'as server' do
+      let(:output) { mock_output 'server-output.txt' }
+
+      it_should_behave_like 'a running cli agent'
+
+      it 'should be a server' do
+        expect(subject).to be_server
+      end
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,75 @@
+require 'spec-helper'
+
+shared_examples_for 'a consul agent run' do |method_name, registry_name, join_flag, args|
+  it 'properly launches consul agent' do
+    members = []
+    members << member if join_flag
+
+    registry.should_receive(registry_name).with.and_return(reg = double)
+    reg.should_receive(:members).with(expiry).and_return(members)
+
+    expected_args = (['consul', 'agent', '-bind', ip, '-data-dir', data_dir, '-node', identity] + args).collect do |e|
+                      if e.instance_of? Symbol
+                        send e
+                      else
+                        e
+                      end
+                    end
+
+    AutoConsul::Runner.should_receive(:spawn).with(*expected_args).and_return(agent_pid = double)
+
+    # consul info retries to verify that it's running.
+    AutoConsul::Runner.should_receive(:system).with('consul', 'info').and_return(false, false, true)
+
+    AutoConsul::Runner.should_receive(:sleep).with(2)
+    AutoConsul::Runner.should_receive(:sleep).with(4)
+    AutoConsul::Runner.should_receive(:sleep).with(6)
+
+    if join_flag
+      AutoConsul::Runner.should_receive(:system).with('consul', 'join', remote_ip).and_return(true)
+    end
+
+    Process.should_receive(:wait).with(agent_pid)
+
+    callable = AutoConsul::Runner.method(method_name)
+    callable.call(identity, ip, expiry, local_state, registry)
+  end
+end
+
+describe AutoConsul::Runner do
+  let(:ip) { "192.168.50.101" }
+  let(:remote_ip) { "192.168.50.102" }
+  let(:member) { double("ClusterMember", :identity => 'foo', :time => double, :data => remote_ip) }
+  let(:agents_list) { [] }
+  let(:servers_list) { [] }
+  let(:identity) { "id-#{double.object_id}" }
+  let(:data_dir) { "/var/lib/consul/#{double.object_id}" }
+  let(:local_state) { double("FileSystemState", :data_path => data_dir) }
+  let(:registry) { double("Registry", :agents => double("S3Provider"),
+                                      :servers => double("S3Provider")) }
+
+  let(:expiry) { 120.to_i }
+
+  before do
+    registry.agents.stub(:agents).with(expiry).and_return(agents_list)
+    registry.servers.stub(:servers).with(expiry).and_return(servers_list)
+  end
+
+  describe :run_agent! do
+    it_behaves_like 'a consul agent run', :run_agent!, :agents, true, []
+  end
+
+  describe :run_server! do
+    describe 'with empty server registry' do
+      # consul agent -bind 192.168.50.100 -data-dir /opt/consul/server/data -node vagrant-server -server -bootstrap
+      it_behaves_like 'a consul agent run', :run_server!, :servers, false, ['-server', '-bootstrap']
+    end
+
+    describe 'with other servers in registry' do
+      # consul agent -bind 192.168.50.100 -data-dir /opt/consul/server/data -node vagrant-server -server
+      # consul join some_ip
+
+      it_behaves_like 'a consul agent run', :run_server!, :servers, true, ['-server']
+    end
+  end
+end

data/spec/s3_registry_provider_spec.rb

@@ -0,0 +1,239 @@
+require 'spec-helper'
+
+shared_examples_for 'a heartbeat emitter' do
+  it 'should write a TIMESTAMP-IDENTIFIER entry under the key prefix with the payload as data.' do
+    objects.should_receive(:[]).with(File.join(path, "#{stamp}-#{identity}")).and_return(obj = double)
+    obj.should_receive(:write).with(payload = "Some payload data #{double.to_s}")
+    subject.heartbeat! identity, payload, expiry
+  end
+end
+
+shared_examples_for 'has valid members' do |locator_pairs|
+  let :member_pairs do
+    locator_pairs.collect do |time_sym, identifier|
+      [send(time_sym), identifier]
+    end
+  end
+
+  it 'gets appropriate identifier and timestamp per member' do
+    m = subject.members(expiry).collect {|mem| [mem.time, mem.identifier]}
+    m.should == member_pairs
+  end
+
+  it 'does not read object data if not requested' do
+    member_pairs.each do |pair|
+      s3_cache[pair].should_not_receive(:read)
+    end
+
+    subject.members(expiry).each {|mem| :amazing}
+  end
+
+  it 'exposes object data through the :data method' do
+    m = subject.members(expiry).collect {|mem| mem.data}
+    m.should == member_pairs.collect {|p| s3_cache[p].read}
+  end
+end
+
+describe AutoConsul::Cluster::Registry::S3Provider do
+  let(:provider) { AutoConsul::Cluster::Registry::S3Provider }
+  let(:bucket) { "bucket-#{self.object_id.to_s}" }
+  let(:path) { "#{self.object_id.to_s}/foo/bar" }
+  let(:uri) { "s3://#{bucket}/#{path}" }
+
+  context 'retrieved via AutoConsul::Cluster.get_provider_for_uri' do
+    it 'should be the provider for an s3:// URL' do
+      AutoConsul::Cluster.get_provider_for_uri(uri).should be_a provider
+    end
+
+    it 'should be instantiated with the uri string as URI instance' do
+      provider.should_receive(:new).with(URI(uri))
+      AutoConsul::Cluster.get_provider_for_uri(uri)
+    end
+  end
+
+  describe 'given a URI instance' do
+    subject { provider.new URI(uri) }
+
+    it 'should get the bucket name from the URI host' do
+      subject.bucket_name.should == bucket
+    end
+
+    it 'should get the key prefix from the URI path' do
+      subject.key_prefix.should == path
+    end
+
+    it 'should get the bucket object using the bucket name and the AWS SDK' do
+      AWS::S3.stub(:new).and_return(s3 = double)
+      s3.should_receive(:buckets).with.and_return(buckets = double)
+      buckets.should_receive(:[]).with(bucket).and_return(bucket_object = double)
+      subject.bucket.should == bucket_object
+    end
+
+    context 'with a bucket' do
+      let(:bucket_object) { double }
+      let(:objects) { double }
+      let(:time) do
+        t = Time.now.utc
+        Time.utc t.year, t.month, t.day, t.hour, t.min, t.sec, 0
+      end
+      let(:expiry) { 120.to_i }
+      let(:check_time) { time - expiry }
+
+      before do
+        subject.stub(:bucket).with.and_return(bucket_object)
+        bucket_object.stub(:objects).with.and_return(objects)
+      end
+
+      describe 'the heartbeat method' do
+        let(:identity) { "#{self.object_id.to_s}-identifier" }
+        let(:stamp) { time.dup.utc.strftime('%Y%m%d%H%M%S') }
+        
+        before do
+          t = time
+          Time.stub(:now).with.and_return(t)
+        end
+
+        describe 'with no expiry' do
+          let(:expiry) { nil }
+
+          before do
+            objects.should_not_receive(:with_prefix)
+            bucket.should_not_receive(:delete_if)
+            objects.should_not_receive(:delete_if)
+            bucket.should_not_receive(:delete)
+            objects.should_not_receive(:delete)
+          end
+
+          it_should_behave_like 'a heartbeat emitter'
+        end
+
+        describe 'with an expiry' do
+          let(:expiry) { 145.to_i }
+          let(:check_time) { time.dup.utc - expiry }
+
+          let :pre_expiration do
+            double "S3Object", :key => File.join(path, "#{(check_time - 1).strftime('%Y%m%d%H%M%S')}-foo")
+          end
+
+          let :on_expiration do
+            double "S3Object", :key => File.join(path, "#{check_time.strftime('%Y%m%d%H%M%S')}-bar")
+          end
+
+          let :post_expiration do
+            double "S3Object", :key => File.join(path, "#{(check_time + 1).strftime('%Y%m%d%H%M%S')}-baz")
+          end
+
+          before do
+            objects.should_receive(:with_prefix).with(path).and_return(with_pre = double)
+            with_pre.should_receive(:delete_if) do |&block|
+              block.call(pre_expiration).should be_true
+              block.call(post_expiration).should be_false
+              block.call(on_expiration).should be_true
+            end
+          end
+
+          it_should_behave_like 'a heartbeat emitter'
+        end
+      end
+
+      describe 'and no heartbeats' do
+        before do
+          objects.should_receive(:with_prefix).with(path).and_return(collection = double)
+          # Doesn't yield, and thus is "empty".
+          collection.should_receive(:each).and_return(collection)
+        end
+      end
+
+      describe 'and heartbeats' do
+        let(:s3_cache) { {} }
+        let :deletes do
+          key_source.find_all {|pair| pair[0] <= check_time}.collect do |pair|
+            s3_cache[pair]
+          end
+        end
+
+        before do
+          with_pre = objects.should_receive(:with_prefix).with(path).and_return(with_prefix_each = double)
+          with_prefix_each = with_prefix_each.should_receive(:each).with
+          key_source.inject(with_prefix_each) do |o, pair|
+            s3_cache[pair] = double("S3Object",
+                                    :key => File.join(path, "#{pair[0].strftime('%Y%m%d%H%M%S')}-#{pair[1]}"),
+                                    :read => pair[1])
+            o.and_yield(s3_cache[pair])
+          end
+
+          with_prefix_each.and_return(with_prefix_each) if key_source.size < 1
+        end
+
+        before do
+          if deletes.size > 0
+            objects.should_receive(:delete).with(deletes)
+          else
+            objects.should_not_receive(:delete)
+          end
+        end
+
+        describe 'past expiration' do
+          let(:earliest) { (check_time - 10).utc }
+          let(:early) { (check_time - 5).utc }
+          let(:max_time) { check_time.dup.utc }
+
+          let :key_source do
+            [[earliest, 'earliest'],
+             [early, 'early'],
+             [max_time, 'expiry']]
+          end
+
+          it 'should have an empty members list' do
+            subject.members(expiry).should == []
+          end
+        end
+
+        describe 'that are live' do
+          let(:valid_early) { (check_time + 1).utc }
+          let(:valid_late) { (time - 1).utc }
+
+          describe 'only' do
+            let :key_source do
+              [[valid_early, 'both'],
+              [valid_early, 'early_only'],
+              [valid_late, 'both'],
+              [valid_late, 'late_only']]
+            end
+
+            it_should_behave_like 'has valid members', [
+                [:valid_early, 'early_only'],
+                [:valid_late, 'both'],
+                [:valid_late, 'late_only']]
+          end
+
+          describe 'mixed with expired heartbeats' do
+            let(:expired_early) { (check_time - 10).utc }
+            let(:expired_late) { check_time.dup.utc }
+
+            let :key_source do
+              [[expired_early, 'expired_and_valid'],
+               [expired_early, 'expired_early'],
+               [expired_late, 'expired_late'],
+               [expired_late, 'check_time_and_valid'],
+               [valid_early, 'both'],
+               [valid_early, 'early_only'],
+               [valid_early, 'expired_and_valid'],
+               [valid_late, 'both'],
+               [valid_late, 'check_time_and_valid'],
+               [valid_late, 'late_only']]
+            end
+
+            it_should_behave_like 'has valid members', [
+                [:valid_early, 'early_only'],
+                [:valid_early, 'expired_and_valid'],
+                [:valid_late, 'both'],
+                [:valid_late, 'check_time_and_valid'],
+                [:valid_late, 'late_only']]
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/spec-helper.rb

@@ -0,0 +1,43 @@
+require 'rspec'
+require 'fileutils'
+require 'tempfile'
+require 'auto-consul'
+
+module AutoConsulTest
+  # A wrapper for a temporary directory.
+  #
+  # While initialization will create a temporary directory, it is the
+  # caller's responsibility to clean things up.
+  class Tempdir
+    def initialize
+      @path = File.expand_path(Dir.mktmpdir)
+    end
+
+    # Helper that joins `paths` to the temporary directory for easy
+    # temporary-directory-internal path generation.
+    #
+    # Call it with no arguments to get the temporary directory itself.
+    def path(*paths)
+      if paths.size > 0
+        File.join @path, *paths
+      else
+        @path
+      end
+    end
+  end
+end
+
+module RSpec::Core::DSL
+  def tempdir_context(*args, &block)
+    describe(*args) do
+      let(:tempdir) { AutoConsulTest::Tempdir.new }
+
+      after do
+        ::FileUtils.remove_entry tempdir.path
+      end
+
+      instance_eval(&block)
+    end
+  end
+end
+