knife-cloudstack-fog 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cabd0497918fc2d74a07bf227823c06843871e11
-  data.tar.gz: 040fd195030f8066160240c34b4dcaa123ff1184
+  metadata.gz: 9783b50b32ad22099bd01c21caa5cceca1717a28
+  data.tar.gz: e40480ac878ead9a2606bbe1e2f189d2347acc70
 SHA512:
-  metadata.gz: 5ba61637614a9af0a1a4f707a0d6345117924daf03bd5ca31e92099db48cd0a95604785bbedb2089fcffaeb84787c04e0d8ff8aae6b3b84c49052c859f72aaf6
-  data.tar.gz: ec4edf39407225b490845590148436e51c293490b928f6c6ed94f3d38780f63d604d69a70b00531f8111822fa7cc3e69982019c240987511a80bfbdcb9e2b4f1
+  metadata.gz: 42e5db01915d4693be9301d05b6ec80c6d2a337526ad2af145b7366ea9bb7caf2e51bd447cd38eafe3fd95a82ac08c8069201ab7a9fcbd39754af0f38820954c
+  data.tar.gz: cf73a2525989a2dc5a16a6706f694c83f42e6d81f6a0be9d45b443ae2dd4f627513b4843c219458299ba4cf5b3677ac35c356d33f7700ad3cf1dbb6ab2feea66

data/README.rdoc

@@ -13,10 +13,6 @@ This is the unofficial Opscode Knife plugin for Apache CloudStack / Citrix Cloud
 Be sure you are running the latest version Chef. Versions earlier than 0.10.0 don't support plugins:
 
     $ gem install chef
-
-Also ensure you are running the latest version of Fog. Versions earlier than 1.3.1 don't fully support Cloudstack Cloud:
-    
-    $ gem update fog 
  
 This plugin is distributed as a Ruby Gem. To install it, run:
 

data/lib/chef/knife/cloudstack_keypair_create.rb

@@ -62,7 +62,7 @@ class Chef
 
         case mode
         when 'register'
-          response = connection.register_ssh_key_pair(options)
+          response = connection.register_ssh_key_pair(options['publickey'], options['name'])
           sshkeypair = response['registersshkeypairresponse']['keypair']
 
           sshkeypair_list = [

data/lib/chef/knife/cloudstack_network_create.rb

@@ -78,13 +78,14 @@ class Chef
         validate!
 
         netoptions = {}
+        mandatoryoptions = {}
 
           if (locate_config_value(:name).nil? || locate_config_value(:networkoffering).nil? || locate_config_value(:zone).nil?)
             puts "Name (-n), Service Offering ID (-o), and Zone ID (-z) are required."
           else
-            netoptions['name'] = locate_config_value(:name)
-            netoptions['networkofferingid'] = locate_config_value(:networkoffering)
-            netoptions['zoneid'] = locate_config_value(:zone)
+            mandatoryoptions['name'] = locate_config_value(:name)
+            mandatoryoptions['networkofferingid'] = locate_config_value(:networkoffering)
+            mandatoryoptions['zoneid'] = locate_config_value(:zone)
 
             if locate_config_value(:startip) != nil
               netoptions['startip'] = locate_config_value(:startip)
@@ -107,14 +108,14 @@ class Chef
             end
 
             if locate_config_value(:displaytext) != nil
-              netoptions['displaytext'] = locate_config_value(:displaytext)
+              mandatoryoptions['displaytext'] = locate_config_value(:displaytext)
             else
-              netoptions['displaytext'] = locate_config_value(:name)
+              mandatoryoptions['displaytext'] = locate_config_value(:name)
             end
 
             Chef::Log.debug("Options: #{netoptions}")
 
-            response = connection.create_network(netoptions)
+            response = connection.create_network(mandatoryoptions['displaytext'], mandatoryoptions['name'], mandatoryoptions['networkofferingid'], mandatoryoptions['zoneid'], netoptions)
 
             Chef::Log.debug("API Response: #{response}")
 

data/lib/chef/knife/cloudstack_server_create.rb

@@ -23,491 +23,516 @@ require 'chef/json_compat'
 require 'chef/knife/cloudstack_base'
 require 'chef/knife/ssh'
 Chef::Knife::Ssh.load_deps
+# require 'pry'
 
 class Chef
-	class Knife
-		class CloudstackServerCreate < Knife
-
-			include Knife::CloudstackBase
-
-			banner "knife cloudstack server create -s SERVICEID -t TEMPLATEID -z ZONEID (options)"
-
-			option  :cloudstack_serviceid,
-						:short => "-s SERVICEID",
-						:long => "--serviceid SERVICEID",
-						:description => "The CloudStack service offering ID."
-
-			option  :cloudstack_templateid,
-						:short => "-t TEMPLATEID",
-						:long => "--templateid TEMPLATEID",
-						:description => "The CloudStack template ID for the server."
-
-			option  :cloudstack_zoneid,
-						:short => "-Z ZONEID",
-						:long => "--zoneid ZONE",
-						:description => "The CloudStack zone ID for the server."
-
-			option  :cloudstack_networkids,
-						:short => "-w NETWORKIDS",
-						:long => "--networkids NETWORKIDS",
-						:description => "Comma separated list of CloudStack network IDs.",
-						:proc => lambda { |n| n.split(/[\s,]+/) },
-						:default => []
-
-			option  :cloudstack_groupids,
-						:short => "-g SECURITYGROUPIDS",
-						:long => "--groupids SECURITYGROUPIDS",
-						:description => "Comma separated list of CloudStack Security Group IDs.",
-						:proc => lambda { |n| n.split(/[\s,]+/) },
-						:default => []
-
-			option  :cloudstack_groupnames,
-						:short => "-G SECURITYGROUPNAMES",
-						:long => "--groupnames SECURITYGROUPNAMES",
-						:description => "Comma separated list of CloudStack Security Group names. Each group name must be encapuslated in quotes if it contains whitespace.",
-						:proc => lambda { |n| n.split(/[\s,]+/) },
-						:default => []
-
-			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  :ssh_user,
-						:short => "-x USERNAME",
-						:long => "--ssh-user USERNAME",
-						:description => "The ssh username",
-						:default => 'root'
-
-			option  :ssh_password,
-						:short => "-P PASSWORD",
-						:long => "--ssh-password PASSWORD",
-						:description => "The ssh password"
-
-			option  :identity_file,
-						:short => "-i PRIVATE_KEY_FILE",
-						:long => "--identity-file PRIVATE_KEY_FILE",
-						:description => "The Private key file for authenticating SSH session. --keypair option is also needed."
-
-			option 	:ssh_port,
-						:short => "-p PORT",
-						:long => "--ssh-port PORT",
-						:description => "The port which SSH should be listening on. If unspecified, will default to 22."
-
-			option  :server_display_name,
-						:short => "-N NAME",
-						:long => "--display-name NAME",
-						:description => "The instance display name"
-
-			option  :host_name,
-						:short => "-H NAME",
-						:long => "--hostname NAME",
-						:description => "The instance host name"
-
-			option  :keypair,
-						:short => "-k KEYPAIR",
-						:long => "--keypair KEYPAIR",
-						:description => "The CloudStack Key Pair to use for SSH key authentication."
-
-			option  :diskoffering,
-						:short => "-D DISKOFFERINGID",
-						:long => "--diskoffering DISKOFFERINGID",
-						:description => "Specifies either the Disk Offering ID for the ROOT disk for an ISO template, or a DATA disk."
-
-			option  :size,
-						:long => "--size SIZE",
-						:description => "Specifies the arbitrary Disk Size for DATADISK volume in GB. Must be passed with custom size Disk Offering ID."
-
-			option 	:random_ssh_port,
-						:long => "--random-ssh-port",
-						:description => "Map a random, unused high-level port to 22 for SSH and creates a port forward for this mapping. For Isolated Networking and VPC only."
-
-			option 	:ssh_gateway,
-						:short => "-W GATEWAY",
-						:long => "--ssh-gateway GATEWAY",
-						:description => "The ssh gateway server. Connection is defined as USERNAME@HOST:PORT",
-						:proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
-
-			# def bootstrap_for_node(host, user, password)
-			def bootstrap_for_node(server, ssh_host)
-				host = server["name"]
-				user = config[:ssh_user]
-				password = server["password"]
-				Chef::Log.debug("Bootstrap host: #{host}")
-				Chef::Log.debug("Bootstrap user: #{user}")
-				Chef::Log.debug("Bootstrap pass: #{password}")
-				bootstrap = Chef::Knife::Bootstrap.new
-				bootstrap.name_args = [ssh_host]
-				bootstrap.config[:run_list] = config[:run_list]
-				bootstrap.config[:ssh_user] = user
-				bootstrap.config[:ssh_password] = password
-				bootstrap.config[:ssh_gateway] = config[:ssh_gateway]
-				bootstrap.config[:identity_file] = locate_config_value(:identity_file)
-				bootstrap.config[:chef_node_name] = config[:server_display_name] if config[:server_display_name]
-				bootstrap.config[:prerelease] = config[:prerelease]
-				bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
-				bootstrap.config[:distro] = locate_config_value(:distro)
-				bootstrap.config[:use_sudo] = true
-				bootstrap.config[:template_file] = locate_config_value(:template_file)
-				bootstrap.config[:environment] = config[:environment]
-				# may be needed for vpc_mode
-				bootstrap.config[:no_host_key_verify] = config[:no_host_key_verify]
-				begin
-					bootstrap
-				rescue
-					sleep @initial_sleep_delay
-					retry
-				end
-			end
-
-			def check_port_available(public_port, ipaddressid)
-				Chef::Log.debug("Checking if port #{public_port} is available.")
-				pubport = public_port.to_i
-				port_forward_rules_query = connection.list_port_forwarding_rules({'ipaddressid' => ipaddressid })
-				port_rules = port_forward_rules_query['listportforwardingrulesresponse']['portforwardingrule']
-				is_available = true
-				some_possible_rules = port_rules.select { |rule| rule['publicport'].to_i <= pubport }
-				possible_rules = some_possible_rules.select { |rule| rule['publicendport'].to_i >= pubport }
-				possible_rules.each do |rule|
-					startport = rule['publicport'].to_i
-					endport = rule['publicendport'].to_i
-					Chef::Log.debug("Determining if #{pubport} is between #{startport} and #{endport}.")
-					if (endport != startport)
-						if pubport.between?(startport, endport)
-							is_available = false
-						else
-							is_available = true
-						end
-					else
-						if (pubport == startport)
-							is_available = false
-						else
-							is_available = true
-						end
-					end
-				end
-				return is_available
-			end
-
-			def add_port_forward(public_start_port, public_end_port, server_id, ipaddressid, privateport)
-				pfwdops = {}
-				pfwdops['ipaddressid'] = ipaddressid
-				pfwdops['privateport'] = privateport
-				pfwdops['protocol'] = "TCP"
-				pfwdops['virtualmachineid'] = server_id
-				pfwdops['openfirewall'] = "true"
-				pfwdops['publicport'] = public_start_port
-				pfwdops['publicendport'] = public_end_port
-				rule_create_job = connection.create_port_forwarding_rule(pfwdops)
-				print "#{ui.color("Creating port forwarding rule.", :cyan)}"
-				while (@connection.query_async_job_result({'jobid' => rule_create_job['createportforwardingruleresponse']['jobid']})['queryasyncjobresultresponse'].fetch('jobstatus') == 0)
-					print("#{ui.color(".", :cyan)}")
-					sleep 2
-				end
-				print("\n")
-			end
-
-			def create_server_def
-				server_def = {
-					"templateid" => locate_config_value(:cloudstack_templateid),
-					"serviceofferingid" => locate_config_value(:cloudstack_serviceid),
-					"zoneid" => locate_config_value(:cloudstack_zoneid)
-				}
-
-				if locate_config_value(:server_display_name) != nil
-					server_def["displayname"] = locate_config_value(:server_display_name)
-				end
-
-				if locate_config_value(:host_name) != nil
-					server_def["name"] = locate_config_value(:host_name)
-				end
-
-				network_ids = []
-				if locate_config_value(:cloudstack_networkids) != []
-					cs_networkids = locate_config_value(:cloudstack_networkids)
-					cs_networkids.each do |id|
-						network_ids.push(id)
-					end
-					server_def["networkids"] = network_ids
-				end
-
-				security_groups = []
-				if locate_config_value(:cloudstack_groupids) != []
-					cs_groupids = locate_config_value(:cloudstack_groupids)
-					cs_groupids.each do |id|
-						security_groups.push(id)
-					end
-					server_def["securitygroupids"] = security_groups
-				elsif locate_config_value(:cloudstack_groupnames) != []
-					cs_groupnames = locate_config_value(:cloudstack_groupnames)
-					cs_groupnames.each do |name|
-						security_groups.push(name)
-					end
-					server_def["securitygroupnames"] = security_groups
-				end
-
-				if locate_config_value(:keypair) != nil
-					server_def["keypair"] = locate_config_value(:keypair)
-				end
-
-				if locate_config_value(:diskoffering) != nil
-					server_def["diskofferingid"] = locate_config_value(:diskoffering)
-				end
-
-				if locate_config_value(:size) != nil
-					server_def["size"] = locate_config_value(:size)
-				end
-
-				server_def
-			end
-
-			def knife_ssh
-				ssh = Chef::Knife::Ssh.new
-				ssh.ui = ui
-				ssh.name_args = [ @primary_ip, ssh_command ]
-				ssh.config[:ssh_user] = Chef::Config[:knife][:ssh_user] || config[:ssh_user]
-				ssh.config[:ssh_password] = config[:ssh_password]
-				ssh.config[:ssh_port] = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
-				ssh.config[:ssh_gateway] = Chef::Config[:knife][:ssh_gateway] || config[:ssh_gateway]
-				ssh.config[:forward_agent] = Chef::Config[:knife][:forward_agent] || config[:forward_agent]
-				ssh.config[:identity_file] = Chef::Config[:knife][:identity_file] || config[:identity_file]
-				ssh.config[:manual] = true
-				ssh.config[:host_key_verify] = Chef::Config[:knife][:host_key_verify] || config[:host_key_verify]
-				ssh.config[:on_error] = :raise
-				Chef::Log.debug("SSH User: #{ssh.config[:ssh_user]}")
-				Chef::Log.debug("SSH Password: #{ssh.config[:ssh_password]}")
-				Chef::Log.debug("SSH Port: #{ssh.config[:ssh_port]}")
-				Chef::Log.debug("SSH Gateway: #{ssh.config[:ssh_gateway]}")
-				Chef::Log.debug("SSH Identity File: #{ssh.config[:identity_file]}")
-				ssh
-			end
-
-			def find_template(template=nil)
-				# Are we bootstrapping using an already shipped template?
-				if config[:template_file]
-					bootstrap_files = config[:template_file]
-				else
-					bootstrap_files = []
-					bootstrap_files << File.join(File.dirname(__FILE__), 'bootstrap', "#{config[:distro]}.erb")
-					bootstrap_files << File.join(Knife.chef_config_dir, "bootstrap", "#{config[:distro]}.erb") if Knife.chef_config_dir
-					bootstrap_files << File.join(ENV['HOME'], '.chef', 'bootstrap', "#{config[:distro]}.erb") if ENV['HOME']
-					bootstrap_files << Gem.find_files(File.join("chef","knife","bootstrap","#{config[:distro]}.erb"))
-					bootstrap_files.flatten!
-				end
-
-				template = Array(bootstrap_files).find do |bootstrap_template|
-					Chef::Log.debug("Looking for bootstrap template in #{File.dirname(bootstrap_template)}")
-					File.exists?(bootstrap_template)
-				end
-
-				unless template
-					ui.info("Can not find bootstrap definition for #{config[:distro]}")
-					raise Errno::ENOENT
-				end
-
-				Chef::Log.debug("Found bootstrap template in #{File.dirname(template)}")
-
-				template
-			end
-
-			def render_template(template=nil)
-				context = Knife::Core::BootstrapContext.new(config, config[:run_list], Chef::Config)
-				Erubis::Eruby.new(template).evaluate(context)
-			end
-
-			def read_template
-				IO.read(@template_file).chomp
-			end
-
-			def knife_ssh_with_password_auth
-				ssh = knife_ssh
-				ssh.config[:identity_file] = nil
-				Chef::Log.debug("Private Key failed or not specified. Trying password of #{ssh.get_password}")
-				ssh.config[:ssh_password] = ssh.get_password
-				ssh
-			end
-
-			def ssh_command
-				command = render_template(read_template)
-
-				if config[:use_sudo]
-					command = config[:use_sudo_password] ? "echo #{config[:ssh_password]} | sudo -S #{command}" : "sudo #{command}"
-				end
-
-				command
-			end
-
-			def run
-				$stdout.sync = true
-				options = create_server_def
-				Chef::Log.debug("Options: #{options} \n")
-
-				@initial_sleep_delay = 10				
-				@sshport = 22
-
-				config[:host_key_verify] = false
-
-				if locate_config_value(:ssh_port) != nil
-					@sshport = locate_config_value(:ssh_port).to_i
-				end
-
-				serverdeploy = connection.deploy_virtual_machine(options)
-				jobid = serverdeploy['deployvirtualmachineresponse'].fetch('jobid')
-
-				server_start = connection.query_async_job_result('jobid'=>jobid)
-
-				Chef::Log.debug("Job ID: #{jobid} \n")
-
-				print "#{ui.color("Waiting for server", :magenta)}"
-				while server_start['queryasyncjobresultresponse'].fetch('jobstatus') == 0
-					print "#{ui.color(".", :magenta)}"
-					sleep @initial_sleep_delay
-					server_start = connection.query_async_job_result('jobid'=>jobid)
-					Chef::Log.debug("Server_Start: #{server_start} \n")
-				end
-				puts "\n\n"
-
-				if server_start['queryasyncjobresultresponse'].fetch('jobstatus') == 2
-					errortext = server_start['queryasyncjobresultresponse'].fetch('jobresult').fetch('errortext')
-					puts "#{ui.color("ERROR! Job failed with #{errortext}", :red)}"
-				end
-
-				if server_start['queryasyncjobresultresponse'].fetch('jobstatus') == 1
-
-					Chef::Log.debug("Job ID: #{jobid} \n")
-					Chef::Log.debug("Options: #{options} \n")
-					server_start = connection.query_async_job_result('jobid'=>jobid)
-					Chef::Log.debug("Server_Start: #{server_start} \n")
-
-					@server = server_start['queryasyncjobresultresponse']['jobresult']['virtualmachine']
-
-					server_display_name = @server['displayname']
-					server_id = @server['name']
-					server_serviceoffering = @server['serviceofferingname']
-					server_template = @server['templatename']
-					if @server['password'] != nil
-						config[:ssh_password] = @server['password']
-					else
-						config[:ssh_password] = locate_config_value(:ssh_password)
-					end
-
-					ssh_user = locate_config_value(:ssh_user)
-
-					@primary_ip = nil
-
-					if @server['nic'].size > 0
-						@primary_ip = @server['nic'].first['ipaddress']
-					end
-
-					if locate_config_value(:random_ssh_port) != nil
-						public_ips = connection.list_public_ip_addresses("associatednetworkid" => @server['nic'][0]['networkid'])
-						primary_public_ip_id = public_ips['listpublicipaddressesresponse']['publicipaddress'][0]['id']
-						@primary_ip = public_ips['listpublicipaddressesresponse']['publicipaddress'][0]['ipaddress']
-						pubport = rand(49152..65535)
-						while (check_port_available(pubport, primary_public_ip_id) == false)
-							pubport = rand(49152..65535)
-						end
-						add_port_forward(pubport, pubport, server_id, primary_public_ip_id, @sshport)
-						@sshport = pubport
-					end
-
-					Chef::Log.debug("Connecting over port #{@sshport}")
-					config[:ssh_port] = @sshport
-					config[:server_name] = @primary_ip
-					@template_file = find_template(config[:bootstrap_template])
-					
-					puts "\n\n"
-					puts "#{ui.color("Name", :cyan)}: #{server_display_name}"
-					puts "#{ui.color("Primary IP", :cyan)}: #{@primary_ip}"
-					puts "#{ui.color("Username", :cyan)}: #{ssh_user}"
-					puts "#{ui.color("Password", :cyan)}: #{config[:ssh_password]}"
-
-					print "#{ui.color("Waiting for SSH.", :magenta)}"
-					if config[:ssh_gateway]
-						Chef::Log.debug("Using SSH Gateway: #{config[:ssh_gateway]}")
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-					end
-					begin
-						knife_ssh.run
-					rescue Net::SSH::AuthenticationFailed
-						unless config[:ssh_password]
-							ui.info("Failed to authenticate #{config[:ssh_user]} - trying password auth")
-							knife_ssh_with_password_auth.run
-						end
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue Errno::ECONNREFUSED
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue SocketError
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue Errno::ETIMEDOUT
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue Errno::EPERM
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue Errno::EHOSTUNREACH
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue Errno::ENETUNREACH
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue Net::SSH::Disconnect
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue Net::SSH::AuthenticationFailed
-						sleep @initial_sleep_delay
-						print "#{ui.color(".", :magenta)}"
-						retry
-					rescue
-						puts caller
-						puts $!.inspect
-					end			
-
-					Chef::Log.debug("#{@server}")
-
-					puts "\n"
-					puts "#{ui.color("Instance Name", :green)}: #{server_display_name}"
-					puts "#{ui.color("Instance ID", :green)}: #{server_id}"
-					puts "#{ui.color("Service Offering", :green)}: #{server_serviceoffering}"
-					puts "#{ui.color("Template", :green)}: #{server_template}"
-					puts "#{ui.color("Public IP Address", :green)}: #{@primary_ip}"
-					puts "#{ui.color("Port", :green)}: #{@sshport}"
-					puts "#{ui.color("User", :green)}: #{ssh_user}"
-					puts "#{ui.color("Password", :green)}: #{config[:ssh_password]}"
-					puts "#{ui.color("Environment", :green)}: #{config[:environment] || '_default'}"
-					puts "#{ui.color("Run List", :green)}: #{config[:run_list].join(', ')}"
-				end
-
-			end
-		end
-	end
+  class Knife
+    class CloudstackServerCreate < Knife
+
+      include Knife::CloudstackBase
+
+      banner "knife cloudstack server create -s SERVICEID -t TEMPLATEID -z ZONEID (options)"
+
+      option  :cloudstack_serviceid,
+            :short => "-s SERVICEID",
+            :long => "--serviceid SERVICEID",
+            :description => "The CloudStack service offering ID."
+
+      option  :cloudstack_templateid,
+            :short => "-t TEMPLATEID",
+            :long => "--templateid TEMPLATEID",
+            :description => "The CloudStack template ID for the server."
+
+      option  :cloudstack_zoneid,
+            :short => "-Z ZONEID",
+            :long => "--zoneid ZONE",
+            :description => "The CloudStack zone ID for the server."
+
+      option  :cloudstack_networkids,
+            :short => "-w NETWORKIDS",
+            :long => "--networkids NETWORKIDS",
+            :description => "Comma separated list of CloudStack network IDs.",
+            :proc => lambda { |n| n.split(/[\s,]+/) },
+            :default => []
+
+      option  :cloudstack_groupids,
+            :short => "-g SECURITYGROUPIDS",
+            :long => "--groupids SECURITYGROUPIDS",
+            :description => "Comma separated list of CloudStack Security Group IDs.",
+            :proc => lambda { |n| n.split(/[\s,]+/) },
+            :default => []
+
+      option  :cloudstack_groupnames,
+            :short => "-G SECURITYGROUPNAMES",
+            :long => "--groupnames SECURITYGROUPNAMES",
+            :description => "Comma separated list of CloudStack Security Group names. Each group name must be encapuslated in quotes if it contains whitespace.",
+            :proc => lambda { |n| n.split(/[\s,]+/) },
+            :default => []
+
+      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  :ssh_user,
+            :short => "-x USERNAME",
+            :long => "--ssh-user USERNAME",
+            :description => "The ssh username",
+            :default => 'root'
+
+      option  :ssh_password,
+            :short => "-P PASSWORD",
+            :long => "--ssh-password PASSWORD",
+            :description => "The ssh password"
+
+      option  :identity_file,
+            :short => "-i PRIVATE_KEY_FILE",
+            :long => "--identity-file PRIVATE_KEY_FILE",
+            :description => "The Private key file for authenticating SSH session. --keypair option is also needed."
+
+      option  :ssh_port,
+            :short => "-p PORT",
+            :long => "--ssh-port PORT",
+            :description => "The port which SSH should be listening on. If unspecified, will default to 22."
+
+      option  :server_display_name,
+            :short => "-N NAME",
+            :long => "--display-name NAME",
+            :description => "The instance display name"
+
+      option  :host_name,
+            :short => "-H NAME",
+            :long => "--hostname NAME",
+            :description => "The instance host name"
+
+      option  :keypair,
+            :short => "-k KEYPAIR",
+            :long => "--keypair KEYPAIR",
+            :description => "The CloudStack Key Pair to use for SSH key authentication."
+
+      option  :diskoffering,
+            :short => "-D DISKOFFERINGID",
+            :long => "--diskoffering DISKOFFERINGID",
+            :description => "Specifies either the Disk Offering ID for the ROOT disk for an ISO template, or a DATA disk."
+
+      option  :size,
+            :long => "--size SIZE",
+            :description => "Specifies the arbitrary Disk Size for DATADISK volume in GB. Must be passed with custom size Disk Offering ID."
+
+      option  :random_ssh_port,
+            :long => "--random-ssh-port",
+            :description => "Map a random, unused high-level port to 22 for SSH and creates a port forward for this mapping. For Isolated Networking and VPC only."
+
+      option  :ssh_gateway,
+            :short => "-W GATEWAY",
+            :long => "--ssh-gateway GATEWAY",
+            :description => "The ssh gateway server. Connection is defined as USERNAME@HOST:PORT",
+            :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
+
+      option  :user_data,
+            :long => "--user-data USER_DATA_FILE",
+            :description => "The user data file to provision the instance with",
+            :proc => Proc.new { |m| Chef::Config[:knife][:cloudstack_user_data] = m },
+            :default => nil
+
+      option  :keyboard,
+            :long => "--keyboard KEYBOARD_TYPE",
+            :description => "An optional keyboard device type for the virtual machine"
+
+      option  :hypervisor,
+            :long => "--hypervisor HYPERVISOR",
+            :description => "the hypervisor on which to deploy the virtual machine",
+            :default => nil
+
+      # def bootstrap_for_node(host, user, password)
+      def bootstrap_for_node(server, ssh_host)
+        host = server["name"]
+        user = config[:ssh_user]
+        password = server["password"]
+        Chef::Log.debug("Bootstrap host: #{host}")
+        Chef::Log.debug("Bootstrap user: #{user}")
+        Chef::Log.debug("Bootstrap pass: #{password}")
+        bootstrap = Chef::Knife::Bootstrap.new
+        bootstrap.name_args = [ssh_host]
+        bootstrap.config[:run_list] = config[:run_list]
+        bootstrap.config[:ssh_user] = user
+        bootstrap.config[:ssh_password] = password
+        bootstrap.config[:ssh_gateway] = config[:ssh_gateway]
+        bootstrap.config[:identity_file] = locate_config_value(:identity_file)
+        bootstrap.config[:chef_node_name] = config[:server_display_name] if config[:server_display_name]
+        bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+        bootstrap.config[:distro] = locate_config_value(:distro)
+        bootstrap.config[:use_sudo] = true
+        bootstrap.config[:template_file] = locate_config_value(:template_file)
+        bootstrap.config[:environment] = config[:environment]
+        # may be needed for vpc_mode
+        bootstrap.config[:no_host_key_verify] = config[:no_host_key_verify]
+        begin
+          bootstrap
+        rescue
+          sleep @initial_sleep_delay
+          retry
+        end
+      end
+
+      def check_port_available(public_port, ipaddressid)
+        Chef::Log.debug("Checking if port #{public_port} is available.")
+        pubport = public_port.to_i
+        port_forward_rules_query = connection.list_port_forwarding_rules({'ipaddressid' => ipaddressid })
+        port_rules = port_forward_rules_query['listportforwardingrulesresponse']['portforwardingrule']
+        is_available = true
+        some_possible_rules = port_rules.select { |rule| rule['publicport'].to_i <= pubport }
+        possible_rules = some_possible_rules.select { |rule| rule['publicendport'].to_i >= pubport }
+        possible_rules.each do |rule|
+          startport = rule['publicport'].to_i
+          endport = rule['publicendport'].to_i
+          Chef::Log.debug("Determining if #{pubport} is between #{startport} and #{endport}.")
+          if (endport != startport)
+            if pubport.between?(startport, endport)
+              is_available = false
+            else
+              is_available = true
+            end
+          else
+            if (pubport == startport)
+              is_available = false
+            else
+              is_available = true
+            end
+          end
+        end
+        return is_available
+      end
+
+      def add_port_forward(public_start_port, public_end_port, server_id, ipaddressid, privateport)
+        pfwdops = {}
+        pfwdops['ipaddressid'] = ipaddressid
+        pfwdops['privateport'] = privateport
+        pfwdops['protocol'] = "TCP"
+        pfwdops['virtualmachineid'] = server_id
+        pfwdops['openfirewall'] = "true"
+        pfwdops['publicport'] = public_start_port
+        pfwdops['publicendport'] = public_end_port
+        rule_create_job = connection.create_port_forwarding_rule(pfwdops)
+        print "#{ui.color("Creating port forwarding rule.", :cyan)}"
+        while (@connection.query_async_job_result({'jobid' => rule_create_job['createportforwardingruleresponse']['jobid']})['queryasyncjobresultresponse'].fetch('jobstatus') == 0)
+          print("#{ui.color(".", :cyan)}")
+          sleep 2
+        end
+        print("\n")
+      end
+
+      def create_server_def
+        server_def = {}
+
+        if locate_config_value(:server_display_name) != nil
+          server_def["displayname"] = locate_config_value(:server_display_name)
+        end
+
+        if locate_config_value(:host_name) != nil
+          server_def["name"] = locate_config_value(:host_name)
+        end
+
+        network_ids = ""
+        if locate_config_value(:cloudstack_networkids) != []
+          cs_networkids = locate_config_value(:cloudstack_networkids)
+          cs_networkids.join(",")
+          server_def["networkids"] = network_ids
+        end
+
+        security_groups = ""
+        if locate_config_value(:cloudstack_groupids) != []
+          cs_groupids = locate_config_value(:cloudstack_groupids)
+          security_groups = cs_groupids.join(",")
+          server_def["securitygroupids"] = security_groups
+        elsif locate_config_value(:cloudstack_groupnames) != []
+          cs_groupnames = locate_config_value(:cloudstack_groupnames)
+          security_groups = cs_groupnames.join(",")
+          server_def["securitygroupnames"] = security_groups
+        end
+
+        if locate_config_value(:keypair) != nil
+          server_def["keypair"] = locate_config_value(:keypair)
+        end
+
+        if locate_config_value(:diskoffering) != nil
+          server_def["diskofferingid"] = locate_config_value(:diskoffering)
+        end
+
+        if locate_config_value(:size) != nil
+          server_def["size"] = locate_config_value(:size)
+        end
+
+        if locate_config_value(:hypervisor) != nil
+          server_def["hypervisor"] = locate_config_value(:hypervisor)
+        end
+
+        if locate_config_value(:cloudstack_user_data) != nil
+          require 'base64'
+          begin
+            server_def["userdata"] = Base64.strict_encode64(File.read(Chef::Config[:knife][:cloudstack_user_data]))
+          rescue
+            ui.warn("Cannot read #{Chef::Config[:knife][:cloudstack_user_data]}: #{$!.inspect}. Ignoring")
+          end
+        end
+        if locate_config_value(:keyboard) != nil
+          server_def["keyboard"] = locate_config_value(:keyboard)
+        end
+
+        server_def
+      end
+
+      def knife_ssh
+        ssh = Chef::Knife::Ssh.new
+        ssh.ui = ui
+        ssh.name_args = [ @primary_ip, ssh_command ]
+        ssh.config[:ssh_user] = Chef::Config[:knife][:ssh_user] || config[:ssh_user]
+        ssh.config[:ssh_password] = config[:ssh_password]
+        ssh.config[:ssh_port] = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
+        ssh.config[:ssh_gateway] = Chef::Config[:knife][:ssh_gateway] || config[:ssh_gateway]
+        ssh.config[:forward_agent] = Chef::Config[:knife][:forward_agent] || config[:forward_agent]
+        ssh.config[:identity_file] = Chef::Config[:knife][:identity_file] || config[:identity_file]
+        ssh.config[:manual] = true
+        ssh.config[:host_key_verify] = Chef::Config[:knife][:host_key_verify] || config[:host_key_verify]
+        ssh.config[:on_error] = :raise
+        Chef::Log.debug("SSH User: #{ssh.config[:ssh_user]}")
+        Chef::Log.debug("SSH Password: #{ssh.config[:ssh_password]}")
+        Chef::Log.debug("SSH Port: #{ssh.config[:ssh_port]}")
+        Chef::Log.debug("SSH Gateway: #{ssh.config[:ssh_gateway]}")
+        Chef::Log.debug("SSH Identity File: #{ssh.config[:identity_file]}")
+        ssh
+      end
+
+      def find_template(template=nil)
+        # Are we bootstrapping using an already shipped template?
+        if config[:template_file]
+          bootstrap_files = config[:template_file]
+        else
+          bootstrap_files = []
+          bootstrap_files << File.join(File.dirname(__FILE__), 'bootstrap', "#{config[:distro]}.erb")
+          bootstrap_files << File.join(Knife.chef_config_dir, "bootstrap", "#{config[:distro]}.erb") if Knife.chef_config_dir
+          bootstrap_files << File.join(ENV['HOME'], '.chef', 'bootstrap', "#{config[:distro]}.erb") if ENV['HOME']
+          bootstrap_files << Gem.find_files(File.join("chef","knife","bootstrap","#{config[:distro]}.erb"))
+          bootstrap_files.flatten!
+        end
+
+        template = Array(bootstrap_files).find do |bootstrap_template|
+          Chef::Log.debug("Looking for bootstrap template in #{File.dirname(bootstrap_template)}")
+          File.exists?(bootstrap_template)
+        end
+
+        unless template
+          ui.info("Can not find bootstrap definition for #{config[:distro]}")
+          raise Errno::ENOENT
+        end
+
+        Chef::Log.debug("Found bootstrap template in #{File.dirname(template)}")
+
+        template
+      end
+
+      def render_template(template=nil)
+        context = Knife::Core::BootstrapContext.new(config, config[:run_list], Chef::Config)
+        Erubis::Eruby.new(template).evaluate(context)
+      end
+
+      def read_template
+        IO.read(@template_file).chomp
+      end
+
+      def knife_ssh_with_password_auth
+        ssh = knife_ssh
+        ssh.config[:identity_file] = nil
+        Chef::Log.debug("Private Key failed or not specified. Trying password of #{ssh.get_password}")
+        ssh.config[:ssh_password] = ssh.get_password
+        ssh
+      end
+
+      def ssh_command
+        command = render_template(read_template)
+
+        if config[:use_sudo]
+          command = config[:use_sudo_password] ? "echo #{config[:ssh_password]} | sudo -S #{command}" : "sudo #{command}"
+        end
+
+        command
+      end
+
+      def run
+        $stdout.sync = true
+        options = create_server_def
+        Chef::Log.debug("Options: #{options} \n")
+
+        @initial_sleep_delay = 10       
+        @sshport = 22
+
+        config[:host_key_verify] = false
+
+        if locate_config_value(:ssh_port) != nil
+          @sshport = locate_config_value(:ssh_port).to_i
+        end
+
+        # binding.pry
+        serverdeploy = connection.deploy_virtual_machine(locate_config_value(:cloudstack_serviceid), 
+          locate_config_value(:cloudstack_templateid), locate_config_value(:cloudstack_zoneid), options)
+        
+        jobid = serverdeploy['deployvirtualmachineresponse'].fetch('jobid')
+
+        server_start = connection.query_async_job_result(jobid)
+
+        Chef::Log.debug("Job ID: #{jobid} \n")
+
+        print "#{ui.color("Waiting for server", :magenta)}"
+        while server_start['queryasyncjobresultresponse'].fetch('jobstatus') == 0
+          print "#{ui.color(".", :magenta)}"
+          sleep @initial_sleep_delay
+          server_start = connection.query_async_job_result(jobid)
+          Chef::Log.debug("Server_Start: #{server_start} \n")
+        end
+        puts "\n\n"
+
+        if server_start['queryasyncjobresultresponse'].fetch('jobstatus') == 2
+          errortext = server_start['queryasyncjobresultresponse'].fetch('jobresult').fetch('errortext')
+          puts "#{ui.color("ERROR! Job failed with #{errortext}", :red)}"
+        end
+
+        if server_start['queryasyncjobresultresponse'].fetch('jobstatus') == 1
+
+          Chef::Log.debug("Job ID: #{jobid} \n")
+          Chef::Log.debug("Options: #{options} \n")
+          server_start = connection.query_async_job_result(jobid)
+          Chef::Log.debug("Server_Start: #{server_start} \n")
+
+          @server = server_start['queryasyncjobresultresponse']['jobresult']['virtualmachine']
+
+          server_display_name = @server['displayname']
+          server_id = @server['name']
+          server_serviceoffering = @server['serviceofferingname']
+          server_template = @server['templatename']
+          if @server['password'] != nil
+            config[:ssh_password] = @server['password']
+          else
+            config[:ssh_password] = locate_config_value(:ssh_password)
+          end
+
+          ssh_user = locate_config_value(:ssh_user)
+
+          @primary_ip = nil
+
+          if @server['nic'].size > 0
+            @primary_ip = @server['nic'].first['ipaddress']
+          end
+
+          if locate_config_value(:random_ssh_port) != nil
+            public_ips = connection.list_public_ip_addresses("associatednetworkid" => @server['nic'][0]['networkid'])
+            primary_public_ip_id = public_ips['listpublicipaddressesresponse']['publicipaddress'][0]['id']
+            @primary_ip = public_ips['listpublicipaddressesresponse']['publicipaddress'][0]['ipaddress']
+            pubport = rand(49152..65535)
+            while (check_port_available(pubport, primary_public_ip_id) == false)
+              pubport = rand(49152..65535)
+            end
+            add_port_forward(pubport, pubport, server_id, primary_public_ip_id, @sshport)
+            @sshport = pubport
+          end
+
+          Chef::Log.debug("Connecting over port #{@sshport}")
+          config[:ssh_port] = @sshport
+          config[:server_name] = @primary_ip
+          @template_file = find_template(config[:bootstrap_template])
+          
+          puts "\n\n"
+          puts "#{ui.color("Name", :cyan)}: #{server_display_name}"
+          puts "#{ui.color("Primary IP", :cyan)}: #{@primary_ip}"
+          puts "#{ui.color("Username", :cyan)}: #{ssh_user}"
+          puts "#{ui.color("Password", :cyan)}: #{config[:ssh_password]}"
+
+          print "#{ui.color("Waiting for SSH.", :magenta)}"
+          if config[:ssh_gateway]
+            Chef::Log.debug("Using SSH Gateway: #{config[:ssh_gateway]}")
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+          end
+          begin
+            knife_ssh.run
+          rescue Net::SSH::AuthenticationFailed
+            unless config[:ssh_password]
+              ui.info("Failed to authenticate #{config[:ssh_user]} - trying password auth")
+              knife_ssh_with_password_auth.run
+            end
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue Errno::ECONNREFUSED
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue SocketError
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue Errno::ETIMEDOUT
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue Errno::EPERM
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue Errno::EHOSTUNREACH
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue Errno::ENETUNREACH
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue Net::SSH::Disconnect
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue Net::SSH::AuthenticationFailed
+            sleep @initial_sleep_delay
+            print "#{ui.color(".", :magenta)}"
+            retry
+          rescue
+            puts caller
+            puts $!.inspect
+          end     
+
+          Chef::Log.debug("#{@server}")
+
+          puts "\n"
+          puts "#{ui.color("Instance Name", :green)}: #{server_display_name}"
+          puts "#{ui.color("Instance ID", :green)}: #{server_id}"
+          puts "#{ui.color("Service Offering", :green)}: #{server_serviceoffering}"
+          puts "#{ui.color("Template", :green)}: #{server_template}"
+          puts "#{ui.color("Public IP Address", :green)}: #{@primary_ip}"
+          puts "#{ui.color("Port", :green)}: #{@sshport}"
+          puts "#{ui.color("User", :green)}: #{ssh_user}"
+          puts "#{ui.color("Password", :green)}: #{config[:ssh_password]}"
+          puts "#{ui.color("Environment", :green)}: #{config[:environment] || '_default'}"
+          puts "#{ui.color("Run List", :green)}: #{config[:run_list].join(', ')}"
+        end
+
+      end
+    end
+  end
 end

data/lib/chef/knife/cloudstack_server_delete.rb

@@ -40,7 +40,7 @@ class Chef
           puts "#{ui.color("Public IP", :red)}: #{instance_ip}"
           puts "\n"
           confirm("#{ui.color("Do you really want to delete this server", :red)}")
-          connection.destroy_virtual_machine('id' => real_instance_id)
+          connection.destroy_virtual_machine(instance_id)
           ui.warn("Deleted server #{instance_name}")
         end
       end

data/lib/chef/knife/cloudstack_server_destroy.rb

@@ -40,7 +40,7 @@ class Chef
           puts "#{ui.color("Public IP", :red)}: #{instance_ip}"
           puts "\n"
           confirm("#{ui.color("Do you really want to destroy this server", :red)}")
-          connection.destroy_virtual_machine('id' => real_instance_id)
+          connection.destroy_virtual_machine(instance_id)
           ui.warn("Destroyed server #{instance_name}")
         end
       end

data/lib/chef/knife/cloudstack_template_list.rb

@@ -106,7 +106,7 @@ class Chef
         hypervisor = locate_config_value(:hypervisor)
         templateid = locate_config_value(:templateid)
 
-        settings = connection.list_templates('templatefilter' => filter)
+        settings = connection.list_templates(filter)
         if response = settings['listtemplatesresponse']
           Chef::Log.debug("Response: #{response}")
           if templates = response['template']

data/lib/knife-cloudstack-fog/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Cloudstack
-    VERSION = "0.5.2"
+    VERSION = "0.6.0"
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-cloudstack-fog
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Chirag Jog (chiragjog)
@@ -12,48 +12,60 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-22 00:00:00.000000000 Z
+date: 2014-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.23'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.0
+        version: 1.23.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.23'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.10.0
+        version: 1.23.0
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.12'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 11.2.0
+        version: 11.12.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.12'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 11.2.0
+        version: 11.12.8
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 description: Support for the Chef Knife command, leveraging FOG, for the Apache CloudStack
@@ -118,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Cloudstack Compute Support for Chef's Knife Command