cloudfinder-ec2 0.1.0

data/spec/cloudfinder-ec2/clusterfinder_spec.rb

@@ -0,0 +1,265 @@
+describe Cloudfinder::EC2::Clusterfinder do
+
+  let (:client)       { Aws::EC2::Client.new(stub_responses: true) }
+  let (:reservations) { [] }
+  let (:cluster_name) { 'production' }
+  let (:region)       { 'some-region' }
+
+  before (:each) do
+    allow(Aws::EC2::Client).to receive(:new).and_return(client)
+  end
+
+  shared_examples_for 'cluster object response' do
+    it 'provides cluster name in returned cluster' do
+      expect(cluster.cluster_name).to eq cluster_name
+    end
+  end
+
+  shared_examples_for 'empty cluster' do
+    include_examples 'cluster object response'
+
+    it 'returns empty cluster' do
+      expect(cluster).to be_empty
+    end
+  end
+
+  shared_examples_for 'running cluster with roles' do |roles|
+    include_examples 'cluster object response'
+
+    it 'returns running cluster' do
+      expect(cluster).to be_running
+    end
+
+    it 'has only the expected cluster roles' do
+      expect(cluster.list_roles).to eq roles
+    end
+  end
+
+  shared_examples_for 'cluster with instance in role' do |role, instance_index, instance_id|
+    it "has #{role} role in cluster" do
+      expect(cluster).to have_role(role)
+    end
+
+    it "has instance #{instance_id} as #{role}:##{instance_index}" do
+      expect(cluster.list_role_instances(role)[instance_index].instance_id).to eq instance_id
+    end
+
+    it "populates #{instance_id} public IP" do
+      expect(cluster.list_role_instances(role)[instance_index].public_ip).to eq public_ip(instance_id)
+    end
+
+    it "populates #{instance_id} private IP" do
+      expect(cluster.list_role_instances(role)[instance_index].private_ip).to eq private_ip(instance_id)
+    end
+
+    it "populates #{instance_id} public DNS" do
+      expect(cluster.list_role_instances(role)[instance_index].public_dns).to eq public_dns(instance_id)
+    end
+
+    it "populates #{instance_id} private DNS" do
+      expect(cluster.list_role_instances(role)[instance_index].private_dns).to eq private_dns(instance_id)
+    end
+  end
+
+  describe '#find' do
+    let (:cluster) { subject.find(region: region, cluster_name: cluster_name) }
+
+    context 'with invalid arguments' do
+      it 'throws without region' do
+        expect { subject.find(cluster_name: cluster_name) }.to raise_error(ArgumentError)
+      end
+
+      it 'throws without cluster name' do
+        expect { subject.find(region: region) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when searching for EC2 instances' do
+      let (:client) { spy(Aws::EC2::Client) }
+
+      it 'creates AWS API client for the specified region' do
+        expect(Aws::EC2::Client).to receive(:new).with(region: 'any-region').once.and_return(client)
+        subject.find(region: 'any-region', cluster_name: cluster_name)
+      end
+
+      it 'requests details of running EC2 instances' do
+        subject.find(region: 'us-east-1', cluster_name: 'i12345678')
+        expect(client).to have_received(:describe_instances).once.with(filters: [{ name: 'instance-state-name', values: ['running'] }])
+      end
+    end
+
+    context 'when AWS API throws exceptions' do
+      it 'bubbles exceptions to caller' do
+        client.stub_responses(:describe_instances, Aws::Errors::MissingCredentialsError)
+        expect { subject.find(region: 'us-east-1', cluster_name: 'any') }.to raise_error(Aws::Errors::MissingCredentialsError)
+      end
+    end
+
+    context 'when no instances are running' do
+      before (:each) do
+        client.stub_responses(:describe_instances, reservations: [])
+      end
+
+      include_examples 'empty cluster'
+    end
+
+    context 'when one instance is running' do
+      before (:each) do
+        stub_describe_instances(stub_reservation(running_instance))
+      end
+
+      context 'with no tags' do
+        let(:running_instance) { stub_instance }
+        include_examples 'empty cluster'
+      end
+
+      context 'with irrelevant tags' do
+        let(:running_instance) { stub_instance(tags: { 'name' => 'qa-server' }) }
+        include_examples 'empty cluster'
+      end
+
+      context 'with cloudfinder-cluster tag for another cluster' do
+        let(:running_instance) { stub_instance(cluster_tag: 'another-cluster', role_tag: 'db') }
+        include_examples 'empty cluster'
+      end
+
+      context 'tagged for correct cloudfinder-cluster without cloudfinder-role' do
+        let(:running_instance) { stub_instance(cluster_tag: cluster_name, role_tag: nil) }
+        include_examples 'empty cluster'
+      end
+
+      context 'tagged for correct cloudfinder-cluster with cloudfinder-role=db' do
+        let(:running_instance) { stub_instance(id: 'i-00000001', cluster_tag: cluster_name, role_tag: 'db') }
+
+        include_examples('running cluster with roles', [:db])
+        include_examples('cluster with instance in role', :db, 0, 'i-00000001')
+      end
+    end
+
+    context 'when two instances in single reservation' do
+      before (:each) do
+        stub_describe_instances(stub_reservation(instance_1, instance_2))
+      end
+
+      context 'with only one in this cluster' do
+        let (:instance_1) { stub_instance(id: 'i-00000001', cluster_tag: cluster_name, role_tag: 'db') }
+        let (:instance_2) { stub_instance(id: 'i-00000002', cluster_tag: 'another-cluster', role_tag: 'app') }
+
+        include_examples('running cluster with roles', [:db])
+        include_examples('cluster with instance in role', :db, 0, 'i-00000001')
+      end
+
+      context 'both in this cluster with same role' do
+        let (:instance_1) { stub_instance(id: 'i-00000001', cluster_tag: cluster_name, role_tag: 'db') }
+        let (:instance_2) { stub_instance(id: 'i-00000002', cluster_tag: cluster_name, role_tag: 'db') }
+
+        include_examples('running cluster with roles', [:db])
+        include_examples('cluster with instance in role', :db, 0, 'i-00000001')
+        include_examples('cluster with instance in role', :db, 1, 'i-00000002')
+      end
+
+      context 'both in this cluster with different roles' do
+        let (:instance_1) { stub_instance(id: 'i-00000001', cluster_tag: cluster_name, role_tag: 'db') }
+        let (:instance_2) { stub_instance(id: 'i-00000002', cluster_tag: cluster_name, role_tag: 'app') }
+
+        include_examples('running cluster with roles', [:db, :app])
+        include_examples('cluster with instance in role', :db, 0, 'i-00000001')
+        include_examples('cluster with instance in role', :app, 0, 'i-00000002')
+      end
+    end
+
+    context 'when three instances in two reservations' do
+      before (:each) do
+        stub_describe_instances(
+            stub_reservation(instance_1, instance_2),
+            stub_reservation(instance_3)
+        )
+      end
+
+      context 'with only two in this cluster' do
+        let (:instance_1) { stub_instance(id: 'i-00000001', cluster_tag: 'another-cluster', role_tag: 'db') }
+        let (:instance_2) { stub_instance(id: 'i-00000002', cluster_tag: 'another-cluster', role_tag: 'app') }
+        let (:instance_3) { stub_instance(id: 'i-00000003', cluster_tag: cluster_name, role_tag: 'app') }
+
+        include_examples('running cluster with roles', [:app])
+        include_examples('cluster with instance in role', :app, 0, 'i-00000003')
+      end
+
+      context 'all in this cluster with same role' do
+        let (:instance_1) { stub_instance(id: 'i-00000001', cluster_tag: cluster_name, role_tag: 'db') }
+        let (:instance_2) { stub_instance(id: 'i-00000002', cluster_tag: cluster_name, role_tag: 'db') }
+        let (:instance_3) { stub_instance(id: 'i-00000003', cluster_tag: cluster_name, role_tag: 'db') }
+
+        include_examples('running cluster with roles', [:db])
+        include_examples('cluster with instance in role', :db, 0, 'i-00000001')
+        include_examples('cluster with instance in role', :db, 1, 'i-00000002')
+        include_examples('cluster with instance in role', :db, 2, 'i-00000003')
+      end
+
+      context 'all in this cluster with different roles' do
+        let (:instance_1) { stub_instance(id: 'i-00000001', cluster_tag: cluster_name, role_tag: 'db') }
+        let (:instance_2) { stub_instance(id: 'i-00000002', cluster_tag: cluster_name, role_tag: 'app') }
+        let (:instance_3) { stub_instance(id: 'i-00000003', cluster_tag: cluster_name, role_tag: 'cache') }
+
+        include_examples('running cluster with roles', [:db, :app, :cache])
+        include_examples('cluster with instance in role', :db, 0, 'i-00000001')
+        include_examples('cluster with instance in role', :app, 0, 'i-00000002')
+        include_examples('cluster with instance in role', :cache, 0, 'i-00000003')
+      end
+    end
+  end
+
+  def stub_describe_instances(*reservations)
+    client.stub_responses(:describe_instances, reservations: reservations)
+  end
+
+  def stub_reservation(*instances)
+    { instances: instances }
+  end
+
+  def stub_instance(args = {})
+    id       = args[:id] || 'i-00000001'
+    instance = {
+        instance_id:        id,
+        public_ip_address:  args[:public_ip] || public_ip(id), #46.137.0.1',
+        private_ip_address: args[:private_ip] || private_ip(id), #'10.248.0.1',
+        public_dns_name:    args[:public_dns] || public_dns(id), #'ec2-46-137-0-1.eu-west-1.compute.amazonaws.com',
+        private_dns_name:   args[:public_dns] || private_dns(id), #'ip-10-248-0-1.eu-west-1.compute.internal',
+        tags:               []
+    }
+    (args[:tags] || {}).each do |key, value|
+      instance[:tags] << { key: key, value: value }
+    end
+
+    if args[:cluster_tag]
+      instance[:tags] << { key: Cloudfinder::EC2::CLUSTER_TAG_NAME, value: args[:cluster_tag] }
+    end
+
+    if args[:role_tag]
+      instance[:tags] << { key: Cloudfinder::EC2::ROLE_TAG_NAME, value: args[:role_tag] }
+    end
+
+    instance
+  end
+
+  def numeric_instance_id(instance_id)
+    instance_id[-2, 2].to_i
+  end
+
+  def private_ip(instance_id)
+    "10.248.0.#{numeric_instance_id(instance_id)}"
+  end
+
+  def public_ip(instance_id)
+    "46.137.0.#{numeric_instance_id(instance_id)}"
+  end
+
+  def private_dns(instance_id)
+    "ec2-46-137-0-#{numeric_instance_id(instance_id)}.eu-west-1.compute.amazonaws.com"
+  end
+
+  def public_dns(instance_id)
+    "ip-10-248-0-#{numeric_instance_id(instance_id)}.eu-west-1.compute.internal"
+  end
+
+end

data/spec/cloudfinder-ec2/command/list_spec.rb

@@ -0,0 +1,131 @@
+describe Cloudfinder::EC2::Command::List, focus: true do
+  let (:detector)         { spy(Cloudfinder::EC2::Detector) }
+  let (:detector_result)  { { cluster_name: detected_cluster, cluster_role: 'db', region: detected_region } }
+  let (:cluster_finder)   { spy(Cloudfinder::EC2::Clusterfinder) }
+  let (:found_cluster)    { double(Cloudfinder::EC2::Cluster) }
+  let (:cluster_hash)     { { cluster_name: detected_cluster, roles: {} } }
+  let (:standard_out)     { StringIO.new }
+  let (:error_out)        { StringIO.new }
+  let (:detected_cluster) { 'qa' }
+  let (:detected_region)  { 'eu-west-1' }
+
+  subject do
+    Cloudfinder::EC2::Command::List.new(
+        cluster_finder,
+        detector,
+        standard_out,
+        error_out
+    )
+  end
+
+  before :each do
+    allow(cluster_finder).to receive(:find).and_return found_cluster
+    allow(found_cluster).to receive(:to_hash).and_return cluster_hash
+  end
+
+  shared_examples_for 'render cluster as JSON' do
+    it 'prints cluster hash to standard out as JSON' do
+      expect(JSON.parse(standard_out.string)).to eq stringify_keys(cluster_hash)
+    end
+
+    it 'prints nothing to standard error' do
+      expect(error_out.string).to eq ''
+    end
+  end
+
+  shared_examples_for 'find cluster by specified name' do |name|
+    it 'finds cluster with specified cluster name' do
+      expect(cluster_finder).to have_received(:find).with(hash_including(cluster_name: name))
+    end
+  end
+
+  shared_examples_for 'find cluster by detected name' do
+    it 'finds cluster with detected cluster name' do
+      expect(cluster_finder).to have_received(:find).with(hash_including(cluster_name: detected_cluster))
+    end
+  end
+
+  shared_examples_for 'find cluster in specified region' do |region|
+    it 'finds cluster in specified region' do
+      expect(cluster_finder).to have_received(:find).with(hash_including(region: region))
+    end
+  end
+
+  shared_examples_for 'find cluster in detected region' do
+    it 'finds cluster in detected region' do
+      expect(cluster_finder).to have_received(:find).with(hash_including(region: detected_region))
+    end
+  end
+
+
+  describe '#execute' do
+    context 'when cluster name and region are specified' do
+      before :each do
+        subject.execute(cluster_name: 'other-cluster', region: 'custom-region')
+      end
+
+      it 'does not attempt automatic cluster detection' do
+        expect(detector).not_to have_received(:detect_cluster)
+      end
+
+      include_examples('find cluster by specified name', 'other-cluster')
+      include_examples('find cluster in specified region', 'custom-region')
+      include_examples 'render cluster as JSON'
+    end
+
+    context 'when only cluster name is specified' do
+      before :each do
+        expect(detector).to receive(:detect_cluster).and_return detector_result
+        subject.execute(cluster_name: 'other-cluster')
+      end
+
+      include_examples('find cluster by specified name', 'other-cluster')
+      include_examples('find cluster in detected region')
+      include_examples 'render cluster as JSON'
+    end
+
+    context 'when region is specified and cluster name can be detected' do
+      before :each do
+        expect(detector).to receive(:detect_cluster).and_return detector_result
+        subject.execute(region: 'custom-region')
+      end
+
+      include_examples('find cluster by detected name')
+      include_examples('find cluster in specified region', 'custom-region')
+      include_examples 'render cluster as JSON'
+    end
+
+    context 'when cluster detector throws exception' do
+      before :each do
+        expect(detector).to receive(:detect_cluster).and_raise Errno::ENETUNREACH
+      end
+
+      it 'rethrows the exception' do
+        expect { subject.execute }.to raise_error Errno::ENETUNREACH
+      end
+
+      it 'prints nothing to standard out' do
+        begin
+          subject.execute rescue StandardError
+        end
+        expect(standard_out.string).to eq ''
+      end
+
+      it 'prints exception header to stderr' do
+        begin
+          subject.execute rescue StandardError
+        end
+        expect(error_out.string).to match /This instance may not be running on EC2/
+      end
+    end
+  end
+
+  def stringify_keys(hash)
+    string_hash = {}
+    hash.each do |key, value|
+      string_hash[key.to_s] = value
+    end
+    string_hash
+  end
+
+end

data/spec/cloudfinder-ec2/detector_spec.rb

@@ -0,0 +1,152 @@
+describe Cloudfinder::EC2::Detector do
+  describe '#detect' do
+    let (:ec2_client) { Aws::EC2::Client.new(stub_responses: true) }
+    let (:tags) { [] }
+
+    before (:each) do
+      allow(Aws::EC2::Client).to receive(:new).and_return(ec2_client)
+      ec2_client.stub_responses(:describe_tags, tags: tags)
+    end
+
+    context 'when instance metadata not available' do
+      it 'throws exception on timeout' do
+        allow(subject).to receive(:open).and_raise TimeoutError
+        expect { subject.detect_cluster }.to raise_error(TimeoutError)
+      end
+
+      it 'throws exception on connection refused' do
+        allow(subject).to receive(:open).and_raise Errno::ECONNREFUSED
+        expect { subject.detect_cluster }.to raise_error(Errno::ECONNREFUSED)
+      end
+
+      it 'throws exception on 404' do
+        allow(subject).to receive(:open).and_raise OpenURI::HTTPError.new('404', double('io'))
+        expect { subject.detect_cluster }.to raise_error(OpenURI::HTTPError)
+      end
+
+      it 'throws exception on network unreachable' do
+        allow(subject).to receive(:open).and_raise Errno::ENETUNREACH
+        expect { subject.detect_cluster }.to raise_error(Errno::ENETUNREACH)
+      end
+
+    end
+
+    shared_examples_for 'instance outside cluster' do
+      include_examples 'instance with metadata'
+
+      it 'returns a nil cluster name' do
+        expect(subject.detect_cluster[:cluster_name]).to be_nil
+      end
+
+      it 'returns a nil cluster role' do
+        expect(subject.detect_cluster[:cluster_name]).to be_nil
+      end
+    end
+
+    shared_examples_for 'instance with metadata' do
+      it 'returns the instance id' do
+        expect(subject.detect_cluster[:instance_id]).to eq instance_id
+      end
+
+      it 'returns the AWS region' do
+        expect(subject.detect_cluster[:region]).to eq region
+      end
+    end
+
+    context 'when instance metadata available' do
+      let (:instance_id) { 'i-00000001' }
+      let (:availability_zone) { 'eu-west-1c' }
+      let (:region) { 'eu-west-1' }
+
+      before :each do
+        stub_metadata('/placement/availability-zone', availability_zone)
+        stub_metadata('/instance-id', instance_id)
+      end
+
+      context 'when searching for EC2 instances' do
+        let (:ec2_client) { spy(Aws::EC2::Client) }
+
+        it 'creates AWS API client for the specified region' do
+          expect(Aws::EC2::Client).to receive(:new).with(region: region).once
+          subject.detect_cluster
+        end
+
+        it 'requests the tags for this instance' do
+          subject.detect_cluster
+          expect(ec2_client).to have_received(:describe_tags).once.with(filters: [{ name: 'resource-id', values: [instance_id] }])
+        end
+
+      end
+
+      context 'when AWS API throws exceptions' do
+        it 'bubbles exceptions to caller' do
+          ec2_client.stub_responses(:describe_tags, Aws::Errors::MissingCredentialsError)
+          expect { subject.detect_cluster }.to raise_error(Aws::Errors::MissingCredentialsError)
+        end
+      end
+
+      context 'when not part of cluster' do
+        context 'when instance has no tags' do
+          let (:tags) { [] }
+          include_examples 'instance outside cluster'
+        end
+
+        context 'when instance only has irrelevant tags' do
+          let (:tags) { [stub_tag('Name', 'anything')] }
+          include_examples 'instance outside cluster'
+        end
+
+        context 'when instance has no cloudfinder-cluster tag' do
+          let (:tags) { [stub_tag(Cloudfinder::EC2::ROLE_TAG_NAME, 'anything')] }
+          include_examples 'instance outside cluster'
+        end
+
+        context 'when instance has no cloudfinder-role tag' do
+          let (:tags) { [stub_tag(Cloudfinder::EC2::CLUSTER_TAG_NAME, 'anything')] }
+          include_examples 'instance outside cluster'
+        end
+      end
+
+      context 'when part of cluster' do
+        let (:cluster_name) { 'qa' }
+        let (:cluster_role) { 'app' }
+        let (:tags) { [
+            stub_tag(Cloudfinder::EC2::CLUSTER_TAG_NAME, cluster_name),
+            stub_tag(Cloudfinder::EC2::ROLE_TAG_NAME, cluster_role)
+        ] }
+
+        include_examples 'instance with metadata'
+
+        it 'returns cluster name' do
+          expect(subject.detect_cluster[:cluster_name]).to eq cluster_name
+        end
+        it 'returns cluster role' do
+          expect(subject.detect_cluster[:cluster_role]).to eq cluster_role.to_sym
+        end
+      end
+    end
+  end
+
+  def stub_metadata(path, response)
+    url     = "http://169.254.169.254/latest/meta-data#{path}"
+    timeout = Cloudfinder::EC2::Detector::EC2_METADATA_TIMEOUT
+    allow(subject).to receive(:open).with(url, { read_timeout: timeout }).and_return FakeResponse.new(response)
+  end
+
+  def stub_tag(key, value)
+    {
+        key:   key,
+        value: value
+    }
+  end
+
+  class FakeResponse
+    def initialize(body)
+      @body = body
+    end
+
+    def read
+      @body
+    end
+  end
+end