dd_spacecadet 0.2.0

data/lib/dd_spacecadet/util.rb

@@ -0,0 +1,43 @@
+# Copyright 2016 DoubleDutch, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'dd_spacecadet/config'
+
+module DoubleDutch
+  module SpaceCadet
+    # Util is a grouping of utility/helper methods
+    module Util
+      def self._lbs_client(env)
+        DoubleDutch::SpaceCadet::Config.lbs_client[env]
+      end
+
+      # method for finding an LB based on its name
+      def self.find_lb(env, search)
+        lookup = search.downcase
+        _get_lbs(env).select { |lb| lb[:name].include?(lookup) }
+      end
+
+      # get the LBs from Rackspace and parse them to the
+      # information we care about: Name & ID
+      def self._get_lbs(env)
+        _lbs_client(env).list_load_balancers.data[:body]['loadBalancers'].map do |lb|
+          {
+            name: lb['name'].downcase,
+            id: lb['id']
+          }
+        end
+      end
+    end
+  end
+end

data/lib/dd_spacecadet/version.rb

@@ -0,0 +1,19 @@
+# Copyright 2016 DoubleDutch, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module DoubleDutch
+  module SpaceCadet
+    VERSION = '0.2.0'.freeze
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# Copyright 2016 DoubleDutch, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'rspec'
+require 'dd_spacecadet'

data/spec/unit/dd_spacecadet/config_spec.rb

@@ -0,0 +1,75 @@
+# Copyright 2016 DoubleDutch, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+describe DoubleDutch::SpaceCadet::Config do
+  before do
+    allow(Fog::Compute).to receive(:new)
+      .with(
+        provider: 'rackspace',
+        rackspace_username: 'testUsername',
+        rackspace_api_key: 'abc123',
+        rackspace_region: 'DFW'
+      )
+      .and_return(:compute)
+
+    allow(Fog::Rackspace::LoadBalancers).to receive(:new)
+      .with(
+        rackspace_username: 'testUsername',
+        rackspace_api_key: 'abc123',
+        rackspace_region: 'DFW'
+      )
+      .and_return(:loadbalancers)
+  end
+
+  after do
+    allow(Fog::Compute).to receive(:new).and_call_original
+    allow(Fog::Rackspace::LoadBalancers).to receive(:new).and_call_original
+  end
+
+  describe '.register' do
+    it 'should register without error' do
+      expect do
+        DoubleDutch::SpaceCadet::Config.register(
+          'dfw-test', 'testUsername', 'abc123', 'DFW'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  describe '.servers_client' do
+    it 'should return the value of @@servers_client' do
+      expect(DoubleDutch::SpaceCadet::Config.servers_client['dfw-test2']).to be_nil
+
+      DoubleDutch::SpaceCadet::Config.register(
+        'dfw-test2', 'testUsername', 'abc123', 'DFW'
+      )
+
+      expect(DoubleDutch::SpaceCadet::Config.servers_client['dfw-test2']).to eql(:compute)
+    end
+  end
+
+  describe '.lbs_client' do
+    it 'should return the value of @@servers_client' do
+      expect(DoubleDutch::SpaceCadet::Config.lbs_client['dfw-test3']).to be_nil
+
+      DoubleDutch::SpaceCadet::Config.register(
+        'dfw-test3', 'testUsername', 'abc123', 'DFW'
+      )
+
+      expect(DoubleDutch::SpaceCadet::Config.lbs_client['dfw-test3']).to eql(:loadbalancers)
+    end
+  end
+end

data/spec/unit/dd_spacecadet/lb_spec.rb

@@ -0,0 +1,390 @@
+# Copyright 2016 DoubleDutch, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+def mock_lbs_summary
+  [
+    { name: 'test-lb01', id: 42 },
+    { name: 'test-lb02', id: 84 }
+  ]
+end
+
+def mock_lbs_resp
+  {
+    'loadBalancer' => {
+      'name' => 'test-lb01',
+      'id' => 42,
+      'nodes' => [
+        {
+          'id' => 142,
+          'address' => '10.0.0.142',
+          'condition' => 'ENABLED'
+        },
+        {
+          'id' => 184,
+          'address' => '10.0.0.184',
+          'condition' => 'ENABLED'
+        }
+      ]
+    }
+  }
+end
+
+def mock_server_data
+  {
+    body: {
+      'servers' => [
+        {
+          'name' => 'test-app01',
+          'addresses' => {
+            'private' => [
+              { 'addr' => '127.0.0.1' }
+            ]
+          }
+        },
+        {
+          'name' => 'tEst-APP02',
+          'addresses' => {
+            'private' => [
+              { 'addr' => '127.0.0.2' }
+            ]
+          }
+        }
+      ]
+    }
+  }
+end
+
+def mock_healthy_status
+  [
+    {
+      name: 'test-lb01',
+      id: 42,
+      nodes_enabled: 2,
+      nodes: [
+        {
+          name: 'test-app01',
+          ip: '10.0.0.142',
+          id: 142,
+          condition: 'ENABLED'
+        },
+        {
+          name: 'test-app02',
+          ip: '10.0.0.142',
+          id: 142,
+          condition: 'ENABLED'
+        }
+      ]
+    },
+    {
+      name: 'test-lb02',
+      id: 84,
+      nodes_enabled: 2,
+      nodes: [
+        {
+          name: 'test-app01',
+          ip: '10.0.0.142',
+          id: 242,
+          condition: 'ENABLED'
+        },
+        {
+          name: 'test-app02',
+          ip: '10.0.0.142',
+          id: 284,
+          condition: 'ENABLED'
+        }
+      ]
+    }
+  ]
+end
+
+def mock_draining_status
+  [
+    {
+      name: 'test-lb01',
+      id: 42,
+      nodes_enabled: 1,
+      nodes: [
+        {
+          name: 'test-app01',
+          ip: '10.0.0.142',
+          id: 142,
+          condition: 'ENABLED'
+        },
+        {
+          name: 'test-app02',
+          ip: '10.0.0.142',
+          id: 142,
+          condition: 'DRAINING'
+        }
+      ]
+    },
+    {
+      name: 'test-lb02',
+      id: 84,
+      nodes_enabled: 1,
+      nodes: [
+        {
+          name: 'test-app01',
+          ip: '10.0.0.142',
+          id: 242,
+          condition: 'ENABLED'
+        },
+        {
+          name: 'test-app02',
+          ip: '10.0.0.142',
+          id: 284,
+          condition: 'DRAINING'
+        }
+      ]
+    }
+  ]
+end
+
+describe DoubleDutch::SpaceCadet::LB do
+  before do
+    allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:get_lbs).and_return(mock_lbs_summary)
+  end
+  after do
+    allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:get_lbs).and_call_original
+  end
+
+  let(:env) { 'test-env' }
+  let(:lb_i) { DoubleDutch::SpaceCadet::LB.new(env) }
+
+  describe '.new' do
+    it 'should set the environment and lbs instance variables' do
+      i = DoubleDutch::SpaceCadet::LB.new(env)
+      expect(i).not_to be_nil
+      expect(i.env).to eql('test-env')
+      expect(i.lbs).to eql([])
+    end
+  end
+
+  describe '.find_lb' do
+    before do
+      allow(DoubleDutch::SpaceCadet::Util).to receive(:_get_lbs).with(env)
+        .and_return(mock_lbs_summary)
+    end
+
+    after { allow(DoubleDutch::SpaceCadet::Util).to receive(:_get_lbs).and_call_original }
+
+    it 'should find all load balancers containing the search string' do
+      r = lb_i.find_lb('lb')
+      expect(r.size).to eql(2)
+
+      expect(r[0][:name]).to eql('test-lb01')
+      expect(r[0][:id]).to eql(42)
+
+      expect(r[1][:name]).to eql('test-lb02')
+      expect(r[1][:id]).to eql(84)
+    end
+
+    it 'should return an empty array for a non-matching value' do
+      expect(lb_i.find_lb('RANDOM_NOT_FOUND_STRING')).to be_empty
+    end
+  end
+
+  describe '.find_lb_and_use' do
+    before do
+      allow(DoubleDutch::SpaceCadet::Util).to receive(:_get_lbs).with(env)
+        .and_return(mock_lbs_summary)
+    end
+
+    after { allow(DoubleDutch::SpaceCadet::Util).to receive(:_get_lbs).and_call_original }
+
+    it 'should find all load balancers containing the search string and add them' do
+      i = DoubleDutch::SpaceCadet::LB.new(env)
+      r = i.find_lb_and_use('lb')
+      expect(r.size).to eql(2)
+
+      expect(r[0][:name]).to eql('test-lb01')
+      expect(r[0][:id]).to eql(42)
+
+      expect(r[1][:name]).to eql('test-lb02')
+      expect(r[1][:id]).to eql(84)
+
+      expect(i.lbs.size).to eql(2)
+      expect(i.lbs[0]).to eql(r[0][:id])
+      expect(i.lbs[1]).to eql(r[1][:id])
+    end
+  end
+
+  describe '.add_lb' do
+    it 'should add the LB ID to the list of LBs' do
+      i = DoubleDutch::SpaceCadet::LB.new(env)
+
+      r = i.add_lb(42)
+      expect(r.size).to eql(1)
+      expect(r[0]).to eql(42)
+
+      r = i.add_lb(84)
+      expect(r.size).to eql(2)
+      expect(r[0]).to eql(42)
+      expect(r[1]).to eql(84)
+    end
+
+    it 'should not allow duplicate entries' do
+      i = DoubleDutch::SpaceCadet::LB.new(env)
+
+      r = i.add_lb(42)
+      expect(r.size).to eql(1)
+      expect(r[0]).to eql(42)
+
+      r = i.add_lb(84)
+      expect(r.size).to eql(2)
+      expect(r[0]).to eql(42)
+      expect(r[1]).to eql(84)
+
+      r = i.add_lb(42)
+      expect(r.size).to eql(2)
+      expect(r[0]).to eql(42)
+      expect(r[1]).to eql(84)
+    end
+  end
+
+  describe '.status' do
+    before do
+      client_resp = double('ClientResponse', data: mock_server_data)
+      client = double('Client', list_servers: client_resp)
+      client_hash = { env => client }
+
+      allow(DoubleDutch::SpaceCadet::Config).to receive(:servers_client)
+        .and_return(client_hash)
+
+      allow(DoubleDutch::SpaceCadet::NodeIP).to receive(:get_name_for).with(
+        env, '10.0.0.142'
+      ).and_return('test-app01')
+
+      allow(DoubleDutch::SpaceCadet::NodeIP).to receive(:get_name_for).with(
+        env, '10.0.0.184'
+      ).and_return('test-app02')
+
+      allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:get_lb_details)
+        .with(42)
+        .and_return(mock_lbs_resp)
+    end
+
+    after do
+      allow(DoubleDutch::SpaceCadet::NodeIP).to receive(:get_name_for).and_call_original
+      allow(DoubleDutch::SpaceCadet::NodeIP).to receive(:get_lb_details).and_call_original
+      allow(DoubleDutch::SpaceCadet::Config).to receive(:servers_client).and_call_original
+      allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:get_lb_details).and_call_original
+    end
+
+    let(:lb_i) do
+      i = DoubleDutch::SpaceCadet::LB.new(env)
+      expect(i.add_lb(42)).to eql([42])
+      i
+    end
+
+    it 'should include the name, ID, and enabled nodes count of the load balancer' do
+      r = lb_i.status
+      expect(r).to be_an(Array)
+      expect(r.size).to eql(1)
+
+      expect(r[0][:name]).to eql('test-lb01')
+      expect(r[0][:id]).to eql(42)
+    end
+
+    it 'should include all backend nodes, their names, and their statuses' do
+      r = lb_i.status
+      expect(r).to be_an(Array)
+      expect(r.size).to eql(1)
+
+      expect(r[0][:nodes]).to be_an(Array)
+      expect(r[0][:nodes].size).to eql(2)
+
+      expect(r[0][:nodes][0][:name]).to eql('test-app01')
+      expect(r[0][:nodes][0][:id]).to eql(142)
+      expect(r[0][:nodes][0][:ip]).to eql('10.0.0.142')
+      expect(r[0][:nodes][0][:condition]).to eql('ENABLED')
+
+      expect(r[0][:nodes][1][:name]).to eql('test-app02')
+      expect(r[0][:nodes][1][:id]).to eql(184)
+      expect(r[0][:nodes][1][:ip]).to eql('10.0.0.184')
+      expect(r[0][:nodes][1][:condition]).to eql('ENABLED')
+    end
+  end
+
+  describe '.update_node' do
+    before do
+      allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:status)
+        .and_return(mock_healthy_status)
+    end
+
+    after do
+      allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:status).and_call_original
+    end
+
+    let(:lb_i) do
+      i = DoubleDutch::SpaceCadet::LB.new(env)
+      expect(i.add_lb(42)).to eql([42])
+      expect(i.add_lb(84)).to eql([42, 84])
+      i
+    end
+
+    context 'input validation' do
+      before do
+        allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:flush_updates)
+          .and_return(nil)
+      end
+
+      after do
+        allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:flush_updates)
+          .and_call_original
+      end
+
+      it 'should only allow the :draining and :enabled conditions' do
+        expect { lb_i.update_node('test-app01', :enabled) }.not_to raise_error
+        expect { lb_i.update_node('test-app01', :draining) }.not_to raise_error
+        expect { lb_i.update_node('test-app01', :invalid) }.to raise_error(ArgumentError)
+      end
+
+      it 'should raise if the node was not found on all LBs' do
+        expect { lb_i.update_node('test-app', :enabled) }.to raise_error(DoubleDutch::SpaceCadet::LBInconsistentState)
+      end
+    end
+
+    context 'when normal' do
+      before do
+        @lbs_client = double('Fog::Rackspace::LoadBalancers', update_node: nil)
+        allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:lbs_client)
+          .and_return(@lbs_client)
+      end
+
+      it 'should allow setting the node to drain on all LBs if no others are' do
+        expect(@lbs_client).to receive(:update_node)
+          .with(42, 142, condition: 'DRAINING').and_return(nil)
+
+        expect(@lbs_client).to receive(:update_node)
+          .with(84, 242, condition: 'DRAINING')
+
+        lb_i.update_node('test-app01', :draining)
+      end
+    end
+
+    context 'when already draining' do
+      before do
+        allow_any_instance_of(DoubleDutch::SpaceCadet::LB).to receive(:status)
+          .and_return(mock_draining_status)
+      end
+
+      it 'should actively prevent you from draining multiple backends' do
+        expect { lb_i.update_node('test-app01', :draining) }.to raise_error(DoubleDutch::SpaceCadet::LBUnsafe)
+      end
+    end
+  end
+end