chef-vpc-toolkit 2.0.0

data/lib/chef-vpc-toolkit/cloud_servers_vpc.rb

@@ -0,0 +1,285 @@
+require 'json'
+require 'builder'
+require 'rexml/document'
+require 'rexml/xpath'
+
+module ChefVPCToolkit
+
+module CloudServersVPC
+
+	SERVER_GROUP_CONFIG_FILE = CHEF_VPC_PROJECT + File::SEPARATOR + "config" + File::SEPARATOR + "server_group.json"
+
+	def self.load_public_key
+
+		ssh_dir=ENV['HOME']+File::SEPARATOR+".ssh"+File::SEPARATOR
+		if File.exists?(ssh_dir+"id_rsa.pub")
+			pubkey=IO.read(ssh_dir+"id_rsa.pub")
+		elsif File.exists?(ssh_dir+"id_dsa.pub")
+			pubkey=IO.read(ssh_dir+"id_dsa.pub")
+		else
+			raise "Failed to load SSH key. Please create a SSH public key pair in your HOME directory."
+		end
+
+		pubkey.chomp
+
+	end
+
+	# generate a Server Group XML from server_group.json
+	def self.server_group_xml(config_file=SERVER_GROUP_CONFIG_FILE, owner=ENV['USER'])
+
+		json_hash=JSON.parse(IO.read(config_file))
+
+		xml = Builder::XmlMarkup.new
+		xml.tag! "server-group" do |sg|
+			sg.name(json_hash["name"])
+			sg.description(json_hash["description"])
+			sg.tag! "owner-name", owner
+			sg.tag! "domain-name", json_hash["domain_name"]
+			if json_hash["vpn_network"] then
+				sg.tag! "vpn-network", json_hash["vpn_network"]
+			else
+				sg.tag! "vpn-network", "172.19.0.0"
+			end
+			if json_hash["vpn_subnet"] then
+				sg.tag! "vpn-subnet", json_hash["vpn_subnet"]
+			else
+				sg.tag! "vpn-subnet", "255.255.128.0"
+			end
+			sg.servers("type" => "array") do |servers|
+				json_hash["servers"].each_pair do |server_name, server_config|
+					servers.server do |server|
+						server.name(server_name)
+						if server_config["description"] then
+							server.description(server_config["description"])
+						else
+							server.description(server_name)
+						end
+						server.tag! "flavor-id", server_config["flavor_id"]
+						server.tag! "image-id", server_config["image_id"]
+						if server_config["openvpn_server"]
+							server.tag! "openvpn-server", "true", { "type" => "boolean"}
+						end
+					end
+				end
+			end
+			sg.tag! "ssh-public-keys", { "type" => "array"} do |ssh_keys|
+				ssh_keys.tag! "ssh-public-key" do |ssh_public_key|
+					ssh_public_key.description "#{ENV['USER']}'s public key"
+					ssh_public_key.tag! "public-key", self.load_public_key
+				end
+			end
+		end
+		xml.target!
+
+	end
+
+	def self.server_group_hash(xml)
+
+		hash={}
+        dom = REXML::Document.new(xml)
+        REXML::XPath.each(dom, "/server-group") do |sg|
+
+			hash["name"]=sg.elements["name"].text
+			hash["description"]=sg.elements["description"].text
+			hash["id"]=sg.elements["id"].text
+			hash["domain-name"]=sg.elements["domain-name"].text
+
+			hash["servers"]={}
+			REXML::XPath.each(dom, "//server") do |server|
+				server_name=server.elements["name"].text
+				server_attributes={
+					"id" => server.elements["id"].text,
+					"cloud-server-id-number" => server.elements["cloud-server-id-number"].text,
+					"status" => server.elements["status"].text,
+					"external-ip-addr" => server.elements["external-ip-addr"].text,
+					"internal-ip-addr" => server.elements["internal-ip-addr"].text,
+					"error-message" => server.elements["error-message"].text,
+					"image-id" => server.elements["image-id"].text,
+					"retry-count" => server.elements["retry-count"].text,
+					"openvpn-server" => server.elements["openvpn-server"].text
+				}
+				if server.elements["openvpn-server"].text and server.elements["openvpn-server"].text == "true" and server.elements["external-ip-addr"].text then
+					hash["vpn-gateway"]=server.elements["external-ip-addr"].text
+				end
+				hash["servers"].store(server_name, server_attributes)
+			end
+		end
+
+		hash
+
+	end
+
+	def self.server_group_xml_for_id(configs, dir, id=nil)
+
+		if id then
+			xml=HttpUtil.get(
+				configs["cloud_servers_vpc_url"]+"/server_groups/#{id}.xml",
+				configs["cloud_servers_vpc_username"],
+				configs["cloud_servers_vpc_password"]
+			)
+		else
+			recent_hash=CloudServersVPC.most_recent_server_group_hash(dir)
+			raise "No server group files exist." if recent_hash.nil?
+			xml=HttpUtil.get(
+				configs["cloud_servers_vpc_url"]+"/server_groups/#{recent_hash['id']}.xml",
+				configs["cloud_servers_vpc_username"],
+				configs["cloud_servers_vpc_password"]
+			)
+
+		end
+
+	end
+
+	def self.most_recent_server_group_hash(dir_pattern)
+        server_groups=[]
+        Dir[dir_pattern].each do  |file|
+            server_groups << CloudServersVPC.server_group_hash(IO.read(file))
+        end
+		if server_groups.size > 0 then
+			server_groups.sort { |a,b| b["id"].to_i <=> a["id"].to_i }[0]
+		else
+			nil
+		end
+	end
+
+	def self.print_server_group(hash)
+
+		puts "Cloud Group ID: #{hash["id"]}"
+		puts "name: #{hash["name"]}"
+		puts "description: #{hash["description"]}"
+		puts "domain name: #{hash["domain-name"]}"
+		puts "VPN gateway IP: #{hash["vpn-gateway"]}"
+		puts "Servers:"
+		hash["servers"].each_pair do |name, attrs|
+			puts "\tname: #{name} (id: #{attrs['cloud-server-id-number']})"
+			puts "\tstatus: #{attrs['status']}"
+			if attrs["openvpn-server"] and attrs["openvpn-server"] == "true" then
+				puts "\tOpenVPN server: #{attrs['openvpn-server']}"
+			end
+			if attrs["error-message"] then
+				puts "\tlast error message: #{attrs['error-message']}"
+			end
+			puts "\t--"
+		end
+
+	end
+
+	def self.server_names(hash)
+
+		names=[]	
+
+		hash["servers"].each_pair do |name, hash|
+			if block_given? then
+				yield name
+			else
+				names << name
+			end	
+		end
+
+		names
+		
+	end
+
+	# default timeout of 20 minutes
+	def self.poll_until_online(group_id, timeout=1200)
+
+		configs=Util.load_configs
+
+		online = false
+		count=0
+		until online or (count*20) >= timeout.to_i do
+			count+=1
+			begin
+				xml=HttpUtil.get(
+					configs["cloud_servers_vpc_url"]+"/server_groups/#{group_id}.xml",
+					configs["cloud_servers_vpc_username"],
+					configs["cloud_servers_vpc_password"]
+				)
+
+				hash=CloudServersVPC.server_group_hash(xml)
+
+				online=true
+				hash["servers"].each_pair do |name, attrs|
+					if ["Pending", "Rebuilding"].include?(attrs["status"]) then
+						online=false
+					end
+					if attrs["status"] == "Failed" then
+						raise "Failed to create server group with the following message: #{attrs['error-message']}"
+					end
+				end
+				if not online
+					yield hash if block_given?
+					sleep 20
+				end
+			rescue EOFError
+			end
+		end
+		if (count*20) >= timeout.to_i then
+			raise "Timeout waiting for server groups to come online."
+		end
+
+	end
+
+	def self.os_types(server_group_hash)
+
+		os_types={}
+		server_group_hash["servers"].each_pair do |name, attrs|
+			os_type = case attrs["image-id"].to_i
+				when 51 # Centos 5.5
+					"centos"
+				when 187811 # Centos 5.4
+					"centos"
+				when 53 # Fedora 13
+					"fedora"
+				when 17 # Fedora 12
+					"fedora"
+				when 14 # RHEL 5.4
+					"rhel"
+				when 62 # RHEL 5.5
+					"rhel"
+				when 49 # Ubuntu 10.04
+					"ubuntu"
+				when 14362 # Ubuntu 9.10
+					"ubuntu"
+				when 8 # Ubuntu 9.04
+					"ubuntu"
+				else
+					"unknown"
+			end
+			if block_given? then
+				yield name, os_type
+			else
+				os_types.store(name, os_type)
+			end
+		end
+		os_types
+
+	end
+
+	def self.rebuild(server_group_hash, server_name)
+
+		configs=Util.load_configs
+
+		server_id=nil
+		image_id=nil
+		server_group_hash["servers"].each_pair do |name, attrs|
+			if name == server_name then
+				raise "Error: Rebuilding the OpenVPN server is not supported at this time." if attrs["openvpn-server"] == "true"
+				server_id=attrs["id"]
+				image_id=attrs["image-id"]
+			end
+		end
+		raise "Unable to find server name: #{server_name}" if server_id.nil?
+	
+		HttpUtil.post(
+			configs["cloud_servers_vpc_url"]+"/servers/#{server_id}/rebuild",
+			{},
+			configs["cloud_servers_vpc_username"],
+			configs["cloud_servers_vpc_password"]
+		)
+
+	end
+
+end
+
+end

data/lib/chef-vpc-toolkit/http_util.rb

@@ -0,0 +1,117 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+module ChefVPCToolkit
+
+module HttpUtil
+
+MULTI_PART_BOUNDARY="jtZ!pZ1973um"
+
+def self.file_upload(url_string, file_data={}, post_data={}, auth_user=nil, auth_password=nil)
+	url=URI.parse(url_string)
+	http = Net::HTTP.new(url.host,url.port)
+	req = Net::HTTP::Post.new(url.path)
+
+	post_arr=[]
+	post_data.each_pair do |key, value|
+		post_arr << "--#{MULTI_PART_BOUNDARY}\r\n"
+		post_arr << "Content-Disposition: form-data; name=\"#{key}\"\r\n"
+		post_arr << "\r\n"
+		post_arr << value
+		post_arr << "\r\n"
+	end
+
+	file_data.each_pair do |name, file|
+		post_arr << "--#{MULTI_PART_BOUNDARY}\r\n"
+		post_arr << "Content-Disposition: form-data; name=\"#{name}\"; filename=\"#{File.basename(file)}\"\r\n"
+		post_arr << "Content-Type: text/plain\r\n"
+		post_arr << "\r\n"
+		post_arr << File.read(file)
+		post_arr << "\r\n--#{MULTI_PART_BOUNDARY}--\r\n"
+	end
+	post_arr << "--#{MULTI_PART_BOUNDARY}--\r\n\r\n"
+
+	req.body=post_arr.join
+
+	if url_string =~ /^https/
+		http.use_ssl = true
+		http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+	end
+	req.basic_auth auth_user, auth_password if auth_user and auth_password
+	req["Content-Type"] = "multipart/form-data, boundary=#{MULTI_PART_BOUNDARY}"
+
+	response = http.request(req)
+	case response
+	when Net::HTTPSuccess
+		return response.body
+	else
+		puts response.body
+		response.error!
+	end
+end
+
+def self.post(url_string, post_data, auth_user=nil, auth_password=nil)
+	url=URI.parse(url_string)
+	http = Net::HTTP.new(url.host,url.port)
+	req = Net::HTTP::Post.new(url.path)
+	if post_data.kind_of?(String) then
+		req.body=post_data
+	elsif post_data.kind_of?(Hash) then
+		req.form_data=post_data
+	else
+		raise "Invalid post data type."
+	end
+	if url_string =~ /^https/
+		http.use_ssl = true
+		http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+	end
+	req.basic_auth auth_user, auth_password if auth_user and auth_password
+	response = http.request(req)
+	case response
+	when Net::HTTPSuccess
+		return response.body
+	else
+		response.error!
+	end
+end
+
+def self.get(url_string, auth_user=nil, auth_password=nil)
+	url=URI.parse(url_string)
+	http = Net::HTTP.new(url.host,url.port)
+	req = Net::HTTP::Get.new(url.path)
+	if url_string =~ /^https/
+		http.use_ssl = true
+		http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+	end
+	req.basic_auth auth_user, auth_password if auth_user and auth_password
+	response = http.request(req)
+	case response
+	when Net::HTTPSuccess
+		return response.body
+	else
+		response.error!
+	end
+end
+
+def self.delete(url_string, auth_user=nil, auth_password=nil)
+	url=URI.parse(url_string)
+	http = Net::HTTP.new(url.host,url.port)
+	req = Net::HTTP::Delete.new(url.path)
+	if url_string =~ /^https/
+		http.use_ssl = true
+		http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+	end
+	req.basic_auth auth_user, auth_password if auth_user and auth_password
+	response = http.request(req)
+	case response
+	when Net::HTTPSuccess
+		return response.body
+	else
+		response.error!
+	end
+end
+
+end
+
+end

data/lib/chef-vpc-toolkit/ssh_util.rb

@@ -0,0 +1,22 @@
+module ChefVPCToolkit
+
+module SshUtil
+
+	def self.remove_known_hosts_ip(ip, known_hosts_file=File.join(ENV['HOME'], ".ssh", "known_hosts"))
+
+		return if ip.nil? or ip.empty?
+
+		existing=IO.read(known_hosts_file)
+		File.open(known_hosts_file, 'w') do |file|
+			existing.each_line do |line|
+				if not line =~ Regexp.new("^#{ip}.*$") then
+						file.write(line)
+				end
+			end
+		end
+
+	end
+
+end
+
+end

data/lib/chef-vpc-toolkit/util.rb

@@ -0,0 +1,56 @@
+require 'yaml'
+
+module ChefVPCToolkit
+
+module Util
+
+	def self.load_configs
+
+		config_file=ENV['CLOUD_TEST_CONFIG_FILE']
+		if config_file.nil? then
+
+			config_file=ENV['HOME']+File::SEPARATOR+".cloud_toolkit.conf"
+			if not File.exists?(config_file) then
+				config_file="/etc/cloud_toolkit.conf"
+			end
+
+		end
+
+		if File.exists?(config_file) then
+			configs=YAML.load_file(config_file)
+			raise_if_nil_or_empty(configs, "cloud_servers_vpc_url")
+			raise_if_nil_or_empty(configs, "cloud_servers_vpc_username")
+			raise_if_nil_or_empty(configs, "cloud_servers_vpc_password")
+			return configs
+		else
+			raise "Failed to load cloud toolkit config file. Please configure /etc/cloud_toolkit.conf or create a .cloud_toolkit.conf config file in your HOME directory."
+		end
+
+	end
+
+	def self.raise_if_nil_or_empty(options, key)
+		if options[key].nil? || options[key].empty? then
+			raise "Please specify a valid #{key.to_s} parameter."
+		end
+	end
+
+	def self.hash_for_group(configs=Util.load_configs)
+
+		id=ENV['GROUP_ID']
+		configs=Util.load_configs
+		hash=nil
+		if id.nil? then
+			hash=CloudServersVPC.most_recent_server_group_hash(File.join(TMP_SG, '*.xml'))
+		else
+			file=File.join(TMP_SG, "#{id}.xml")
+			hash = CloudServersVPC.server_group_hash(IO.read(file))
+		end
+		raise "Create a cloud before running this command." if hash.nil?
+
+		hash
+
+	end
+
+end
+
+end