knife-rackspace-load-balancer 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 HowAboutWe
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,28 @@
+==Setup
+Add region to your knife configuration:
+  #knife.rb
+  knife[:rackspace_api_region] = "ord"
+
+==Commands
+List:
+  bundle exec knife rackspace load balancer list
+
+Show:
+  bundle exec knife rackspace load balancer show <load_balancer_id>
+  bundle exec knife rackspace load balancer show <load_balancer_id> <load_balancer_id> --resolve-node-names
+
+Create:
+  bundle exec knife rackspace load balancer create "some.site.com" --port 80 --node-port 80 --add-nodes-by-name "app1,app2" --algorithm RANDOM
+
+Delete:
+  bundle exec knife rackspace load balancer delete <load_balancer_id>
+
+Add Node:
+  bundle exec knife rackspace load balancer add node --by-name "app1" --port 80 --only "<load_balancer_id>,<load_balancer_id>"
+  bundle exec knife rackspace load balancer add node --by-name "app1,app2" --auto-resolve-port --except "<load_balancer_id>"
+
+Delete Node:
+  bundle exec knife rackspace load balancer delete node --by-search "chef_environment:staging AND name:staging-app" --all
+
+== Copyright
+Copyright (c) 2012 HowAboutWe. See LICENSE.txt for further details.

data/knife-rackspace-load-balancer.gemspec

@@ -0,0 +1,18 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name = "knife-rackspace-load-balancer"
+  s.version = Knife::Rackspace::LoadBalancer::VERSION
+  s.authors = ["Matthew Vermaak"]
+  s.email = "dev@howaboutwe.com"
+  s.summary = "Rackspace cloud load balancer support for knife"
+  s.description = "A gem to extend knife-rackspace allowing cloud load balancer management."
+  s.homepage = "http://github.com/howaboutwe/knife-rackspace-load-balancer"
+  s.licenses = ["MIT"]
+  s.files = `git ls-files`.split("\n")
+  s.add_dependency "chef", "~> 0.10.8"
+  s.add_dependency "knife-rackspace", "~> 0.5.12"
+  s.add_dependency "cloudlb", "~> 0.1.0"
+  s.require_paths = ["lib"]
+end

data/lib/chef/knife/rackspace_load_balancer_add_node.rb

@@ -0,0 +1,161 @@
+require 'chef/knife'
+require 'chef/knife/rackspace_base'
+require 'chef/knife/rackspace_load_balancer_base'
+require 'chef/knife/rackspace_load_balancer_nodes'
+require 'cloudlb'
+
+module KnifePlugins
+  class RackspaceLoadBalancerAddNode < Chef::Knife
+    include Chef::Knife::RackspaceBase
+    include Chef::Knife::RackspaceLoadBalancerBase
+    include Chef::Knife::RackspaceLoadBalancerNodes
+
+    banner "knife rackspace load balancer add node (options)"
+
+    option :force,
+      :long => "--force",
+      :description => "Skip user input"
+
+    option :all,
+      :long => "--all",
+      :description => "Add to all load balancers"
+
+    option :except,
+      :long => "--except \"ID[,ID]\"",
+      :description => "Comma deliminated list of load balancer ids to omit (Implies --all)"
+
+    option :only,
+      :long => "--only \"ID[,ID]\"",
+      :description => "Comma deliminated list of load balancer ids to add to"
+
+    option :port,
+      :long => "--port PORT",
+      :description => "Add node listening to this port [DEFAULT: 80]",
+      :default => "80"
+
+    option :condition,
+      :long => "--condition CONDITION",
+      :description => "Add node in this condition [DEFAULT: ENABLED]",
+      :default => "ENABLED"
+
+    option :weight,
+      :long => "--weight WEIGHT",
+      :description => "Add node with this weight [DEFAULT: 1]",
+      :default => "1"
+
+    option :by_name,
+      :long => "--by-name \"NAME[,NAME]\"",
+      :description => "Resolve names against chef server to produce list of nodes to add"
+
+    option :by_private_ip,
+      :long => "--by-private-ip \"IP[,IP]\"",
+      :description => "List of nodes given by private ips to add"
+
+    option :by_search,
+      :long => "--by-search SEARCH",
+      :description => "Resolve search against chef server to produce list of nodes to add"
+
+    option :auto_resolve_port,
+      :long => "--auto-resolve-port",
+      :description => "Auto resolve port of node addition"
+
+    def run
+      unless [:all, :except, :only].any? {|target| not config[target].nil?}
+        ui.fatal("Must provide a target set of load balancers with --all, --except, or --only")
+        show_usage
+        exit 1
+      end
+
+      unless [:by_name, :by_private_ip, :by_search].any? {|addition| not config[addition].nil?}
+        ui.fatal("Must provide a set of additional nodes with --by-name, --by-private-ip, or --by-search")
+        show_usage
+        exit 2
+      end
+
+      node_ips = resolve_node_ips_from_config({
+        :by_search     => config[:by_search],
+        :by_name       => config[:by_name],
+        :by_private_ip => config[:by_private_ip]
+      })
+
+      nodes = node_ips.map do |ip|
+        {
+          :address => ip,
+          :port => config[:auto_resolve_port] ? "Auto resolve" : config[:port],
+          :condition => config[:condition],
+          :weight => config[:weight]
+        }
+      end
+
+      if nodes.empty?
+        ui.fatal("Node resolution did not provide a set of nodes for addition")
+        exit 3
+      end
+
+      target_load_balancers = lb_connection.list_load_balancers
+
+      if config[:only]
+        only = config[:only].split(",").map(&:to_s)
+        target_load_balancers = target_load_balancers.select {|lb| only.include? lb[:id].to_s}
+      end
+
+      if config[:except]
+        except = config[:except].split(",").map(&:to_s)
+        target_load_balancers = target_load_balancers.reject {|lb| except.include? lb[:id].to_s}
+      end
+
+      if target_load_balancers.empty?
+        ui.fatal("Load balancer resolution did not provide a set of target load balancers")
+        exit 4
+      end
+
+      ui.output(format_for_display({
+        :targets => target_load_balancers.map {|lb| lb[:name]},
+        :nodes => nodes
+      }))
+
+      unless config[:force]
+        ui.confirm("Do you really want to add these nodes")
+      end
+
+      target_load_balancers.each do |lb|
+        begin
+          ui.output("Opening #{lb[:name]}")
+          balancer = lb_connection.get_load_balancer(lb[:id])
+          lb_nodes = balancer.list_nodes
+          lb_node_ips = lb_nodes.map {|lbn| lbn[:address]}
+
+          if config[:auto_resolve_port]
+            nodes_for_balancer = nodes.dup
+
+            port = lb_nodes.first[:port]
+            ui.output(ui.color("Auto resolved port to: #{port}", :cyan))
+
+            nodes_for_balancer.each do |nfb|
+              nfb[:port] = port
+            end
+          else
+            nodes_for_balancer = nodes
+          end
+
+          nodes_for_balancer.each do |node|
+            if lb_node_ips.include?(node[:address])
+              ui.warn("Skipping node #{node[:address]}")
+            else
+              ui.output("Adding node #{node[:address]}")
+              if balancer.create_node(node)
+                ui.output(ui.color("Success", :green))
+              else
+                ui.output(ui.color("Failed", :red))
+              end
+            end
+          end
+        rescue CloudLB::Exception::Other => e
+          ui.error("Failed on #{lb[:name]}: CloudLB::Exception [#{e.class.name}] - #{e.message}")
+        end
+      end
+
+      ui.output(ui.color("Complete", :green))
+    end
+  end
+end

data/lib/chef/knife/rackspace_load_balancer_base.rb

@@ -0,0 +1,26 @@
+class Chef
+  class Knife
+    module RackspaceLoadBalancerBase
+      def self.included(base)
+        base.class_eval do
+          option :rackspace_api_region,
+            :short => "-R REGION",
+            :long => "--rackspace-api-region REGION",
+            :description => "Your rackspace API region. IE: ord, dfw",
+            :proc => Proc.new {|region| Chef::Config[:knife][:rackspace_api_region] = region}
+        end
+      end
+      def rackspace_api_credentials
+        {
+          :username => Chef::Config[:knife][:rackspace_api_username],
+          :api_key => Chef::Config[:knife][:rackspace_api_key],
+          :region => Chef::Config[:knife][:rackspace_api_region]
+        }
+      end
+
+      def lb_connection
+        @lb_connection ||= CloudLB::Connection.new(rackspace_api_credentials)
+      end
+    end
+  end
+end

data/lib/chef/knife/rackspace_load_balancer_create.rb

@@ -0,0 +1,124 @@
+require 'chef/knife'
+require 'chef/knife/rackspace_base'
+require 'chef/knife/rackspace_load_balancer_base'
+require 'chef/knife/rackspace_load_balancer_nodes'
+require 'cloudlb'
+
+module KnifePlugins
+  class RackspaceLoadBalancerCreate < Chef::Knife
+    include Chef::Knife::RackspaceBase
+    include Chef::Knife::RackspaceLoadBalancerBase
+    include Chef::Knife::RackspaceLoadBalancerNodes
+
+    banner "knife rackspace load balancer create NAME (options)"
+
+    option :force,
+      :long => "--force",
+      :description => "Skip user input"
+
+    option :protocol,
+      :long => "--protocol PROTOCOL",
+      :description => "The protocol to balance [Default: HTTP]",
+      :default => "HTTP"
+
+    option :add_nodes_by_search,
+      :long => "--add-nodes-by-search SEARCH",
+      :description => "Node search query resolved by Chef Server to add"
+
+    option :add_nodes_by_private_ip,
+      :long => "--add-nodes-by-private-ip \"IP[,IP]\"",
+      :description => "Comma deliminated list of private ips to add"
+
+    option :add_nodes_by_name,
+      :long => "--add-nodes-by-name \"NAME[,NAME]\"",
+      :description => "Comma deliminated list of node names resolved by Chef Server to add"
+
+    option :node_port,
+      :long => "--node-port PORT",
+      :description => "Add nodes listening to this port DEFAULT: 80",
+      :default => "80"
+
+    option :node_weight,
+      :long => "--node-weight WEIGHT",
+      :description => "Add nodes with this weight",
+      :default => "1"
+
+    option :node_condition,
+      :long => "--node-condition CONDITION",
+      :description => "Add nodes with this condition",
+      :default => "ENABLED"
+
+    option :port,
+      :long => "--port PORT",
+      :description => "Configure the load balancer to listen to this port DEFAULT: 80",
+      :default => "80"
+
+    option :algorithm,
+      :long => "--algorithm ALGORITHM",
+      :description => "The algorithm to employ for load balancing [Defualt: RANDOM]",
+      :default => "RANDOM"
+
+    option :virtual_ip_ids,
+      :long => "--virtual-ip-id \"ID[,ID]\"",
+      :description => "Comma deliminated list of virtual ip ids"
+
+    option :virtual_ip_type,
+      :long => "--virtual-ip-type TYPE",
+      :description => "Type of virtual IP to obtain [DEFAULT: PUBLIC]",
+      :default => "PUBLIC"
+
+
+
+    def run
+      if @name_args.first.nil?
+        ui.fatal("Must provide name")
+        show_usage
+        exit 1
+      end
+
+      unless [:add_nodes_by_search, :add_nodes_by_name, :add_nodes_by_private_ip].any? {|addition| not config[addition].nil?}
+        ui.fatal("Must provide nodes via --add-nodes-by-search, --add-nodes-by-node-name, or --add-nodes-by-private-ip")
+        show_usage
+        exit 2
+      end
+
+      node_ips = resolve_node_ips_from_config({
+        :by_search     => config[:add_nodes_by_search],
+        :by_name       => config[:add_nodes_by_name],
+        :by_private_ip => config[:add_nodes_by_private_ip]
+      })
+
+      nodes = node_ips.map do |ip|
+        {
+          :address => ip,
+          :port => config[:node_port],
+          :condition => config[:node_condition],
+          :weight => config[:node_weight]
+        }
+      end
+
+      load_balancer_configuration = {
+        :name => @name_args.first,
+        :protocol => config[:protocol],
+        :port => config[:port],
+        :algorithm => config[:algorithm],
+        :nodes => nodes,
+        :virtual_ip_type => config[:virtual_ip_type]
+      }
+
+      unless config[:virtual_ip_ids].nil?
+        load_balancer_configuration[:virtual_ip_ids] = config[:virtual_ip_ids].split(",")
+      end
+
+      ui.output format_for_display(load_balancer_configuration)
+
+      unless config[:force]
+        ui.confirm("Do you really want to create this load balancer")
+      end
+
+      load_balancer_id = lb_connection.create_load_balancer(load_balancer_configuration)
+
+      ui.output(ui.color("Created load balancer #{@name_args.first}", :green))
+    end
+  end
+end

data/lib/chef/knife/rackspace_load_balancer_delete.rb

@@ -0,0 +1,41 @@
+require 'chef/knife'
+require 'chef/knife/rackspace_base'
+require 'chef/knife/rackspace_load_balancer_base'
+require 'cloudlb'
+
+require 'chef/knife/rackspace_load_balancer_show'
+
+module KnifePlugins
+  class RackspaceLoadBalancerDelete < Chef::Knife
+    include Chef::Knife::RackspaceBase
+    include Chef::Knife::RackspaceLoadBalancerBase
+
+    banner "knife rackspace load balancer delete ID [ID] (options)"
+
+    option :force,
+      :long => "--force",
+      :description => "Skip user prompts"
+
+    option :resolve_node_names,
+      :long => "--resolve-node-names",
+      :description => "Resolve node names against Chef Server"
+
+    def run
+      @name_args.each do |load_balancer_id|
+        show_load_balancer = RackspaceLoadBalancerShow.new
+        show_load_balancer.config[:resolve_node_names] = true if config[:resolve_node_names]
+        show_load_balancer.name_args = [load_balancer_id]
+        show_load_balancer.run
+
+        unless config[:force]
+          ui.confirm("Do you really want to delete this load balancer")
+        end
+
+        load_balancer = lb_connection.get_load_balancer(load_balancer_id)
+        load_balancer.destroy!
+
+        ui.warn("Deleted load balancer #{load_balancer_id}")
+      end
+    end
+  end
+end

data/lib/chef/knife/rackspace_load_balancer_delete_node.rb

@@ -0,0 +1,117 @@
+require 'chef/knife'
+require 'chef/knife/rackspace_base'
+require 'chef/knife/rackspace_load_balancer_base'
+require 'chef/knife/rackspace_load_balancer_nodes'
+require 'cloudlb'
+
+module KnifePlugins
+  class RackspaceLoadBalancerDeleteNode < Chef::Knife
+    include Chef::Knife::RackspaceBase
+    include Chef::Knife::RackspaceLoadBalancerBase
+    include Chef::Knife::RackspaceLoadBalancerNodes
+
+    banner "knife rackspace load balancer delete node (options)"
+
+    option :force,
+      :long => "--force",
+      :description => "Skip user input"
+
+    option :all,
+      :long => "--all",
+      :description => "Remove from all load balancers"
+
+    option :except,
+      :long => "--except \"ID[,ID]\"",
+      :description => "List of load balancer ids to omit (Implies --all)"
+
+    option :only,
+      :long => "--only \"ID[,ID]\"",
+      :description => "List of load balancer ids to remove from"
+
+    option :by_name,
+      :long => "--by-name \"NAME[,NAME]\"",
+      :description => "Resolve names against chef server to produce list of nodes to remove"
+
+    option :by_private_ip,
+      :long => "--by-private-ip \"IP[,IP]\"",
+      :description => "List of nodes given by private ips to remove"
+
+    option :by_search,
+      :long => "--by-search SEARCH",
+      :description => "Resolve search against chef server to produce list of nodes to remove"
+
+    def run
+      unless [:all, :except, :only].any? {|target| not config[target].nil?}
+        ui.fatal("Must provide a target set of load balancers with --all, --except, or --only")
+        show_usage
+        exit 1
+      end
+
+      unless [:by_name, :by_private_ip, :by_search].any? {|addition| not config[addition].nil?}
+        ui.fatal("Must provide a set of nodes to remove with --by-name, --by-private-ip, or --by-search")
+        show_usage
+        exit 2
+      end
+
+      node_ips = resolve_node_ips_from_config({
+        :by_search     => config[:by_search],
+        :by_name       => config[:by_name],
+        :by_private_ip => config[:by_private_ip]
+      })
+
+      nodes = node_ips.map do |ip|
+        { :address => ip }
+      end
+
+      if nodes.empty?
+        ui.fatal("Node resolution did not provide a set of nodes for removal")
+        exit 3
+      end
+
+      target_load_balancers = lb_connection.list_load_balancers
+
+      if config[:only]
+        only = config[:only].split(",").map(&:to_s)
+        target_load_balancers = target_load_balancers.select {|lb| only.include? lb[:id].to_s}
+      end
+
+      if config[:except]
+        except = config[:except].split(",").map(&:to_s)
+        target_load_balancers = target_load_balancers.reject {|lb| except.include? lb[:id].to_s}
+      end
+
+      if target_load_balancers.empty?
+        ui.fatal("Load balancer resolution did not provide a set of target load balancers")
+        exit 4
+      end
+
+      ui.output(format_for_display({
+        :targets => target_load_balancers.map {|lb| lb[:name]},
+        :nodes => nodes
+      }))
+
+      unless config[:force]
+        ui.confirm("Do you really want to remove these nodes")
+      end
+
+      target_load_balancers.each do |lb|
+        ui.output("Opening #{lb[:name]}")
+        balancer = lb_connection.get_load_balancer(lb[:id])
+
+        lb_nodes = balancer.list_nodes
+        lb_nodes.each do |lb_node_hash|
+          if node_ips.include? lb_node_hash[:address].to_s
+            lb_node = balancer.get_node(lb_node_hash[:id])
+            ui.output("Removing node #{lb_node.address}")
+            if lb_node.destroy!
+              ui.output(ui.color("Success", :green))
+            end
+          end
+        end
+      end
+
+      ui.output(ui.color("Complete", :green))
+    end
+  end
+end
+

data/lib/chef/knife/rackspace_load_balancer_list.rb

@@ -0,0 +1,39 @@
+require 'chef/knife'
+require 'chef/knife/rackspace_base'
+require 'chef/knife/rackspace_load_balancer_base'
+require 'cloudlb'
+
+module KnifePlugins
+  class RackspaceLoadBalancerList < Chef::Knife
+
+    include Chef::Knife::RackspaceBase
+    include Chef::Knife::RackspaceLoadBalancerBase
+
+    banner "knife rackspace load balancer list"
+
+    def run
+      load_balancer_list = [
+        ui.color("Id", :bold),
+        ui.color("Name", :bold),
+        ui.color("Nodes", :bold),
+        ui.color("Virtual Ip", :bold),
+        ui.color("Protocol / Port", :bold),
+        ui.color("Status", :bold),
+      ]
+
+      lb_connection.list_load_balancers.each do |load_balancer|
+        vip = (load_balancer[:virtualIps].detect {|vip| vip[:ipVersion] == "IPV4"})
+        vip ||= load_balancer[:virtualIps].first
+
+        load_balancer_list << load_balancer[:id].to_s
+        load_balancer_list << load_balancer[:name].to_s
+        load_balancer_list << load_balancer[:nodeCount].to_s
+        load_balancer_list << (vip.nil? ? "None" : vip[:address].to_s)
+        load_balancer_list << "#{load_balancer[:protocol]} / #{load_balancer[:port].to_s}"
+        load_balancer_list << ui.color(load_balancer[:status].to_s, load_balancer[:status] == "ACTIVE" ? :green : :red)
+      end
+
+      puts ui.list(load_balancer_list, :columns_across, 6)
+    end
+  end
+end

data/lib/chef/knife/rackspace_load_balancer_nodes.rb

@@ -0,0 +1,32 @@
+class Chef
+  class Knife
+    module RackspaceLoadBalancerNodes
+      def nodes_by_search(query)
+        nodes = []
+        Chef::Search::Query.new.search(:node, query) do |n|
+          nodes << n
+        end
+
+        nodes
+      end
+
+      def resolve_node_ips_from_config(options)
+        node_ips = []
+        if options[:by_search]
+          nodes_from_chef = nodes_by_search(options[:by_search])
+
+          node_ips = nodes_from_chef.map {|n| n.rackspace.private_ip}
+        elsif options[:by_name]
+          node_names = options[:by_name].split(",")
+          nodes_from_chef = nodes_by_search(node_names.map {|n| "name:#{n}"}.join(" OR "))
+
+          node_ips = nodes_from_chef.map {|n| n.rackspace.private_ip}
+        elsif options[:by_private_ip]
+          node_ips = config[:by_private_ip].split(",")
+        end
+
+        node_ips
+      end
+    end
+  end
+end

data/lib/chef/knife/rackspace_load_balancer_show.rb

@@ -0,0 +1,75 @@
+require 'chef/knife'
+require 'chef/search/query'
+require 'chef/knife/rackspace_base'
+require 'chef/knife/rackspace_load_balancer_base'
+require 'chef/knife/rackspace_load_balancer_nodes'
+require 'cloudlb'
+
+module KnifePlugins
+  class RackspaceLoadBalancerShow < Chef::Knife
+    include Chef::Knife::RackspaceBase
+    include Chef::Knife::RackspaceLoadBalancerBase
+    include Chef::Knife::RackspaceLoadBalancerNodes
+
+    banner "knife rackspace load balancer show ID [ID] (options)"
+
+    option :resolve_node_names,
+      :long => "--resolve-node-names",
+      :description => "Resolve node names against chef server"
+
+    def run
+      @name_args.each do |load_balancer_id|
+        load_balancer = lb_connection.get_load_balancer(load_balancer_id)
+        nodes = load_balancer.list_nodes
+
+        load_balancer_info = {
+          :name => load_balancer.name,
+          :id => load_balancer.id,
+          :protocol => load_balancer.protocol,
+          :port => load_balancer.port,
+          :status => ui.color(load_balancer.status, load_balancer.status == "ACTIVE" ? :green : :red)
+        }
+
+        vip_list = [
+          ui.color("Virtual Ip(s)", :bold),
+          ui.color("Id", :bold),
+          ui.color("Version", :bold),
+        ]
+
+        load_balancer.list_virtual_ips.each do |vip|
+          vip_list << vip[:address].to_s
+          vip_list << vip[:id].to_s
+          vip_list << vip[:ipVersion].to_s
+        end
+
+        node_list = [
+          ui.color("Node(s)", :bold),
+          ui.color("Address", :bold),
+          ui.color("Port", :bold),
+          ui.color("Condition", :bold),
+          ui.color("Status", :bold)
+        ]
+
+        nodes.each do |node|
+          node_name = node[:id]
+
+          if config[:resolve_node_names]
+            first_node = nodes_by_search("private_ip:#{node[:address]}").first
+            node_name = first_node.name unless first_node.nil? || first_node.name.nil?
+          end
+
+          node_list << node_name.to_s
+          node_list << node[:address].to_s
+          node_list << node[:port].to_s
+          node_list << ui.color(node[:condition].to_s, node[:condition] == "ENABLED" ? :green : :red)
+          node_list << ui.color(node[:status].to_s, node[:status] == "ONLINE" ? :green : :red)
+        end
+
+        ui.output(format_for_display(load_balancer_info))
+        ui.output("\n")
+        ui.output(ui.list(vip_list, :columns_across, 3))
+        ui.output(ui.list(node_list, :columns_across, 5))
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,8 @@
+module Knife
+  module Rackspace
+    module LoadBalancer
+      VERSION="0.0.1"
+      MAJOR, MINOR, TINY = VERSION.split(".")
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: knife-rackspace-load-balancer
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Matthew Vermaak
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-12 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: chef
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.10.8
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: knife-rackspace
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.5.12
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cloudlb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id003
+description: A gem to extend knife-rackspace allowing cloud load balancer management.
+email: dev@howaboutwe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- LICENSE.txt
+- README.rdoc
+- knife-rackspace-load-balancer.gemspec
+- lib/chef/knife/rackspace_load_balancer_add_node.rb
+- lib/chef/knife/rackspace_load_balancer_base.rb
+- lib/chef/knife/rackspace_load_balancer_create.rb
+- lib/chef/knife/rackspace_load_balancer_delete.rb
+- lib/chef/knife/rackspace_load_balancer_delete_node.rb
+- lib/chef/knife/rackspace_load_balancer_list.rb
+- lib/chef/knife/rackspace_load_balancer_nodes.rb
+- lib/chef/knife/rackspace_load_balancer_show.rb
+- lib/version.rb
+has_rdoc: true
+homepage: http://github.com/howaboutwe/knife-rackspace-load-balancer
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Rackspace cloud load balancer support for knife
+test_files: []
+