dd_spacecadet 0.2.0

data/README.md

@@ -0,0 +1,49 @@
+# SpaceCadet
+SpaceCadet is a library written in Ruby for interacting with the Rackspace Cloud Load Balancers.
+The library itself uses the `fog` gem, which is a very popular Ruby library for interacting with
+all of the different cloud providers (including Rackspace).
+
+## License
+SpaceCadet is released under the [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) license. See the [LICENSE](https://github.com/doubledutch/spacecadet/blob/master/LICENSE) file for full the full details of the license.
+
+## Why SpaceCadet?
+Because this library is meant to speed up deploys, and it's a little "special"...
+
+It's not meant to be pretty, clean, or re-usable. This library was written with one purpose in mind:
+being able to change a single backend node from `ENABLED` to `DRAINING` within multiple LBs.
+
+Also: `(Rack)space`.
+
+## Including in Gemfile
+
+```Ruby
+gem 'dd_spacecadet', git: 'git@ddgit.me:EngOps/spacecadet.git'
+```
+
+## Usage
+Here's an example of using the library while interacting with the `DFW` region:
+
+```Ruby
+require 'dd_spacecadet'
+
+env = 'dfw-prod'
+region = 'DFW'
+
+DoubleDutch::SpaceCadet::Config.register(
+  env, ENV['RS_CLOUD_USERNAME'], ENV['RS_CLOUD_KEY'], region
+)
+
+dfw_prod = DoubleDutch::SpaceCadet::LB.new(env)
+
+# search for an LB by its label, in this example "prod-lb"
+# if multiple LBs match it will use *ALL* of them
+dfw_prod.find_lb_and_use('prod-lb')
+
+# gets the status of each LB and its nodes
+# you can use dfw.print_status to print the info to stdout with formatting
+dfw.status
+
+dfw.update_node('node01', :draining)
+
+dfw.update_node('node01', :enabled)
+```

data/Rakefile

@@ -0,0 +1,31 @@
+# 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 'rubocop/rake_task'
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'Run RuboCop'
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.options = %w(-D)
+  t.fail_on_error = true
+  t.patterns = %w(
+    Rakefile Gemfile *.gemspec
+    lib/**/*.rb spec/**/*.rb
+  )
+end
+
+task default: [:rubocop, :spec]

data/dd_spacecadet.gemspec

@@ -0,0 +1,40 @@
+# 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.
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+
+require 'dd_spacecadet/version'
+
+Gem::Specification.new do |s|
+  s.name                  = 'dd_spacecadet'
+  s.summary               = 'Library for manipulating Rackspace Cloud Load Balancers'
+  s.author                = 'DoubleDutch Engineering Operations'
+  s.email                 = 'engops@doubledutch.me'
+  s.license               = 'Apache 2.0'
+  s.version               = DoubleDutch::SpaceCadet::VERSION
+  s.required_ruby_version = '~> 2.3'
+  s.date                  = Time.now.strftime('%Y-%m-%d')
+  s.homepage              = 'https://github.com/DoubleDutch/spacecadet'
+  s.description           = 'Rubygem for safely managing Rackspace Cloud Load Balancer backend servers'
+
+  s.test_files            = `git ls-files spec/*`.split
+  s.files                 = `git ls-files`.split
+
+  s.add_development_dependency 'rake', '~> 11.2.2'
+  s.add_development_dependency 'rspec', '~> 3.5.0'
+  s.add_development_dependency 'rubocop', '~> 0.42.0'
+  s.add_development_dependency 'irbtools', '~> 2.0.1'
+
+  s.add_runtime_dependency 'fog', '~> 1.38.0'
+end

data/lib/dd_spacecadet.rb

@@ -0,0 +1,27 @@
+# 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/version'
+require 'dd_spacecadet/util'
+require 'dd_spacecadet/error'
+require 'dd_spacecadet/config'
+require 'dd_spacecadet/node_ip'
+require 'dd_spacecadet/lb'
+
+# DoubleDutch is the top-level module for
+# internal DoubleDutch modules and classes
+module DoubleDutch
+  # SpaceCadet is a module for configuring the Rackspace Cloud Load Balancers
+  module SpaceCadet; end
+end

data/lib/dd_spacecadet/config.rb

@@ -0,0 +1,57 @@
+# 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 'fog'
+
+module DoubleDutch
+  module SpaceCadet
+    # Class Config is used to configure a client for a specific Rackspace account
+    # You provide the `env`, usually for format is <geo>-<env> (e.g., dfw-prod)
+    class Config
+      @@servers_client = {}
+      @@lbs_client = {}
+
+      class << self
+        def register(env, username, key, region)
+          # init servers_client if it is nil
+          @@servers_client[env] ||= Fog::Compute.new(
+            provider: 'rackspace',
+            rackspace_username: username,
+            rackspace_api_key: key,
+            rackspace_region: region
+          )
+
+          # init lbs_client if it is nil
+          @@lbs_client[env] ||= Fog::Rackspace::LoadBalancers.new(
+            rackspace_username: username,
+            rackspace_api_key: key,
+            rackspace_region: region
+          )
+        end
+
+        # DoubleDutch::SpaceCadet::Config.servers.client
+        # returns @@servers_client
+        def servers_client
+          @@servers_client
+        end
+
+        # DoubleDutch::SpaceCadet::Config.lbs.client
+        # returns @@lbs_client
+        def lbs_client
+          @@lbs_client
+        end
+      end
+    end
+  end
+end

data/lib/dd_spacecadet/error.rb

@@ -0,0 +1,24 @@
+# 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
+    class Error < StandardError; end
+    class ServerNotFound < DoubleDutch::SpaceCadet::Error; end
+    class LBNotFound < DoubleDutch::SpaceCadet::Error; end
+    class LBInconsistentState < DoubleDutch::SpaceCadet::Error; end
+    class LBUnsafe < DoubleDutch::SpaceCadet::Error; end
+    class MalformedNodeObject < DoubleDutch::SpaceCadet::Error; end
+  end
+end

data/lib/dd_spacecadet/lb.rb

@@ -0,0 +1,194 @@
+# 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/error'
+require 'dd_spacecadet/util'
+
+module DoubleDutch
+  module SpaceCadet
+    # LB is the class used for manging the Load Balancer configs
+    class LB
+      attr_reader :env, :lbs
+
+      def initialize(env)
+        @env = env
+        @lbs = []
+      end
+
+      # reset the class (clear the added LBs)
+      def reset
+        @lbs.clear
+      end
+
+      # add an LB, by ID, to be managed by this class
+      def add_lb(lb_id)
+        @lbs = (@lbs << lb_id).uniq
+      end
+
+      # find an LB using a search string
+      def find_lb(search)
+        DoubleDutch::SpaceCadet::Util.find_lb(@env, search)
+      end
+
+      # the same as find_lb, but it adds each to the classs
+      def find_lb_and_use(search)
+        find_lb(search).each { |lb| add_lb(lb[:id]) }
+      end
+
+      # gets the status of managed LBs
+      def status
+        details = @lbs.map { |lb_id| get_lb_details(lb_id) }
+
+        parse_lb_details(details)
+      end
+
+      # updates the condition of a node with the Load Balancer
+      # this is used to move from :enabled => :draining
+      def update_node(name, condition)
+        # check whether the condition is valid
+        unless [:enabled, :draining].include?(condition)
+          raise ArgumentError, 'Invalid condition (can be :enabled or :draining)'
+        end
+
+        lb_details = status
+
+        raise LoadBalancerNotFound, 'No LB details found!' if lb_details.empty?
+
+        to_update = calculate_update(name.downcase, lb_details, condition)
+
+        if to_update.size != lb_details.size
+          raise LBInconsistentState, "We only found #{to_update.size} nodes across #{lb_details.size} LBs"
+        end
+
+        flush_updates(to_update)
+      end
+
+      # this does the same thing as status
+      # put it prints it the information to stdout
+      def render_status
+        status.each do |st|
+          puts "#{st[:name]} (#{st[:id]})"
+          st[:nodes].each { |n| puts "    #{n[:name]}    #{n[:condition]}    #{n[:id]}    #{n[:ip]}" }
+          puts '---'
+        end
+
+        nil
+      end
+
+      private
+
+      def lbs_client
+        DoubleDutch::SpaceCadet::Config.lbs_client[@env]
+      end
+
+      def get_lb_details(lb_id)
+        lbs_client.get_load_balancer(lb_id).data[:body]
+      end
+
+      def flush_updates(to_update)
+        to_update.each do |update|
+          flush_update(update)
+        end
+      end
+
+      # safety check before taking actions
+      # this makes sure we cannot set more than one node to draining
+      def safe?(lbd, condition)
+        # if it's a draining operation
+        # check for safety
+        if condition == :draining
+          # this inverts the result of the boolean statement
+          # if these conditions are met, we are *NOT* safe
+          # if there is onle one mode enabled: NOT SAFE
+          # if any node is disabled/draining: NOT SAFE
+          return !(lbd[:nodes_enabled] == 1 || lbd[:nodes_enabled] != lbd[:nodes].size)
+        end
+
+        # otherwise, it's safe
+        true
+      end
+
+      # calculate which node IDs need to be updated
+      def calculate_update(name, details, condition)
+        to_update = []
+
+        # loop over the individual load balancers
+        details.each do |lbd|
+          # make sure this LB is in a safe state to mutate
+          unless safe?(lbd, condition)
+            raise LBUnsafe, "#{lbd[:name]} LB unsafe for draining"
+          end
+
+          # loop over the registered nodes to find the ID
+          # of the one we want to update the condition of
+          lbd[:nodes].each do |lbn|
+            to_update << { lb_id: lbd[:id], node_id: lbn[:id], condition: condition } if lbn[:name] == name
+          end
+        end
+
+        to_update
+      end
+
+      def flush_update(update)
+        call_update(update)
+      # immediately after updating an LB config, Rackspace marks the LB
+      # as being immutable (meaning no further config changes can happen)
+      # this exception below is what is thrown by Fog if we hit that situation
+      rescue Fog::Rackspace::LoadBalancers::ServiceError
+        # the LB is currently marked as being immutable
+        # wait N arbitrary seconds before trying again
+        sleep(5)
+        call_update(update)
+      end
+
+      def call_update(update)
+        lbs_client.update_node(
+          update[:lb_id],
+          update[:node_id],
+          condition: update[:condition].to_s.upcase
+        )
+      end
+
+      def parse_lb_details(details)
+        details.map do |lb|
+          detail = {
+            name: lb['loadBalancer']['name'].downcase,
+            id: lb['loadBalancer']['id']
+          }
+
+          detail[:nodes], detail[:nodes_enabled] = parse_nodes(lb['loadBalancer']['nodes'])
+
+          detail
+        end
+      end
+
+      def parse_nodes(nodes)
+        enabled_count = 0
+
+        n = nodes.map do |node|
+          enabled_count += 1 if node['condition'].casecmp('enabled').zero?
+
+          {
+            name: DoubleDutch::SpaceCadet::NodeIP.get_name_for(@env, node['address']),
+            ip: node['address'],
+            id: node['id'],
+            condition: node['condition']
+          }
+        end
+
+        [n.sort { |x, y| x[:name] <=> y[:name] }, enabled_count]
+      end
+    end
+  end
+end

data/lib/dd_spacecadet/node_ip.rb

@@ -0,0 +1,104 @@
+# 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/error'
+require 'dd_spacecadet/config'
+
+module DoubleDutch
+  module SpaceCadet
+    # NodeIP is a class of helper methods to find a node
+    # based on its name or IP address
+    class NodeIP
+      # internal data structures
+      @@nodes_by_name = {}
+      @@nodes_by_ip = {}
+
+      class << self
+        # get the IP address for a node
+        # based on its label (name)
+        def get_ip_for(env, name)
+          refresh_nodes(env)
+
+          ip = @@nodes_by_name.dig(env, name)
+
+          raise ServerNotFound, "unable to locate #{name} in #{env} data" if ip.nil?
+
+          ip
+        end
+
+        # get the label (name) for a node
+        # based on its IP address
+        def get_name_for(env, ip)
+          refresh_nodes(env)
+
+          name = @@nodes_by_ip.dig(env, ip)
+
+          raise ServerNotFound, "unable to locate #{ip} in #{env} data" if name.nil?
+
+          name
+        end
+
+        # clear flushes all cached data
+        def clear(env)
+          @@nodes_by_name.delete(env)
+          @@nodes_by_ip.delete(env)
+        end
+
+        private
+
+        # if any of the internal structures are nil or empty
+        # we should probably try to do an update
+        def needs_refresh?(env)
+          (@@nodes_by_name[env].nil? || @@nodes_by_name[env].empty?) ||
+            (@@nodes_by_ip[env].nil? || @@nodes_by_ip[env].empty?)
+        end
+
+        # this gets the details of the nodes we care about:
+        # name and IP
+        def get_details(server)
+          priv_addresses = server.dig('addresses', 'private')
+
+          raise MailformedNodeObject, 'Node missing private addresses' if priv_addresses.nil? || priv_addresses.empty?
+
+          [server['name'].downcase, priv_addresses[0]['addr']]
+        end
+
+        # refresh the information we have by pulling down a listing of all
+        # nodes from Rackspace
+        def refresh_nodes(env)
+          # only refresh if a refresh is needed
+          if needs_refresh?(env)
+            # get an Array of all of the servers
+            servers = DoubleDutch::SpaceCadet::Config.servers_client[env].list_servers.data[:body]['servers']
+
+            # hbn: HashByName
+            # hbi: HashByIp
+            hbn = {}
+            hbi = {}
+
+            servers.each do |server|
+              name, ip = get_details(server)
+
+              hbn[name] = ip
+              hbi[ip] = name
+            end
+
+            @@nodes_by_name[env] = hbn
+            @@nodes_by_ip[env] = hbi
+          end
+        end
+      end
+    end
+  end
+end