knife-rackspace-cluster 0.0.2

data/lib/chef/knife/rax_cluster_base.rb

@@ -0,0 +1,152 @@
+require 'chef/knife'
+#require 'chef/knife/rackspace/rackspace_base'
+#require 'chef/knife/rackspafce/rackspace_server_create'
+
+
+  # Make sure you subclass from Chef::Knife
+  
+class Chef
+	class Knife
+		
+	
+		module RaxClusterBase
+		
+			def self.included(includer)
+				includer.class_eval do
+			  
+				deps do
+					
+					require "net/https"
+					require 'net/http'
+					require "uri"
+					requie 'json'
+					#require 'chef/shef/ext'
+					#require 'rubygems'
+					#require 'chef/knife/rackspace_server_create'
+					#require 'json'
+					require 'fog'
+					#require "thread"
+					#require 'net/ssh/multi'
+					require 'readline'
+					require 'chef/knife/bootstrap'
+					require 'chef/json_compat'
+			
+				   Chef::Knife::Bootstrap.load_deps
+				  #include Knife::RackspaceBase
+				end
+					#option :rax_cluster_auth,
+					#  :short => "-auth auth_url_for_cluster",
+					#  :long => "--rackspace-api-url url",
+					#  :description => "Specify the URL to auth for creation of LB's, i.e. (https:////identity.api.rackspacecloud.com/v1.1)",
+					#  :proc => Proc.new { |key| Chef::Config[:knife][:rax_cluster_auth] = key }
+
+					#option :rackspace_api_key,
+					#  :short => "-K KEY",
+					#  :long => "--rackspace-api-key KEY",
+					#  :description => "Your rackspace API key",
+					#  :proc => Proc.new { |key| Chef::Config[:knife][:rackspace_api_key] = key }
+					#
+					#option :rackspace_username,
+					#  :short => "-A USERNAME",
+					#  :long => "--rackspace-username USERNAME",
+					#  :description => "Your rackspace API username",
+					#  :proc => Proc.new { |username| Chef::Config[:knife][:rackspace_username] = username }
+					#
+					#option :rackspace_version,
+					#  :long => '--rackspace-version VERSION',
+					#  :description => 'Rackspace Cloud Servers API version',
+					#  :default => "v1",
+					#  :proc => Proc.new { |version| Chef::Config[:knife][:rackspace_version] = version }
+					#
+					#option :rackspace_api_auth_url,
+					#  :long => "--rackspace-api-auth-url URL",
+					#  :description => "Your rackspace API auth url",
+					#  :default => "auth.api.rackspacecloud.com",
+					#  :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_api_auth_url] = url },
+					#  :default => "https://identity.api.rackspacecloud.com/v1.1/auth"
+					#
+					#option :rackspace_endpoint,
+					#  :long => "--rackspace-endpoint URL",
+					#  :description => "Your rackspace API endpoint",
+					#  :default => "https://dfw.servers.api.rackspacecloud.com/v2",
+					#  :proc => Proc.new { |url| Chef::Config[:knife][:rackspace_endpoint] = url }
+				end
+			end
+			def populate_environment
+				self.setup_environment_vars{ 
+					rackspace_username = Chef::Config[:knife][:rackspace_username]
+					rackspace_password = Chef::Config[:knife][:rackspace_password]
+					rackspace_endpoint = Chef::Config[:knife][:rackspace_auth_url]
+					@headers = {"x-auth-user" => rackspace_username, "x-auth-key" => rackspace_password,
+								"auth_url" => rackspace_endpoint,
+								"content-type" => "application/json", "Accept" => "application/json"}
+					#@rax_endpoint = Chef::Config[:knife][:narciss_url] + "/" + Chef::Config[:knife][:narciss_version] + "/"
+					#if rackspace_username_set
+					#	@rackspace_username = rackspace_username
+					#end
+					#if rackspace_password_set
+					#	@rackspace_password = rackspace_password				
+					#end
+					#if rackspace_tenant_set
+					#	@rackspace_tenant = rackspace_tenant	
+					#end
+					#if rackspace_endpoint_set
+					#	@rackspace_endpoint = rackspace_endpoint
+					#end
+							
+				}
+			end
+	
+			def make_web_call(httpVerb,uri,headers=nil, request_content=nil)
+			  verbs =
+				  {"get" => "Net::HTTP::Get.new(uri.request_uri, headers)",
+				  "head" => "Net::HTTP::Head.new(uri.request_uri, headers)",
+				  "put" => "Net::HTTP::Put.new(uri.request_uri, headers)",
+				  "delete" => "Net::HTTP::Delete.new(uri.request_uri, headers)",
+				  "post" => "Net::HTTP::Post.new(uri.request_uri, headers)"
+				  }
+			  #Get to work boy! This is Ruby!
+			  uri = URI.parse(uri)
+			  
+			  http = Net::HTTP.new(uri.host, uri.port)
+			  #if uri.host =~ /https/
+				  http.use_ssl = true
+			  #end
+			  http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			  request = eval verbs[httpVerb]
+			  if httpVerb == 'post' or httpVerb == 'put'
+				 request.body = request_content
+			  end
+			  response = http.request(request)
+			  if not ('200'..'204').include? response.code
+					  puts "Error making web call"
+					  puts "Response code : #{response.code}"
+					  puts "Response body : #{response.body}"
+					  #puts "Response Headers : #{response.headers}"
+			  end
+			  return response
+			  
+			end
+			#Just used for lbaas since fog doesn't allow meta data on LB's
+			def authenticate(auth_url='https://identity.api.rackspacecloud.com/v1.1/auth',username=Chef::Config[:knife][:rackspace_api_username] ,password=Chef::Config[:knife][:rackspace_api_key])
+				auth_json = {
+					"credentials" => {
+						"username" => username,
+						"key" => password
+					}
+				}
+				headers = {"Content-Type" => "application/json"}
+				auth_data = make_web_call('post', auth_url, headers, auth_json.to_json)
+				lb_data = JSON.parse(auth_data.body)
+				lb_returned = {'auth_token' => lb_data['auth']['token']['id'], 'lb_urls' => lb_data['auth']['serviceCatalog']['cloudLoadBalancers'] }
+				return lb_returned
+			end
+			def msg_pair(label, value, color=:cyan)
+			  if value && !value.to_s.empty?
+				puts "#{ui.color(label, color)}: #{value}"
+			  end
+			end
+			
+		end
+	end
+end

data/lib/chef/knife/rax_cluster_build.rb

@@ -0,0 +1,220 @@
+
+require 'chef/knife/rackspace_server_create'
+class Chef
+  class Knife
+    class RaxClusterBuild < RackspaceServerCreate
+
+      include Knife::RackspaceBase
+
+      deps do
+        require 'fog'
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+      end
+
+      banner "knife rackspace server create (options)"
+
+      option :flavor,
+        :short => "-f FLAVOR",
+        :long => "--flavor FLAVOR",
+        :description => "The flavor of server; default is 2 (512 MB)",
+        :proc => Proc.new { |f| Chef::Config[:knife][:flavor] = f.to_i },
+        :default => 2
+
+      option :image,
+        :short => "-I IMAGE",
+        :long => "--image IMAGE",
+        :description => "The image of the server",
+        :proc => Proc.new { |i| Chef::Config[:knife][:image] = i.to_s }
+
+      option :server_name,
+        :short => "-S NAME",
+        :long => "--server-name NAME",
+        :description => "The server name"
+
+      option :chef_node_name,
+        :short => "-N NAME",
+        :long => "--node-name NAME",
+        :description => "The Chef node name for your new node"
+
+      option :private_network,
+        :long => "--private-network",
+        :description => "Use the private IP for bootstrapping rather than the public IP",
+        :boolean => true,
+        :default => false
+
+      option :ssh_user,
+        :short => "-x USERNAME",
+        :long => "--ssh-user USERNAME",
+        :description => "The ssh username; default is 'root'",
+        :default => "root"
+
+      option :ssh_password,
+        :short => "-P PASSWORD",
+        :long => "--ssh-password PASSWORD",
+        :description => "The ssh password"
+
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
+
+      option :prerelease,
+        :long => "--prerelease",
+        :description => "Install the pre-release chef gems"
+
+      option :bootstrap_version,
+        :long => "--bootstrap-version VERSION",
+        :description => "The version of Chef to install",
+        :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
+
+      option :distro,
+        :short => "-d DISTRO",
+        :long => "--distro DISTRO",
+        :description => "Bootstrap a distro using a template; default is 'chef-full'",
+        :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
+        :default => "chef-full"
+
+      option :template_file,
+        :long => "--template-file TEMPLATE",
+        :description => "Full path to location of template to use",
+        :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
+        :default => false
+
+      option :run_list,
+        :short => "-r RUN_LIST",
+        :long => "--run-list RUN_LIST",
+        :description => "Comma separated list of roles/recipes to apply",
+        :proc => lambda { |o| o.split(/[\s,]+/) },
+        :default => []
+
+      option :first_boot_attributes,
+        :short => "-j JSON_ATTRIBS",
+        :long => "--json-attributes",
+        :description => "A JSON string to be added to the first run of chef-client",
+        :proc => lambda { |o| JSON.parse(o) },
+        :default => {}
+
+      option :rackspace_metadata,
+        :short => "-M JSON",
+        :long => "--rackspace-metadata JSON",
+        :description => "JSON string version of metadata hash to be supplied with the server create call",
+        :proc => Proc.new { |m| Chef::Config[:knife][:rackspace_metadata] = JSON.parse(m) },
+        :default => ""
+
+      option :host_key_verify,
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, enabled by default",
+        :boolean => true,
+        :default => true
+
+      def tcp_test_ssh(hostname)
+        tcp_socket = TCPSocket.new(hostname, 22)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
+          yield
+          true
+        else
+          false
+        end
+      rescue Errno::ETIMEDOUT
+        false
+      rescue Errno::EPERM
+        false
+      rescue Errno::ECONNREFUSED
+        sleep 2
+        false
+      rescue Errno::EHOSTUNREACH
+        sleep 2
+        false
+      ensure
+        tcp_socket && tcp_socket.close
+      end
+
+      def run
+        $stdout.sync = true
+
+        unless Chef::Config[:knife][:image]
+          ui.error("You have not provided a valid image value.  Please note the short option for this value recently changed from '-i' to '-I'.")
+          exit 1
+        end
+
+        node_name = get_node_name(config[:chef_node_name] || config[:server_name])
+
+        server = connection.servers.create(
+          :name => node_name,
+          :image_id => Chef::Config[:knife][:image],
+          :flavor_id => locate_config_value(:flavor),
+          :metadata => Chef::Config[:knife][:rackspace_metadata]
+          )
+
+        msg_pair("Instance ID", server.id)
+        msg_pair("Host ID", server.host_id)
+        msg_pair("Name", server.name)
+        msg_pair("Flavor", server.flavor.name)
+        msg_pair("Image", server.image.name)
+        msg_pair("Metadata", server.metadata)
+
+        print "\n#{ui.color("Waiting server", :magenta)}"
+
+        # wait for it to be ready to do stuff
+        server.wait_for { print "."; ready? }
+
+        puts("\n")
+
+        msg_pair("Public DNS Name", public_dns_name(server))
+        msg_pair("Public IP Address", public_ip(server))
+        msg_pair("Private IP Address", private_ip(server))
+        msg_pair("Password", server.password)
+
+        print "\n#{ui.color("Waiting for sshd", :magenta)}"
+
+        #which IP address to bootstrap
+        bootstrap_ip_address = public_ip(server)
+        if config[:private_network]
+          bootstrap_ip_address = private_ip(server)
+        end
+        Chef::Log.debug("Bootstrap IP Address #{bootstrap_ip_address}")
+        if bootstrap_ip_address.nil?
+          ui.error("No IP address available for bootstrapping.")
+          exit 1
+        end
+
+        print(".") until tcp_test_ssh(bootstrap_ip_address) {
+          sleep @initial_sleep_delay ||= 10
+          puts("done")
+        }
+        bootstrap_for_node(server, bootstrap_ip_address).run
+
+        puts "\n"
+        msg_pair("Instance ID", server.id)
+        msg_pair("Host ID", server.host_id)
+        msg_pair("Name", server.name)
+        msg_pair("Flavor", server.flavor.name)
+        msg_pair("Image", server.image.name)
+        msg_pair("Metadata", server.metadata)
+        msg_pair("Public DNS Name", public_dns_name(server))
+        msg_pair("Public IP Address", public_ip(server))
+        msg_pair("Private IP Address", private_ip(server))
+        msg_pair("Password", server.password)
+        msg_pair("Environment", config[:environment] || '_default')
+        msg_pair("Run List", config[:run_list].join(', '))
+        ipaddress = ''
+        #if not server.private_ip_address
+        #  ipaddress = server.public_ip_address
+        #end
+        #if not ipaddress
+        #  ipaddress = "false"
+        #end
+        return_hash = {"public_ip" => public_ip(server), "private_ip" => private_ip(server), "server_name" => server.name, "server_id" => server.id}
+        return return_hash
+      end
+      
+    end
+  end
+end
+
+

data/lib/chef/knife/rax_cluster_change.rb

@@ -0,0 +1,95 @@
+class Chef
+  class Knife
+    class RaxClusterChange < Knife
+      attr_accessor :headers, :rax_endpoint, :lb_id 
+      include Knife::RaxClusterBase
+
+      banner "knife rax cluster change LB_ID (chef_options)"
+      deps do
+        require 'fog'
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+      end
+      
+      option :lb_region,
+      :short => "-r lb_region",
+      :long => "--load-balancer-region lb_region",
+      :description => "Load balancer region (only supports ORD || DFW)",
+      :proc => Proc.new { |lb_region| Chef::Config[:knife][:lb_region] = lb_region},
+      :default => "ORD"
+
+      option :run_list,
+      :long => "--run-list run_list",
+      :description => "Pass a comma delimted run list --run-list 'recipe[apt],role[base]'",
+      :proc => Proc.new { |run_list| Chef::Config[:knife][:run_list] = run_list}
+      
+      option :chef_env,
+      :long => "--chef-env environment",
+      :description => "Pass a comma delimted run list --run-list 'recipe[apt],role[base]'",
+      :proc => Proc.new { |chef_env| Chef::Config[:knife][:chef_env] = chef_env}
+      
+      def change_chef_vars(instances, &block)
+        instances.each { |inst|
+          query = "name:#{inst['server_name']}"
+          query_nodes = Chef::Search::Query.new
+          query_nodes.search('node', query) do |node_item|
+            yield node_item
+          end
+        }
+      end
+      def run
+        if !config[:run_list] and !config[:chef_env]
+          ui.fatal "Please specify either --run-list or --chef-env to change on your cluster"
+          exit(1)
+        end
+        if @name_args.empty?
+          ui.fatal "Please specify a load balancer ID to update"
+          exit(1)
+        end
+        lb_auth = authenticate()
+        headers = {"x-auth-token" => lb_auth['auth_token'], "content-type" => "application/json"}
+        lb_url = ""
+        lb_auth['lb_urls'].each {|lb|
+          if config[:lb_region].to_s.downcase ==  lb['region'].to_s.downcase
+            lb_url = lb['publicURL']
+            break
+          end
+          lb_url = lb['publicURL']
+          }
+        @name_args.each {|arg|
+          lb_url = lb_url + "/loadbalancers/#{arg}"
+          lb_data = make_web_call("get", lb_url, headers)
+          lb_data = JSON.parse(lb_data.body)          
+          instances = []
+          lb_data['loadBalancer']['metadata'].each{|md|
+            instances << {"server_name" => md['key'], "uuid" => md['uuid']}
+            }
+          
+          if config[:run_list]
+            config[:run_list] = config[:run_list].split(",")
+            change_chef_vars(instances) { |node_item|
+              ui.msg "Changing #{node_item.name} run list to #{config[:run_list]}"
+              node_item.run_list(config[:run_list])
+              node_item.save
+            }
+          end
+          if config[:chef_env]
+            change_chef_vars(instances){|node_item|
+              ui.msg "Changing #{node_item.name} chef environment to #{config[:chef_env]}"
+              node_item.chef_environment(config[:chef_env])
+              node_item.save
+              
+              }
+          end
+          
+        }
+        
+      end
+      
+      
+
+    end
+  end
+end

data/lib/chef/knife/rax_cluster_create.rb

@@ -0,0 +1,212 @@
+require 'chef/knife/rax_cluster_base'
+require 'chef/knife/rax_cluster_build'
+
+class Chef
+  class Knife
+    class RaxClusterCreate < Knife
+      attr_accessor :headers, :rax_endpoint, :lb_name 
+      include Knife::RaxClusterBase
+      banner "knife rax cluster create (cluster_name) [options]"
+      deps do
+        require 'fog'
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+      end
+
+      option :algorithm,
+      :short => "-a Load_balacner_algorithm",
+      :long => "--algorithm algorithm",
+      :description => "Load balancer algorithm",
+      :proc => Proc.new { |algorithm| Chef::Config[:knife][:algorithm] = algorithm },
+      :default => "ROUND_ROBIN"
+      
+	  option :blue_print,
+	  :short => "-B Blue_print_file",
+	  :long => "--map blue_print_file",
+	  :description => "Path to blue Print json file",
+	  :proc => Proc.new { |i| Chef::Config[:knife][:blue_print] = i.to_s }
+      
+      option :port,
+      :short => "-lb_port port",
+      :long => "--load-balancer-port port",
+      :description => "Load balancer port",
+      :proc => Proc.new { |port| Chef::Config[:knife][:port] = port},
+      :default => "80"
+      
+      option :timeout,
+      :short => "-t timeout",
+      :long => "--load-balancer-timeout timeout",
+      :description => "Load balancer timeout",
+      :proc => Proc.new { |timeout| Chef::Config[:knife][:timeout] = timeout},
+      :default => "30"
+      
+      option :lb_region,
+      :short => "-r lb_region",
+      :long => "--load-balancer-region lb_region",
+      :description => "Load balancer region (only supports ORD || DFW)",
+      :proc => Proc.new { |lb_region| Chef::Config[:knife][:lb_region] = lb_region},
+      :default => "ORD"
+      
+      option :protocol,
+      :short => "-p protocol",
+      :long => "--load-balancer-protocol protocol",
+      :description => "Load balancer protocol",
+      :proc => Proc.new { |protocol| Chef::Config[:knife][:protocol] = protocol},
+      :default => 'HTTP'
+      
+      option :generate_map_template,
+      :short => "-G",
+      :long => "--generate_map_template",
+      :description => "Generate server map Template in current dir named map_template.json"
+      
+      #option :session_persistence,
+      #:short => "-S on_or_off",
+      #:long => "--session-persistence session_persistence_on_or_off",
+      #:description => "Load balancer session persistence on or off",
+      #:proc => Proc.new { |session_persistence| Chef::Config[:knife][:session_persistence] = session_persistence}
+
+      def generate_map_template
+           file_name = "./map_template.json"
+           template = %q(
+           {
+             "blue_print" : 
+               {
+                   "name_convention" : "web",
+                   "run_list" : [
+                     "recipe[apt]"
+                   ],
+                   "quantity" : 1,
+                   "chef_env" : "dev",
+                   "image_ref" : "a9753ff4-f46c-427d-9498-1358564f622f",
+                   "flavor" : 2
+                   }
+             
+     
+           }
+     )
+     
+           File.open(file_name, 'w') { |file| file.write(template)}
+      end
+      def create_lb(instances)
+        lb_request = {
+          "loadBalancer" => {
+            "name" => @lb_name.to_s + "_cluster",
+            "port" => config[:port] || '80',
+            "protocol" => config[:protocol] || 'HTTP',
+            "algorithm" => config[:algorithm] || 'ROUND_ROBIN',
+            "virtualIps" => [
+              {
+                "type" => "PUBLIC"
+              }
+            ],
+            "nodes" => [],
+            "metadata" => []
+          }
+        }
+        
+        instances.each {|inst|
+          lb_request['loadBalancer']['nodes'] << {"address" => inst['ip_address'], 'port' =>Chef::Config[:knife][:port] || '80', "condition" => "ENABLED" }
+          lb_request['loadBalancer']['metadata'] << {"key" => inst['server_name'], "value" => inst['uuid']}
+          }
+        lb_authenticate = authenticate()
+        lb_url = ""
+        lb_authenticate['lb_urls'].each {|lb|
+          if config[:lb_region].to_s.downcase ==  lb['region'].to_s.downcase
+            lb_url = lb['publicURL']
+            break
+          end
+          lb_url = lb['publicURL']
+          }
+        lb_url = lb_url + "/loadbalancers"
+        
+        headers = {'Content-type' => 'application/json', 'x-auth-token' => lb_authenticate['auth_token']}
+        create_lb_call = make_web_call("post",lb_url, headers, lb_request.to_json )
+        lb_details = JSON.parse(create_lb_call.body)
+        ui.msg "Load Balancer Cluster Sucesfully Created"
+        ui.msg "Load Balancer ID: #{lb_details['loadBalancer']['id']}"
+        ui.msg "Load Balancer Name: #{lb_details['loadBalancer']['name']}"
+        lb_ip = ""
+        lb_details['loadBalancer']['virtualIps'].each {|lb| (lb['ipVersion'] == "IPV4") ? lb_ip = lb['address'] : "not_found"}
+        ui.msg "Load Balancer IP Address: #{lb_ip}"
+      end
+      
+      
+      def deploy(blue_print,update_cluster=nil)
+        (File.exist?(blue_print)) ? map_contents = JSON.parse(File.read(blue_print)) : map_contents = JSON.parse(blue_print)
+        sleep_interval = 1
+        instances = []
+        if map_contents.has_key?("blue_print")
+          bp_values = map_contents['blue_print']
+          bootstrap_nodes = []
+          quantity = bp_values['quantity'].to_i
+              quantity.times do |node_name|
+                  node_name  = rand(900000000)
+                  create_server = Chef::Knife::RaxClusterBuild.new
+                  #create_server.config[:identity_file] = config[:identity_file]
+                  Chef::Config[:knife][:image] = bp_values['image_ref'] 
+                  create_server.config[:chef_node_name] = bp_values['name_convention'] + node_name.to_s 
+                  create_server.config[:environment] = bp_values['chef_env'] 
+                  Chef::Config[:environment] = bp_values['chef_env']
+                  create_server.config[:run_list] = bp_values['run_list']
+                  Chef::Config[:knife][:flavor] = bp_values['flavor']
+                  begin
+                    bootstrap_nodes << Thread.new { Thread.current['server_return'] = create_server.run }
+                  rescue
+                    ui.msg "Bootstrapping failed"
+                  end
+                  
+              end
+              quantity.times do |times|
+                if quantity > 20
+                  sleep_interval = 3
+                end
+                sleep(sleep_interval)
+                bootstrap_nodes[times].join              
+                instances << {"server_name" => bootstrap_nodes[times]['server_return']['server_name'],
+                              "ip_address" => bootstrap_nodes[times]['server_return']['private_ip'],
+                              "uuid" => bootstrap_nodes[times]['server_return']['server_id'],
+                              "name_convention" => bp_values['name_convention'],
+                              "chef_env" => bp_values['chef_env'],
+                              "run_list" => bp_values['run_list']
+                              }
+              end
+        end
+        if update_cluster
+          return instances
+        else
+          create_lb(instances)
+        end
+        
+        
+        
+      end
+
+      def run
+        #Generate template config
+		if config[:generate_map_template]
+		  generate_map_template()
+		  ui.msg "Map template saved as ./map_template.json"
+		  exit()
+		end
+        
+        
+        if @name_args.empty? or @name_args.size > 1
+		  ui.fatal "Please specify a single name for your cluster"
+		  exit(1)
+        end
+        #Set load balancer name
+        @lb_name = @name_args[0]
+        
+        if config[:blue_print]
+          deploy(config[:blue_print])
+      
+        end
+        
+      end
+    
+      
+    end
+  end
+end

data/lib/chef/knife/rax_cluster_delete.rb

@@ -0,0 +1,76 @@
+require 'chef/knife/rax_cluster_base'
+require 'chef/knife/rackspace_server_delete'
+
+class Chef
+  class Knife
+    class RaxClusterDelete < Knife
+      attr_accessor :headers, :rax_endpoint, :lb_name 
+      include Knife::RaxClusterBase
+      banner "knife rax cluster delete (load_balancer_id) [options]"
+      deps do
+        require 'fog'
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+      end
+      
+      option :lb_region,
+      :short => "-r lb_region",
+      :long => "--load-balancer-region lb_region",
+      :description => "Load balancer region (only supports ORD || DFW)",
+      :proc => Proc.new { |lb_region| Chef::Config[:knife][:lb_region] = lb_region},
+      :default => "ORD"
+
+      def delete_cluster
+        lb_authenticate = authenticate()
+        lb_url = ""
+        puts config[:lb_region]
+        headers = {"x-auth-token" => lb_authenticate['auth_token'], "content-type" => "application/json"}
+        lb_authenticate['lb_urls'].each {|lb|
+          if config[:lb_region].to_s.downcase ==  lb['region'].to_s.downcase
+            lb_url = lb['publicURL']
+            break
+          end
+          lb_url = lb['publicURL']
+        }
+        @name_args.each {|arg|
+          server_uuids = []
+          lb_url = lb_url + "/loadbalancers/#{arg}"
+          get_uuids = make_web_call("get", lb_url, headers )
+          if get_uuids.code == '404'
+            ui.msg "Make sure you specify the -r flag to specify what region the LB is located"
+            exit(1)
+          end
+          lb_data =  JSON.parse(get_uuids.body)
+          lb_data['loadBalancer']['metadata'].each{|meta|
+            server_uuids << {'uuid' => meta['value'], 'server_name' => meta['key'] }
+            }
+          server_uuids.each { |uuid|
+            rs_delete = RackspaceServerDelete.new
+            rs_delete.config[:yes] = 'yes'
+            rs_delete.name_args = [ uuid['uuid'] ]
+            rs_delete.config[:purge] = true
+            rs_delete.config[:chef_node_name] = uuid['server_name']
+            rs_delete.run
+          }
+          delete_lb_call = make_web_call("delete", lb_url, headers)
+          puts "Deleted loadbalancer id #{arg}"
+          
+          
+        }
+      end
+        
+      def run
+        if @name_args.empty?
+          ui.fatal "Please specify a Load balancer ID to delete"
+        end
+        ui.confirm("Are you sure you want to delete this Load balancer and ALL nodes associated with it?")
+        delete_cluster
+      end
+      
+
+
+    end
+  end
+end

data/lib/chef/knife/rax_cluster_expand.rb

@@ -0,0 +1,104 @@
+require 'chef/knife/rax_cluster_base'
+require 'chef/knife/rackspace_server_delete'
+
+class Chef
+  class Knife
+    class RaxClusterExpand < Knife
+      attr_accessor :headers, :rax_endpoint, :lb_id 
+      include Knife::RaxClusterBase
+      banner "knife rax cluster expand (load_balancer_id) -B template_file.json"
+      deps do
+        require 'fog'
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+      end
+	  
+	  option :blue_print,
+	  :short => "-B Blue_print_file",
+	  :long => "--map blue_print_file",
+	  :description => "Path to blue Print json file",
+	  :proc => Proc.new { |i| Chef::Config[:knife][:blue_print] = i.to_s }
+      
+      option :port,
+      :short => "-lb_port port",
+      :long => "--load-balancer-port port",
+      :description => "Load balancer port",
+      :proc => Proc.new { |port| Chef::Config[:knife][:port] = port},
+      :default => "80"
+	  
+      option :lb_region,
+      :short => "-r lb_region",
+      :long => "--load-balancer-region lb_region",
+      :description => "Load balancer region (only supports ORD || DFW)",
+      :proc => Proc.new { |lb_region| Chef::Config[:knife][:lb_region] = lb_region},
+      :default => "ORD"
+	  
+	  def expand_cluster
+        rs_cluster = RaxClusterCreate.new
+        rs_cluster.config[:blue_print]  = config[:blue_print]
+        rs_cluster.lb_name = @name_args[0]
+        instance_return = rs_cluster.deploy(config[:blue_print],'update_cluster')
+        lb_auth = authenticate()
+        puts lb_auth['auth_token']
+        headers = {"x-auth-token" => lb_auth['auth_token'], "content-type" => "application/json"}
+        lb_url = ""
+        lb_auth['lb_urls'].each {|lb|
+          if config[:lb_region].to_s.downcase ==  lb['region'].to_s.downcase
+            lb_url = lb['publicURL']
+            break
+          end
+          lb_url = lb['publicURL']
+          }
+        meta_data_request = {
+          "metadata" => []        
+        }
+        node_data_request = {
+          "nodes" => []
+        }
+        meta_url = lb_url + "/loadbalancers/#{@lb_id}/metadata"
+        node_url = lb_url + "/loadbalancers/#{@lb_id}/nodes"
+        
+        instance_return.each {|inst|
+          node_data_request['nodes'] << {"address" => inst['ip_address'], 'port' =>Chef::Config[:knife][:port] || '80', "condition" => "ENABLED" }          
+          meta_data_request['metadata'] << {"key" => inst['server_name'], "value" => inst['uuid']} 
+          }
+        meta_request = make_web_call("post", meta_url, headers, meta_data_request.to_json)
+        lb_status = lb_url + "/loadbalancers/#{@lb_id}"
+        lb_stats = make_web_call("get", lb_status, headers)
+        lb_stats = JSON.parse(lb_stats.body)
+
+        while lb_stats['loadBalancer']['status'].to_s.downcase != 'active'
+          sleep(5)
+          lb_stats = make_web_call("get", lb_status, headers)
+          lb_stats = JSON.parse(lb_stats.body)
+        end
+        node_request = make_web_call("post", node_url, headers, node_data_request.to_json)        
+        ui.msg "Load balancer id #{@lb_id} has been updated"
+        
+	  end
+	  
+	  def run
+        if @name_args.empty?
+          ui.fatal "Please specify Load balancer ID to add nodes too"
+          exit(1)
+        end
+        if !config[:blue_print]
+          ui.fatal "Please specify a blue print file to parse with -B"
+          exit(1)
+        end
+        
+        if config[:blue_print]
+          @lb_id = @name_args[0]
+          expand_cluster
+        end
+        
+	  end
+      
+
+
+
+    end
+  end
+end

data/lib/chef/knife/rax_cluster_list.rb

@@ -0,0 +1,56 @@
+class Chef
+  class Knife
+    class RaxClusterList < Knife
+      attr_accessor :headers, :rax_endpoint, :lb_id 
+      include Knife::RaxClusterBase
+
+      banner "knife rax cluster list -r lb_region"
+      deps do
+        require 'fog'
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+      end
+      
+      option :lb_region,
+      :short => "-r lb_region",
+      :long => "--load-balancer-region lb_region",
+      :description => "Load balancer region (only supports ORD || DFW)",
+      :proc => Proc.new { |lb_region| Chef::Config[:knife][:lb_region] = lb_region},
+      :default => "ORD"
+      
+      
+      
+      def run
+        lb_auth = authenticate
+        headers = {"x-auth-token" => lb_auth['auth_token'], "content-type" => "application/json"}
+        lb_url = ""
+        lb_auth['lb_urls'].each {|lb|
+          if config[:lb_region].to_s.downcase ==  lb['region'].to_s.downcase
+            lb_url = lb['publicURL']
+            break
+          end
+          lb_url = lb['publicURL']
+          }
+        lb_url = lb_url + "/loadbalancers"
+        lb_list = make_web_call("get", lb_url, headers)
+        lb_list = JSON.parse(lb_list.body)
+        lb_list['loadBalancers'].each {|lb|
+          if (lb['name'] =~ /_cluster/i)
+            msg_pair("LB Details for #{lb['name']}", " ")
+            msg_pair("\s\s\s\sLB ID", "#{lb['id']}")
+            msg_pair("\s\s\s\sLB Port", "#{lb['port']}")
+            msg_pair("\s\s\s\sLB Algorithm", "#{lb['algorithm']}")
+            msg_pair("\s\s\s\sLB Protocol", "#{lb['protocol']}")
+            msg_pair("\s\s\s\sLB Node Count", "#{lb['nodeCount']}")
+            ui.msg "\n\n"
+          end
+          }
+        
+      end
+
+
+    end
+  end
+end

data/lib/chef/knife/super_rax.rb

@@ -0,0 +1,126 @@
+module MyKnifePlugins
+  # Make sure you subclass from Chef::Knife
+  class OverRide < Chef::Knife
+    
+    
+    banner "Cloud Builder"
+      deps do
+       
+       require 'chef/knife/rackspace/rackspace_server_create'
+       require 'json'
+       require 'fog'
+       require "thread"
+       require 'chef/knife/rackspace/rackspace_base'
+       require 'net/ssh/multi'
+       require 'readline'
+       require 'chef/knife/bootstrap'
+       require 'chef/json_compat'
+       Chef::Knife::Bootstrap.load_deps
+      #include Knife::RackspaceBase
+      end
+        option :server_map,
+        :short => "-M MAP_File",
+        :long => "--map Map_File",
+        :description => "Path to Server Map json file",
+        :proc => Proc.new { |i| Chef::Config[:knife][:server_map] = i.to_s }
+        
+        option :provider,
+        :short => "-P Provider",
+        :long => "--provider provider",
+        :description => "Specify RAX, open_stack",
+        :default => 'RAX'
+        #:proc => Proc.new { |i| Chef::Config[:knife][:server_map] = i.to_s }
+        
+        option :generate_map_template,
+        :short => "-G",
+        :long  => "--generate_map_template",
+        :description => "Generate server map Template in current dir named map_template.json"
+        
+        #option :image,
+        #:short => "-I IMAGE",
+        #:long => "--image IMAGE",
+        #:description => "The image of the server",
+        #:proc => Proc.new { |i| Chef::Config[:knife][:image] = i.to_s }
+
+
+
+        
+    # This method will be executed when you run this knife command.
+    def generate_map_template
+      file_name = "./map_template.json"
+      template = %q(
+      {
+        "servers" : [
+          {
+              "name_convention" : "web",
+              "run_list" : [
+                "role[base]",
+                "role[narciss]"
+              ],
+              "quantity" : 2,
+              "chef_env" : "dev",
+              "image_ref" : "c195ef3b-9195-4474-b6f7-16e5bd86acd0",
+              "flavor" : 2
+              
+          }
+        ]
+      })
+      File.open(file_name, 'w') { |file| file.write(template)}
+    end
+    #Populates server_calls with map data
+    def parse_server_map(map_file)
+      map_contents = JSON.parse(File.read(map_file))
+      server_calls = {}
+      if map_contents.has_key?("servers")
+        for i in map_contents['servers']
+          server_calls[i['name_convention']] = {
+                            "run_list" =>  i['run_list'] ,
+                            "quantity" => i['quantity'], "chef_env" => i['chef_env'],
+                            "image_ref" => i['image_ref']
+          }
+          #i['quantity'].times do
+              run_list = i['run_list'].join(', ')
+            #Thread.new {
+              create_server = Chef::Knife::RackspaceServerCreate.new
+              #create_server.config[:image] = i['image_ref']
+              Chef::Config[:knife][:image] = i['image_ref']
+              create_server.config[:server_name] = i['name_convention']
+              create_server.config[:environment] = i['chef_env']
+              create_server.config[:run_list] = i['run_list']
+              #create_server.config[:flavor] = i['flavor']
+              Chef::Config[:knife][:flavor] = i['flavor']
+              create_server.run
+          ##}
+          #end
+        
+        end
+
+      else
+        ui.fatal "JSON file incorrect format"
+      end
+    end
+  
+  
+    def launch_build
+      yield
+      
+    end
+
+    def run
+      #Generate template config
+      if config[:generate_map_template]
+        generate_map_template()
+      end
+      #Parses Map and takes action
+      if config[:server_map]
+        parse_server_map(config[:server_map])
+
+        
+      end
+      
+      
+
+    end
+ 
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: knife-rackspace-cluster
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors: 
+- zack feldstein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-02-19 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: knife-rackspace
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: fog
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+  type: :runtime
+  version_requirements: *id002
+description: Creates rax clusters
+email: zack.feldstein@rackspace.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/chef/knife/rax_cluster_base.rb
+- lib/chef/knife/rax_cluster_build.rb
+- lib/chef/knife/rax_cluster_change.rb
+- lib/chef/knife/rax_cluster_create.rb
+- lib/chef/knife/rax_cluster_delete.rb
+- lib/chef/knife/rax_cluster_expand.rb
+- lib/chef/knife/rax_cluster_list.rb
+- lib/chef/knife/super_rax.rb
+homepage: http://github.com/jrcloud/knife_rax_cluster
+licenses: []
+
+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.8.23
+signing_key: 
+specification_version: 3
+summary: Knife rax cluster
+test_files: []
+