chef-vpc-toolkit 2.1.0 → 2.2.0

data/lib/chef-vpc-toolkit/cloud-servers-vpc/ssh_public_key.rb

@@ -0,0 +1,25 @@
+module ChefVPCToolkit
+
+module CloudServersVPC
+
+class SshPublicKey
+
+	attr_accessor :id
+	attr_accessor :description
+	attr_accessor :public_key
+	attr_accessor :server_group_id
+
+	def initialize(options={})
+
+		@id=options[:id]
+		@description=options[:description]
+		@public_key=options[:public_key]
+		@server_group_id=options[:server_group_id]
+
+    end
+
+end
+
+end
+
+end

data/lib/chef-vpc-toolkit/cloud-servers-vpc/vpn_network_interface.rb

@@ -0,0 +1,29 @@
+module ChefVPCToolkit
+
+module CloudServersVPC
+
+class VpnNetworkInterface
+
+	attr_accessor :id
+	attr_accessor :vpn_ip_addr
+	attr_accessor :ptp_ip_addr
+	attr_accessor :client_key
+	attr_accessor :client_cert
+	attr_accessor :ca_cert
+
+	def initialize(options={})
+
+		@id=options[:id].to_i
+		@vpn_ip_addr=options[:vpn_ip_addr]
+		@ptp_ip_addr=options[:ptp_ip_addr]
+		@client_key=options[:client_key]
+		@client_cert=options[:client_cert]
+		@ca_cert=options[:ca_cert]
+
+    end
+
+end
+
+end
+
+end

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

@@ -5,12 +5,16 @@ module ChefVPCToolkit
 
 module Util
 
+	@@configs=nil
+
 	def self.hostname
 		Socket.gethostname
 	end
 
 	def self.load_configs
 
+		return @@configs if not @@configs.nil?
+
 		config_file=ENV['CHEF_VPC_TOOLKIT_CONF']
 		if config_file.nil? then
 
@@ -26,36 +30,36 @@ module Util
 			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
+			@@configs=configs
 		else
 			raise "Failed to load cloud toolkit config file. Please configure /etc/chef_vpc_toolkit.conf or create a .chef_vpc_toolkit.conf config file in your HOME directory."
 		end
 
-	end
+		@@configs
 
-	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)
+	def self.load_public_key
 
-		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'))
+		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
-			file=File.join(TMP_SG, "#{id}.xml")
-			hash = CloudServersVPC.server_group_hash(IO.read(file))
+			raise "Failed to load SSH key. Please create a SSH public key pair in your HOME directory."
 		end
-		raise "Create a cloud before running this command." if hash.nil?
 
-		hash
+		pubkey.chomp
 
 	end
 
+	def self.raise_if_nil_or_empty(options, key)
+		if not options or options[key].nil? or options[key].empty? then
+			raise "Please specify a valid #{key.to_s} parameter."
+		end
+	end
+
 end
 
 end

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

@@ -13,28 +13,28 @@ module VpnNetworkManager
 
 	CERT_DIR=File.join(ENV['HOME'], '.pki', 'openvpn')
 
-	def self.configure_gconf(group_hash, client_hash)
+	def self.configure_gconf(group, client)
 
-		ca_cert=File.join(CERT_DIR, group_hash['id'], 'ca.crt')
-		client_cert=File.join(CERT_DIR, group_hash['id'], 'client.crt')
-		client_key=File.join(CERT_DIR, group_hash['id'], 'client.key')
+		ca_cert=File.join(CERT_DIR, group.id.to_s, 'ca.crt')
+		client_cert=File.join(CERT_DIR, group.id.to_s, 'client.crt')
+		client_key=File.join(CERT_DIR, group.id.to_s, 'client.key')
 
-		vpn_interface=client_hash['vpn-network-interfaces'][0]
+		vpn_interface=client.vpn_network_interfaces[0]
 
-		FileUtils.mkdir_p(File.join(CERT_DIR, group_hash['id']))
+		FileUtils.mkdir_p(File.join(CERT_DIR, group.id.to_s))
 		File::chmod(0700, File.join(ENV['HOME'], '.pki'))
 		File::chmod(0700, CERT_DIR)
 
-		File.open(ca_cert, 'w') { |f| f.write(vpn_interface['ca-cert']) }
-		File.open(client_cert, 'w') { |f| f.write(vpn_interface['client-cert']) }
+		File.open(ca_cert, 'w') { |f| f.write(vpn_interface.ca_cert) }
+		File.open(client_cert, 'w') { |f| f.write(vpn_interface.client_cert) }
 		File.open(client_key, 'w') do |f|
-			f.write(vpn_interface['client-key'])
+			f.write(vpn_interface.client_key)
 			f.chmod(0600)
 		end
 
 		xml = Builder::XmlMarkup.new
 		xml.gconfentryfile do |file|
-			file.entrylist({ "base" => "/system/networking/connections/vpc_#{group_hash['id']}"}) do |entrylist|
+			file.entrylist({ "base" => "/system/networking/connections/vpc_#{group.id}"}) do |entrylist|
 
 				entrylist.entry do |entry|
 					entry.key("connection/autoconnect")
@@ -45,7 +45,7 @@ module VpnNetworkManager
 				entrylist.entry do |entry|
 					entry.key("connection/id")
 					entry.value do |value|
-						value.string("VPC Group: #{group_hash['id']}")
+						value.string("VPC Group: #{group.id}")
 					end
 				end
 				entrylist.entry do |entry|
@@ -83,7 +83,7 @@ module VpnNetworkManager
 					entry.key("ipv4/dns")
 					entry.value do |value|
 						value.list("type" => "int") do |list|
-							ip=IPAddr.new(group_hash['vpn-network'].chomp("0")+"1")
+							ip=IPAddr.new(group.vpn_network.chomp("0")+"1")
 							list.value do |lv|
 								lv.int(ip_to_integer(ip.to_s))
 							end
@@ -95,7 +95,7 @@ module VpnNetworkManager
 					entry.value do |value|
 						value.list("type" => "string") do |list|
 							list.value do |lv|
-								lv.string(group_hash['domain-name'])
+								lv.string(group.domain_name)
 							end
 						end
 					end
@@ -170,7 +170,7 @@ module VpnNetworkManager
 				entrylist.entry do |entry|
 					entry.key("vpn/remote")
 					entry.value do |value|
-						value.string(group_hash['vpn-gateway'])
+						value.string(group.vpn_gateway_ip)
 					end
 				end
 				entrylist.entry do |entry|
@@ -198,7 +198,7 @@ module VpnNetworkManager
 	end
 
 	def self.delete_certs(server_group_id)
-		FileUtils.rm_rf(File.join(CERT_DIR, server_group_id))
+		FileUtils.rm_rf(File.join(CERT_DIR, server_group_id.to_s))
 	end
 
 	def self.connect(server_group_id)
@@ -211,7 +211,7 @@ module VpnNetworkManager
 
 	def self.ip_to_integer(ip_string)
 		return 0 if ip_string.nil?
-		ip_arr=ip_string.each(".").collect{ |s| s.chomp(".").to_i}
+		ip_arr=ip_string.split(".").collect{ |s| s.to_i }
 		return ip_arr[0] + ip_arr[1]*2**8 + ip_arr[2]*2**16 + ip_arr[3]*2**24
 	end
 

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

@@ -0,0 +1,15 @@
+module ChefVPCToolkit
+
+module XMLUtil
+
+	def self.element_text(dom, name)
+		if dom.elements[name]
+			return dom.elements[name].text
+		else
+			return nil
+		end
+	end
+
+end
+
+end

data/rake/chef_vpc_toolkit.rake

@@ -1,4 +1,5 @@
 #require 'chef-cloud-toolkit'
+include ChefVPCToolkit::CloudServersVPC
 
 namespace :group do
 	TMP_SG=File.join(CHEF_VPC_PROJECT, 'tmp', 'server_groups')
@@ -7,41 +8,31 @@ namespace :group do
 	directory TMP_SG
 	directory TMP_CLIENTS
 
-	desc "Create a new group of cloud servers"
-	task :create => [ TMP_SG, "chef:validate_json" ] do
-
-		request=CloudServersVPC.server_group_xml
-		configs=Util.load_configs
+	task :init => [TMP_SG, TMP_CLIENTS]
 
-		resp=HttpUtil.post(
-			configs["cloud_servers_vpc_url"]+"/server_groups.xml",
-			request,
-			configs["cloud_servers_vpc_username"],
-			configs["cloud_servers_vpc_password"]
-		)
+	desc "Create a new group of cloud servers"
+	task :create => [ "init", "chef:validate_json" ] do
 
-		hash=CloudServersVPC.server_group_hash(resp)	
-		out_file=hash["id"]+".xml"
-		File.open(File.join(TMP_SG, out_file), 'w') do |f|
-			f.chmod(0600)
-			f.write(resp)
-		end
-		puts "Cloud server group ID #{hash['id']} created."
+		sg=ServerGroup.from_json_config(IO.read(ServerGroup::CONFIG_FILE))
+		sg=ServerGroup.create(sg)
+		puts "Server group ID #{sg.id} created."
 		
 	end
 
-	desc "List existing cloud server groups"
-	task :list => TMP_SG do
+	desc "List existing cloud server groups."
+	task :list => "init" do
 
-		server_groups=[]
-		Dir[File.join(TMP_SG, '*.xml')].each do  |file|
-			server_groups << CloudServersVPC.server_group_hash(IO.read(file))
+		server_groups=nil
+		if ENV['REMOTE']
+			server_groups=ServerGroup.list(:source => "remote")
+		else
+			server_groups=ServerGroup.list(:source => "cache")
 		end
 		if server_groups.size > 0
-			puts "Cloud server groups:"
-			server_groups.sort { |a,b| b["id"] <=> a["id"] }.each do |sg|
-				gw=sg['vpn-gateway'].nil? ? "" : " (#{sg['vpn-gateway']})"
-				puts "\t#{sg['id']}: #{sg['name']}#{gw}"
+			puts "Server groups:"
+			server_groups.sort { |a,b| b.id <=> a.id }.each do |sg|
+				gw=sg.vpn_gateway_ip.nil? ? "" : " (#{sg.vpn_gateway_ip})"
+				puts "\t :id => #{sg.id}, :name => #{sg.name}, :owner => #{sg.owner_name}#{gw}"
 			end
 		else
 			puts "No server groups."
@@ -49,37 +40,39 @@ namespace :group do
 
 	end
 
-	desc "Print information for a cloud server group"
-	task :show => TMP_SG do
-		id=ENV['GROUP_ID']
-		configs=Util.load_configs
-		xml=CloudServersVPC.server_group_xml_for_id(configs, File.join(TMP_SG, '*.xml'), id)
+	desc "Join a group by caching the server group data to disk."
+	task :join => [ "init" ] do
 
-		hash=CloudServersVPC.server_group_hash(xml)
-		File.open(File.join(TMP_SG, "#{hash['id']}.xml"), 'w') do |f|
-			f.chmod(0600)
-			f.write(xml)
+		id=ENV['GROUP_ID']
+		if id.nil?
+			ENV['REMOTE']="true"
+			Rake::Task['group:list'].invoke
+			puts "Enter ID of group to join:"
+			id=STDIN.gets.chomp
 		end
-		CloudServersVPC.print_server_group(hash)
+
+		sg=ServerGroup.fetch(:id => id, :source => "remote")
+		sg.cache_to_disk
+		sg.pretty_print
+
+	end
+
+	desc "Print information for a cloud server group"
+	task :show => [ "init" ] do
+
+		sg=ServerGroup.fetch
+		sg.cache_to_disk
+		sg.pretty_print
 
 	end
 
 	desc "Delete a cloud server group"
-	task :delete => "vpn:delete" do
-		id=ENV['GROUP_ID']
-		configs=Util.load_configs
-		hash=Util.hash_for_group
-		if id.nil? then
-			id=hash["id"]
-		end
-		SshUtil.remove_known_hosts_ip(hash["vpn-gateway"])	
-		puts "Deleting cloud server group ID: #{id}."
-		HttpUtil.delete(
-			configs["cloud_servers_vpc_url"]+"/server_groups/#{id}.xml",
-			configs["cloud_servers_vpc_username"],
-			configs["cloud_servers_vpc_password"]
-		)
-		File.delete(File.join(TMP_SG, "#{id}.xml"))
+	task :delete => ["init", "vpn:delete"] do
+
+		sg=ServerGroup.fetch(:source => "cache")
+		SshUtil.remove_known_hosts_ip(sg.vpn_gateway_ip)
+		puts "Deleting cloud server group ID: #{sg.id}."
+		sg.delete
 
 	end
 
@@ -90,28 +83,58 @@ namespace :group do
 	end
 
 	desc "Poll/loop until a server group is online"
-	task :poll do
-		timeout=ENV['TIMEOUT']
-		if timeout.nil? or timeout.empty? then
-			timeout=1500 # defaults to 24 minutes
-		end
-		hash=Util.hash_for_group
+	task :poll => ["init"] do
+
+		sg=ServerGroup.fetch
+
 		puts "Polling for server(s) to come online (this may take a couple minutes)..."
-		servers=nil
+		old_group_xml=nil
 		vpn_gateway=nil
-		CloudServersVPC.poll_until_online(hash["id"], timeout) do |server_group_hash|
-			if servers != server_group_hash then
-				servers = server_group_hash
-				vpn_gateway = server_group_hash["vpn-gateway"] if server_group_hash["vpn-gateway"]
+		sg.poll_until_online do |server_group|
+			if old_group_xml != server_group.to_xml then
+				old_group_xml = server_group.to_xml
+				vpn_gateway = server_group.vpn_gateway_ip if server_group.vpn_gateway_ip
 				if not vpn_gateway.nil? and not vpn_gateway.empty? then
 					SshUtil.remove_known_hosts_ip(vpn_gateway)
 				end
-				ENV["GROUP_ID"]=server_group_hash['id']
-				CloudServersVPC.print_server_group(server_group_hash)
+				server_group.pretty_print
 			end
 		end
 		Rake::Task['group:show'].invoke
-		puts "Cloud server group online."
+		puts "Server group online."
+	end
+
+	desc "Add a single server to the server group."
+	task :add_server do
+		server_name=ENV['SERVER_NAME']
+		image_id=ENV['IMAGE_ID']
+		flavor_id=ENV['FLAVOR_ID']
+		raise "Please specify a SERVER_NAME." if server_name.nil?
+		raise "Please specify a IMAGE_ID." if image_id.nil?
+		raise "Please specify a FLAVOR_ID." if flavor_id.nil?
+		group=ServerGroup.fetch(:source => "cache")
+		server=Server.new(
+			:name => server_name,
+			:description => server_name,
+			:image_id => image_id,
+			:flavor_id => flavor_id,
+			:server_group_id => group.id
+		)
+		server=Server.create(server)
+		group=ServerGroup.fetch
+		group.cache_to_disk
+		puts "Server ID #{server.id} created."
+	end
+
+	desc "Delete a single server from the server group."
+	task :delete_server do
+		server_name=ENV['SERVER_NAME']
+		raise "Please specify a SERVER_NAME." if server_name.nil?
+		group=ServerGroup.fetch(:source => "cache")
+		server=group.server(server_name)
+		raise "Server with name '#{server_name}' does not exist." if server.nil?
+		server.delete
+		puts "Server '#{server_name}' deleted."
 	end
 
 end
@@ -119,16 +142,13 @@ end
 namespace :server do
 
 	desc "Rebuild a server in a server group."
-	task :rebuild => TMP_SG do
-		id=ENV['GROUP_ID']
+	task :rebuild do
 		server_name=ENV['SERVER_NAME']
 		raise "Please specify a SERVER_NAME." if server_name.nil?
-		configs=Util.load_configs
-
-		xml=CloudServersVPC.server_group_xml_for_id(configs, File.join(TMP_SG, '*.xml'), id)
-		hash=CloudServersVPC.server_group_hash(xml)
-		CloudServersVPC.rebuild(hash, server_name)
-
+		group=ServerGroup.fetch
+		server=group.server(server_name)
+		raise "Server with name '#{server_name}' does not exist." if server.nil?
+		server.rebuild
 	end
 
 end
@@ -148,12 +168,19 @@ namespace :chef do
 
 		configs=ChefInstaller.load_configs
 		configs.merge!(Util.load_configs)
-		hash=Util.hash_for_group(configs)
-		os_types=CloudServersVPC.os_types(hash)
-		configs["ssh_gateway_ip"]=hash["vpn-gateway"]
-		client_validation_key=ChefInstaller.install_chef_server(configs, os_types)
-		ChefInstaller.create_databags(configs)
-		ChefInstaller.install_chef_clients(configs, client_validation_key, os_types)
+		group=ServerGroup.fetch(:source => "cache")
+		configs["ssh_gateway_ip"]=group.vpn_gateway_ip
+
+		server_name=ENV['SERVER_NAME']
+		if server_name.nil? then
+			client_validation_key=ChefInstaller.install_chef_server(configs, group.os_types)
+			ChefInstaller.create_databags(configs)
+			ChefInstaller.install_chef_clients(configs, client_validation_key, group.os_types)
+		else
+			raise "Server with name '#{server_name}' does not exist." if group.server(server_name).nil?
+			client_validation_key=ChefInstaller.client_validation_key(configs)
+			ChefInstaller.install_chef_client(configs, server_name, client_validation_key, group.os_types[server_name])
+		end
 
 	end
 
@@ -161,35 +188,56 @@ namespace :chef do
 	task :tail_logs do
 		
 		lines=ENV['LINES']
+		server=ENV['SERVER_NAME']
+		if server && server.empty?
+			server=nil
+		end
 		if lines.nil? or lines.empty? then
 			lines=100
 		end
 		configs=ChefInstaller.load_configs
-		hash=Util.hash_for_group(configs)
-		CloudServersVPC.server_names(hash) do |name|
+		group=ServerGroup.fetch(:source => "cache")
+		group.server_names do |name|
+			if server && server != name
+				next
+			end
+
 			puts "================================================================================"
 			puts "SERVER NAME: #{name}"
-			puts ChefInstaller.tail_log(hash["vpn-gateway"], name, "/var/log/chef/client.log", lines)
+			puts ChefInstaller.tail_log(group.vpn_gateway_ip, name, "/var/log/chef/client.log", lines)
 		end
 
 	end
 
-	desc "Sync the local cookbook repos directory to the Chef server."
-	task :sync_repos do
+	#Deprecated
+	task :sync_repos => "chef:push_repos"
+
+	desc "Push/Extract cookbook repos to the server group."
+	task :push_repos do
 
 		configs=ChefInstaller.load_configs
-		hash=Util.hash_for_group(configs)
-		configs["ssh_gateway_ip"]=hash["vpn-gateway"]
+		group=ServerGroup.fetch(:source => "cache")
+		configs["ssh_gateway_ip"]=group.vpn_gateway_ip
 		ChefInstaller.rsync_cookbook_repos(configs)
 
 	end
 
+	desc "Pull cookbook repos from the server group to the local project."
+	task :pull_repos do
+
+		configs=ChefInstaller.load_configs
+		group=ServerGroup.fetch(:source => "cache")
+		configs["ssh_gateway_ip"]=group.vpn_gateway_ip
+		ChefInstaller.pull_cookbook_repos(configs)
+
+	end
+
 	desc "Create/Update databags on the Chef server."
 	task :databags do
 
 		configs=ChefInstaller.load_configs
-		hash=Util.hash_for_group(configs)
-		configs["ssh_gateway_ip"]=hash["vpn-gateway"]
+		group=ServerGroup.fetch(:source => "cache")
+		configs["ssh_gateway_ip"]=group.vpn_gateway_ip
 		ChefInstaller.create_databags(configs)
 
 	end
@@ -203,9 +251,8 @@ namespace :share do
 
 		if File.exists?("#{CHEF_VPC_PROJECT}/share/") then
 			puts "Syncing share data."
-			configs=Util.load_configs
-			hash=Util.hash_for_group(configs)
-			system("rsync -azL '#{CHEF_VPC_PROJECT}/share/' root@#{hash['vpn-gateway']}:/mnt/share/")
+			group=ServerGroup.fetch(:source => "cache")
+			system("rsync -azL '#{CHEF_VPC_PROJECT}/share/' root@#{group.vpn_gateway_ip}:/mnt/share/")
 		end
 
 	end
@@ -218,90 +265,71 @@ namespace :vpn do
 	task :connect do
 
 		puts "Creating VPN Connection..."
-		configs=Util.load_configs
-		group_hash=Util.hash_for_group(configs)
-		if not File.exists?(File.join(TMP_CLIENTS, group_hash['id']+'.xml')) then
+		group=ServerGroup.fetch(:source => "cache")
+		if not File.exists?(File.join(TMP_CLIENTS, "#{group.id}.xml")) then
 			Rake::Task['vpn:create_client'].invoke
 			Rake::Task['vpn:poll_client'].invoke
 		end
-		client_hash=CloudServersVPC.client_hash(IO.read(File.join(TMP_CLIENTS, group_hash['id']+'.xml')))
-		ChefVPCToolkit::VpnNetworkManager.configure_gconf(group_hash, client_hash)
-		ChefVPCToolkit::VpnNetworkManager.connect(group_hash['id'])
+		client=Client.fetch(:id => group.id, :source => "cache")
+		ChefVPCToolkit::VpnNetworkManager.configure_gconf(group, client)
+		ChefVPCToolkit::VpnNetworkManager.connect(group.id)
 
 	end
 
 	desc "Disconnect from a server group as a VPN client."
 	task :disconnect do
 
-		configs=Util.load_configs
-		group_hash=Util.hash_for_group(configs)
-		ChefVPCToolkit::VpnNetworkManager.disconnect(group_hash['id'])
+		group=ServerGroup.fetch(:source => "cache")
+		ChefVPCToolkit::VpnNetworkManager.disconnect(group.id)
 
-		vpn_server_ip=group_hash["vpn-network"].chomp("0")+"1"
+		vpn_server_ip=group.vpn_network.chomp("0")+"1"
 		SshUtil.remove_known_hosts_ip(vpn_server_ip)
-		SshUtil.remove_known_hosts_ip("#{CloudServersVPC.vpn_server_name(group_hash)},#{vpn_server_ip}")
+		SshUtil.remove_known_hosts_ip("#{group.vpn_gateway_name},#{vpn_server_ip}")
 
 	end
 
 	desc "Delete VPN config information."
 	task :delete do
 
-		configs=Util.load_configs
-		group_hash=Util.hash_for_group(configs)
-		group_id=group_hash['id']
-		ChefVPCToolkit::VpnNetworkManager.unset_gconf_config(group_id)
-		ChefVPCToolkit::VpnNetworkManager.delete_certs(group_id)
-		client_file=File.join(TMP_CLIENTS, "#{group_id}.xml")
+		group=ServerGroup.fetch(:source => "cache")
+		ChefVPCToolkit::VpnNetworkManager.unset_gconf_config(group.id)
+		ChefVPCToolkit::VpnNetworkManager.delete_certs(group.id)
 
-		vpn_server_ip=group_hash["vpn-network"].chomp("0")+"1"
+		vpn_server_ip=group.vpn_network.chomp("0")+"1"
 		SshUtil.remove_known_hosts_ip(vpn_server_ip)
-		SshUtil.remove_known_hosts_ip("#{CloudServersVPC.vpn_server_name(group_hash)},#{vpn_server_ip}")
-
-		if File.exists?(client_file) then
-			File.delete(client_file)
+		SshUtil.remove_known_hosts_ip("#{group.vpn_gateway_name},#{vpn_server_ip}")
+		begin
+			client=Client.fetch(:id => group.id, :source => "cache")
+			client.delete if client
+		rescue
 		end
 
 	end
 
 	desc "Create a new VPN client."
-	task :create_client => [ TMP_CLIENTS ] do
-
-		configs=Util.load_configs
-		group_hash=Util.hash_for_group(configs)
+	task :create_client do
 
+		group=ServerGroup.fetch(:source => "cache")
 		vpn_client_name=Util.hostname
+		configs=Util.load_configs
 		if not configs['vpn_client_name'].nil? then
 			vpn_client_name=configs['vpn_client_name']
 		end
 
-		xml=CloudServersVPC.create_client(group_hash, vpn_client_name)
-		client_hash=CloudServersVPC.client_hash(xml)
-		out_file=group_hash["id"]+".xml"
-		File.open(File.join(TMP_CLIENTS, out_file), 'w') do |f|
-			f.chmod(0600)
-			f.write(xml)
-		end
-		puts "Client ID #{client_hash['id']} created."
+		client=Client.create(group, vpn_client_name)
+		puts "Client ID #{client.id} created."
 		
 	end
 
 	desc "Poll until a client is online"
-	task :poll_client => TMP_CLIENTS do
-		timeout=ENV['VPN_CLIENT_TIMEOUT']
-		if timeout.nil? or timeout.empty? then
-			timeout=300 # defaults to 5 minutes
-		end
-		configs=Util.load_configs
-		group_hash=Util.hash_for_group
-		client_hash=CloudServersVPC.client_hash(IO.read(File.join(TMP_CLIENTS, group_hash['id']+'.xml')))
+	task :poll_client do
+
+		group=ServerGroup.fetch(:source => "cache")
+		client=Client.fetch(:id => group.id, :source => "cache")
 		puts "Polling for client VPN cert to be created (this may take a minute)...."
-		CloudServersVPC.poll_client(client_hash["id"], timeout)
-		xml=CloudServersVPC.client_xml_for_id(configs, TMP_CLIENTS, client_hash["id"])
-		out_file=group_hash["id"]+".xml"
-		File.open(File.join(TMP_CLIENTS, out_file), 'w') do |f|
-			f.chmod(0600)
-			f.write(xml)
-		end
+		client.poll_until_online
+		client=Client.fetch(:id => client.id, :remote => "cache")
+		client.cache_to_disk
 		puts "Client VPN certs are ready to use."
 
 	end
@@ -309,9 +337,14 @@ namespace :vpn do
 end
 
 desc "SSH into the most recently created VPN gateway server."
-task :ssh do
-	hash=Util.hash_for_group
-	exec("ssh -o \"StrictHostKeyChecking no\" root@#{hash['vpn-gateway']}")
+task :ssh => 'group:init' do
+
+	sg=ServerGroup.fetch(:source => "cache")
+	args=ARGV[1, ARGV.length].join(" ")
+	if ARGV[1] and ARGV[1].start_with?('GROUP_ID=')
+		args=ARGV[2, ARGV.length].join(" ")
+	end
+	exec("ssh -o \"StrictHostKeyChecking no\" root@#{sg.vpn_gateway_ip} #{args}")
 end
 
 desc "Create a server group, install chef, sync share data and cookbooks."
@@ -319,7 +352,7 @@ task :create do
 
 	Rake::Task['group:create'].invoke
 	Rake::Task['group:poll'].invoke
-	Rake::Task['chef:sync_repos'].invoke
+	Rake::Task['chef:push_repos'].invoke
 	Rake::Task['chef:install'].invoke
 	#Rake::Task['share:sync'].invoke
 
@@ -332,9 +365,9 @@ task :rechef => [ "server:rebuild", "group:poll" ] do
 
 	configs=ChefInstaller.load_configs
 	configs.merge!(Util.load_configs)
-	hash=Util.hash_for_group(configs)
-	os_types=CloudServersVPC.os_types(hash)
-	configs["ssh_gateway_ip"]=hash["vpn-gateway"]
+	group=ServerGroup.fetch
+	os_types=group.os_types
+	configs["ssh_gateway_ip"]=group.vpn_gateway_ip
 	ChefInstaller.knife_readd_node(configs, server_name)
 	client_validation_key=ChefInstaller.client_validation_key(configs)
 	ChefInstaller.install_chef_client(configs, server_name, client_validation_key, os_types[server_name])
@@ -349,7 +382,7 @@ desc "Print help and usage information"
 task :usage do
 
 	puts ""
-	puts "Cloud Toolkit Version: #{ChefVPCToolkit::Version::VERSION}"
+	puts "Chef VPC Toolkit Version: #{ChefVPCToolkit::Version::VERSION}"
 	puts ""
 	puts "The following tasks are available:"
 
@@ -357,32 +390,38 @@ task :usage do
 	puts "----"
 	puts "Example commands:"
 	puts ""
-	puts "\t- Create a new cloud server group, upload cookbooks, install chef\n\ton all the nodes, sync share data and cookbooks."
+	puts "\t- Create a new server group, upload cookbooks, install chef\n\ton all the nodes, sync share data and cookbooks."
 	puts ""
 	puts "\t\t$ rake create"
 
 	puts ""
-	puts "\t- List your currently running cloud server groups."
+	puts "\t- List your currently running server groups."
 	puts ""
 	puts "\t\t$ rake group:list"
 
 	puts ""
-	puts "\t- SSH into the current (most recently created) cloud server group"
+	puts "\t- List all remote groups using a common Cloud Servers VPC account."
+	puts ""
+	puts "\t\t$ rake group:list REMOTE=true"
+
+
+	puts ""
+	puts "\t- SSH into the current (most recently created) server group."
 	puts ""
 	puts "\t\t$ rake ssh"
 
 	puts ""
-	puts "\t- SSH into a cloud server group with an ID of 3"
+	puts "\t- SSH into a server group with an ID of 3."
 	puts ""
 	puts "\t\t$ rake ssh GROUP_ID=3"
 
 	puts ""
-	puts "\t- Delete the cloud server group with an ID of 3"
+	puts "\t- Delete the server group with an ID of 3."
 	puts ""
 	puts "\t\t$ rake group:delete GROUP_ID=3"
 
 	puts ""
-	puts "\t- Rebuild/Re-Chef a server in the most recently created cloud\n\tserver group"
+	puts "\t- Rebuild/Re-Chef a server in the most recently created server group."
 	puts ""
 	puts "\t\t$ rake rechef SERVER_NAME=db1"