knife-vsphere 0.1.8 → 0.1.9

data/lib/chef/knife/BaseVsphereCommand.rb

@@ -22,73 +22,71 @@ class Chef
 				require 'chef/json_compat'
 			end
 
-
 			def self.get_common_options
+				$default = Hash.new
 
 				option :vsphere_user,
 					:short => "-u USERNAME",
-					:long => "--user USERNAME",
-					:description => "The username for the host"
+					:long => "--vsuser USERNAME",
+					:description => "The username for vsphere"
 
 				option :vsphere_pass,
 					:short => "-p PASSWORD",
-					:long => "--password PASSWORD",
-					:description => "The password for the host"
+					:long => "--vspass PASSWORD",
+					:description => "The password for vsphere"
+
+				option :vsphere_host,
+					:long => "--vshost",
+					:description => "The vsphere host"
 
-				option :datacenter,
+				option :vsphere_dc,
 					:short => "-d DATACENTER",
-					:long => "--datacenter DATACENTER",
-					:description => "The Datacenter to create the VM in"
-
-				option :path,
-					:long => "--path SOAP_PATH",
-					:description => "The SOAP endpoint path",
-					:proc => Proc.new { |p| Chef::Config[:knife][:path] = p },
-					:default => "/sdk"
-
-				option :port,
-					:long => "--port PORT",
-					:description => "The VI SDK port number to use",
-					:proc => Proc.new { |p| Chef::Config[:knife][:port] = p },
-					:default => 443
-
-				option :use_ssl,
-					:long => "--ssl USE_SSL",
-					:description => "Whether to use SSL connection",
-					:default => true
-
-				option :insecure,
-					:short => "-i USE_INSECURE_SSL",
-					:long => "--insecure USE_INSECURE_SSL",
-					:description => "Determines whether SSL certificate verification is skipped",
-					:default => true
+					:long => "--vsdc DATACENTER",
+					:description => "The Datacenter for vsphere"
+
+				option :vsphere_path,
+					:long => "--vspath SOAP_PATH",
+					:description => "The vsphere SOAP endpoint path"
+				$default[:vsphere_path] = "/sdk"
+
+				option :vsphere_port,
+					:long => "--vsport PORT",
+					:description => "The VI SDK port number to use"
+				$default[:vsphere_port] = 443
+
+				option :vshere_ssl,
+					:long => "--vsssl USE_SSL",
+					:description => "Whether to use SSL connection"
+				$default[:vsphere_ssl] = true
+
+				option :vsphere_insecure,
+					:long => "--vsinsecure USE_INSECURE_SSL",
+					:description => "Determines whether SSL certificate verification is skipped"
 
 				option :folder,
 					:short => "-f FOLDER",
 					:long => "--folder FOLDER",
-					:description => "The folder to get VMs from",
-					:default => ''
-
+					:description => "The folder to get VMs from"
+				$default[:folder] = ''
 			end
 
-			def locate_config_value(key)
+			def get_config(key)
 				key = key.to_sym
-				Chef::Config[:knife][key] || config[key]
+				config[key] || Chef::Config[:knife][key] || $default[key]
 			end
 
 			def get_vim_connection
 
 				conn_opts = {
-					:host => locate_config_value(:vsphere_host),
-					:path => config[:path],
-					:port => config[:port],
-					:use_ssl => config[:ssl],
-					:user => locate_config_value(:vsphere_user),
-					:password => locate_config_value(:vsphere_pass),
-					:insecure => config[:insecure]
+					:host => get_config(:vsphere_host),
+					:path => get_config(:vshere_path),
+					:port => get_config(:vsphere_port),
+					:use_ssl => get_config(:vsphere_ssl),
+					:user => get_config(:vsphere_user),
+					:password => get_config(:vsphere_pass),
+					:insecure => get_config(:vsphere_insecure)
 				}
 
-				#    opt :insecure, "don't verify ssl certificate", :short => 'k', :default => (ENV['RBVMOMI_INSECURE'] == '1')
 				#    opt :debug, "Log SOAP messages", :short => 'd', :default => (ENV['RBVMOMI_DEBUG'] || false)
 
 				vim = RbVmomi::VIM.connect conn_opts
@@ -97,7 +95,7 @@ class Chef
 			end
 
 			def find_folder(folderName)
-				dcname = config[:vsphere_dc] || Chef::Config[:knife][:vsphere_dc]
+				dcname = get_config(:vsphere_dc)
 				dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
 				baseEntity = dc.vmFolder
 				entityArray = folderName.split('/')
@@ -111,14 +109,14 @@ class Chef
 			end
 
 			def find_network(networkName)
-				dcname = config[:vsphere_dc] || Chef::Config[:knife][:vsphere_dc]
+				dcname = get_config(:vsphere_dc)
 				dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
 				baseEntity = dc.network
 				baseEntity.find { |f| f.name == networkName } or abort "no such network #{networkName}"
 			end
 
 			def find_pool(poolName)
-				dcname = config[:vsphere_dc] || Chef::Config[:knife][:vsphere_dc]
+				dcname = get_config(:vsphere_dc)
 				dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
 				baseEntity = dc.hostFolder
 				entityArray = poolName.split('/')
@@ -144,7 +142,7 @@ class Chef
 			end
 
 			def find_datastore(dsName)
-				dcname = config[:vsphere_dc] || Chef::Config[:knife][:vsphere_dc]
+				dcname = get_config(:vsphere_dc)
 				dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
 				baseEntity = dc.datastore
 				baseEntity.find { |f| f.info.name == dsName } or abort "no such datastore #{dsName}"

data/lib/chef/knife/vsphere_datastore_list.rb

@@ -46,7 +46,7 @@ class Chef::Knife::VsphereDatastoreList < Chef::Knife::BaseVsphereCommand
     $stdout.sync = true
     
     vim = get_vim_connection
-    dcname = config[:vsphere_dc] || Chef::Config[:knife][:vsphere_dc]
+		dcname = get_config(:vsphere_dc)
     dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
     dc.datastore.each do |store|
       avail = number_to_human_size(store.summary[:freeSpace])

data/lib/chef/knife/vsphere_template_list.rb

@@ -20,7 +20,7 @@ class Chef::Knife::VsphereTemplateList < Chef::Knife::BaseVsphereCommand
 
     vim = get_vim_connection
 
-    baseFolder = find_folder(config[:folder]);
+    baseFolder = find_folder(get_config(:folder));
 
     vms = find_all_in_folder(baseFolder, RbVmomi::VIM::VirtualMachine).
       select {|v| !v.config.nil? && v.config.template == true }

data/lib/chef/knife/vsphere_vlan_list.rb

@@ -0,0 +1,37 @@
+# Author: Jesse Campbell
+# 
+# Permission to use, copy, modify, and/or distribute this software for
+# any purpose with or without fee is hereby granted, provided that the
+# above copyright notice and this permission notice appear in all
+# copies.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+# AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+# DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
+# OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+# TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+# PERFORMANCE OF THIS SOFTWARE
+
+require 'chef/knife'
+require 'chef/knife/BaseVsphereCommand'
+
+# Lists all known data stores in datacenter with sizes
+class Chef::Knife::VsphereVlanList < Chef::Knife::BaseVsphereCommand
+
+  banner "knife vsphere vlan list"
+
+  get_common_options
+  def run
+    $stdout.sync = true
+    
+    vim = get_vim_connection
+		dcname = get_config(:vsphere_dc)
+    dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
+    dc.network.each do |network|
+      puts "#{ui.color("VLAN", :cyan)}: #{network.name}"
+    end
+  end
+end
+

data/lib/chef/knife/vsphere_vm_clone.rb

@@ -84,13 +84,11 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 
 	option :power,
 		:long => "--start STARTVM",
-		:description => "Indicates whether to start the VM after a successful clone",
-		:default => false
+		:description => "Indicates whether to start the VM after a successful clone"
 
 	option :bootstrap,
 		:long => "--bootstrap FALSE",
-		:description => "Indicates whether to bootstrap the VM",
-		:default => false
+		:description => "Indicates whether to bootstrap the VM"
 
 	option :fqdn,
 		:long => "--fqdn SERVER_FQDN",
@@ -99,8 +97,8 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 	option :ssh_user,
 		:short => "-x USERNAME",
 		:long => "--ssh-user USERNAME",
-		:description => "The ssh username",
-		:default => "root"
+		:description => "The ssh username"
+	$default[:ssh_user] = "root"
 
 	option :ssh_password,
 		:short => "-P PASSWORD",
@@ -110,9 +108,8 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 	option :ssh_port,
 		:short => "-p PORT",
 		:long => "--ssh-port PORT",
-		:description => "The ssh port",
-		:default => "22",
-		:proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key }
+		:description => "The ssh port"
+	$default[:ssh_port] = 22
 
 	option :identity_file,
 		:short => "-i IDENTITY_FILE",
@@ -131,7 +128,7 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 	option :bootstrap_version,
 		:long => "--bootstrap-version VERSION",
 		:description => "The version of Chef to install",
-		:proc => lambda { |v| Chef::Config[:knife][:bootstrap_version] = v }
+		:proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
 
 	option :bootstrap_proxy,
 		:long => "--bootstrap-proxy PROXY_URL",
@@ -141,26 +138,23 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 	option :distro,
 		:short => "-d DISTRO",
 		:long => "--distro DISTRO",
-		:description => "Bootstrap a distro using a template",
-		:default => "ubuntu10.04-gems"
+		:description => "Bootstrap a distro using a template"
+	$default[:distro] = "ubuntu10.04-gems"
 
 	option :template_file,
 		:long => "--template-file TEMPLATE",
-		:description => "Full path to location of template to use",
-		:default => false
+		:description => "Full path to location of template to use"
 
 	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 => []
+		:description => "Comma separated list of roles/recipes to apply"
+	$default[:run_list] = ''
 
 	option :no_host_key_verify,
 		:long => "--no-host-key-verify",
 		:description => "Disable host key verification",
-		:boolean => true,
-		:default => false
+		:boolean => true
 
 	def run
 		$stdout.sync = true
@@ -176,17 +170,17 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 
 		vim = get_vim_connection
 
-    dcname = config[:vsphere_dc] || Chef::Config[:knife][:vsphere_dc]
+    dcname = get_config(:vsphere_dc)
     dc = vim.serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
 
-		src_folder = find_folder(config[:folder]) || dc.vmFolder
+		src_folder = find_folder(get_config(:folder)) || dc.vmFolder
 
 		src_vm = find_in_folder(src_folder, RbVmomi::VIM::VirtualMachine, config[:source_vm]) or
 		abort "VM/Template not found"
 
 		clone_spec = generate_clone_spec(src_vm.config)
 
-    cust_folder = config[:dest_folder] || config[:folder]
+    cust_folder = config[:dest_folder] || get_config(:folder)
 
 		dest_folder = cust_folder.nil? ? src_vm.vmFolder : find_folder(cust_folder)
 
@@ -195,14 +189,14 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 		task.wait_for_completion
 		puts "Finished creating virtual machine #{vmname}"
 
-		if config[:power] || config[:bootstrap]
+		if get_config(:power) || get_config(:bootstrap)
 			vm = find_in_folder(dest_folder, RbVmomi::VIM::VirtualMachine, vmname) or
 			fatal_exit("VM #{vmname} not found")
 			vm.PowerOnVM_Task.wait_for_completion
 			puts "Powered on virtual machine #{vmname}"
 		end
 
-		if config[:bootstrap]
+		if get_config(:bootstrap)
 			print "Waiting for sshd..."
 			print "." until tcp_test_ssh(config[:fqdn])
 			puts "done"
@@ -215,18 +209,18 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 	def generate_clone_spec (src_config)
 
     rspec = nil
-    if config[:resource_pool]
-      rspec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => find_pool(config[:resource_pool]))
+    if get_config(:resource_pool)
+      rspec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => find_pool(get_config(:resource_pool)))
     else
-      dcname = config[:vsphere_dc] || Chef::Config[:knife][:vsphere_dc]
+      dcname = get_config(:vsphere_dc)
       dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
       hosts = find_all_in_folder(dc.hostFolder, RbVmomi::VIM::ComputeResource)
       rp = hosts.first.resourcePool
       rspec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => rp)
     end
 
-		if config[:datastore]
-			rspec.datastore = find_datastore(config[:datastore])
+		if get_config(:datastore)
+			rspec.datastore = find_datastore(get_config(:datastore))
 		end
 
 		clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(:location => rspec,
@@ -235,16 +229,16 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 
 		clone_spec.config = RbVmomi::VIM.VirtualMachineConfigSpec(:deviceChange => Array.new)
 
-		if config[:customization_cpucount]
-			clone_spec.config.numCPUs = config[:customization_cpucount]
+		if get_config(:customization_cpucount)
+			clone_spec.config.numCPUs = get_config(:customization_cpucount)
 		end
 
-		if config[:customization_memory]
-			clone_spec.config.memoryMB = Integer(config[:customization_memory]) * 1024
+		if get_config(:customization_memory)
+			clone_spec.config.memoryMB = Integer(get_config(:customization_memory)) * 1024
 		end
 
-		if config[:customization_vlan]
-			network = find_network(config[:customization_vlan])
+		if get_config(:customization_vlan)
+			network = find_network(get_config(:customization_vlan))
 			switch_port = RbVmomi::VIM.DistributedVirtualSwitchPortConnection(:switchUuid => network.config.distributedVirtualSwitch.uuid ,:portgroupKey => network.key)
 			card = src_config.hardware.device.find { |d| d.deviceInfo.label == "Network adapter 1" } or
         abort "Can't find source network card to customize"
@@ -253,9 +247,9 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 			clone_spec.config.deviceChange.push dev_spec
 		end
 
-		if config[:customization_spec]
-			csi = find_customization(config[:customization_spec]) or
-			fatal_exit("failed to find customization specification named #{config[:customization_spec]}")
+		if get_config(:customization_spec)
+			csi = find_customization(get_config(:customization_spec)) or
+			fatal_exit("failed to find customization specification named #{get_config(:customization_spec)}")
 
 			if csi.info.type != "Linux"
 				fatal_exit("Only Linux customization specifications are currently supported")
@@ -266,23 +260,23 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 			cust_spec = RbVmomi::VIM.CustomizationSpec(:globalIPSettings => global_ipset)
 		end
 
-		if config[:customization_dns_ips]
-			cust_spec.globalIPSettings.dnsServerList = config[:customization_dns_ips].split(',')
+		if get_config(:customization_dns_ips)
+			cust_spec.globalIPSettings.dnsServerList = get_config(:customization_dns_ips).split(',')
 		end
 
-		if config[:customization_dns_suffixes]
-			cust_spec.globalIPSettings.dnsSuffixList = config[:customization_dns_suffixes].split(',')
+		if get_config(:customization_dns_suffixes)
+			cust_spec.globalIPSettings.dnsSuffixList = get_config(:customization_dns_suffixes).split(',')
 		end
 
 		if config[:customization_ips]
-			if config[:customization_gw]
-				cust_spec.nicSettingMap = config[:customization_ips].split(',').map { |i| generate_adapter_map(i,config[:customization_gw]) }
+			if get_config(:customization_gw)
+				cust_spec.nicSettingMap = config[:customization_ips].split(',').map { |i| generate_adapter_map(i,get_config(:customization_gw)) }
 			else
 				cust_spec.nicSettingMap = config[:customization_ips].split(',').map { |i| generate_adapter_map(i) }
 			end
 		end
 
-		use_ident = !config[:customization_hostname].nil? || !config[:customization_domain].nil? || cust_spec.identity.nil?
+		use_ident = !config[:customization_hostname].nil? || !get_config(:customization_domain).nil? || cust_spec.identity.nil?
 
 		if use_ident
 			# TODO - verify that we're deploying a linux spec, at least warn
@@ -291,14 +285,12 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 			ident.hostName = RbVmomi::VIM.CustomizationFixedName
 			if config[:customization_hostname]
 				ident.hostName.name = config[:customization_hostname]
-			elsif config[:customization_domain]
-				ident.hostName.name = config[:customization_domain]
 			else
 				ident.hostName.name = config[:vmname]
 			end
 
-			if config[:customization_domain]
-				ident.domain = config[:customization_domain]
+			if get_config(:customization_domain)
+				ident.domain = get_config(:customization_domain)
 			else
 				ident.domain = ''
 			end
@@ -355,25 +347,25 @@ class Chef::Knife::VsphereVmClone < Chef::Knife::BaseVsphereCommand
 		Chef::Knife::Bootstrap.load_deps
 		bootstrap = Chef::Knife::Bootstrap.new
 		bootstrap.name_args = [config[:fqdn]]
-		bootstrap.config[:run_list] = config[:run_list]
-		bootstrap.config[:ssh_user] = config[:ssh_user]
-		bootstrap.config[:ssh_password] = config[:ssh_password]
-		bootstrap.config[:ssh_port] = config[:ssh_port]
-		bootstrap.config[:identity_file] = config[:identity_file]
-		bootstrap.config[:chef_node_name] = config[:chef_node_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 unless config[:ssh_user] == 'root'
-		bootstrap.config[:template_file] = locate_config_value(:template_file)
-		bootstrap.config[:environment] = config[:environment]
+		bootstrap.config[:run_list] = get_config(:run_list).split(/[\s,]+/)
+		bootstrap.config[:ssh_user] = get_config(:ssh_user)
+		bootstrap.config[:ssh_password] = get_config(:ssh_password)
+		bootstrap.config[:ssh_port] = get_config(:ssh_port)
+		bootstrap.config[:identity_file] = get_config(:identity_file)
+		bootstrap.config[:chef_node_name] = get_config(:chef_node_name)
+		bootstrap.config[:prerelease] = get_config(:prerelease)
+		bootstrap.config[:bootstrap_version] = get_config(:bootstrap_version)
+		bootstrap.config[:distro] = get_config(:distro)
+		bootstrap.config[:use_sudo] = true unless get_config(:ssh_user) == 'root'
+		bootstrap.config[:template_file] = get_config(:template_file)
+		bootstrap.config[:environment] = get_config(:environment)
 		# may be needed for vpc_mode
-		bootstrap.config[:no_host_key_verify] = config[:no_host_key_verify]
+		bootstrap.config[:no_host_key_verify] = get_config(:no_host_key_verify)
 		bootstrap
 	end
 
 	def tcp_test_ssh(hostname)
-		tcp_socket = TCPSocket.new(hostname, 22)
+		tcp_socket = TCPSocket.new(hostname, get_config(:ssh_port))
 		readable = IO.select([tcp_socket], nil, nil, 5)
 		if readable
 			Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")

data/lib/chef/knife/vsphere_vm_delete.rb

@@ -7,33 +7,60 @@ require 'chef/knife'
 require 'chef/knife/BaseVsphereCommand'
 require 'rbvmomi'
 
+# These two are needed for the '--purge' deletion case
+require 'chef/node'
+require 'chef/api_client'
+
 # Delete a virtual machine from vCenter
 class Chef::Knife::VsphereVmDelete < Chef::Knife::BaseVsphereCommand
 
-  banner "knife vsphere vm delete VMNAME"
+	banner "knife vsphere vm delete VMNAME"
+
+	option :purge,
+		:short => "-P",
+		:long => "--purge",
+		:boolean => true,
+		:description => "Destroy corresponding node and client on the Chef Server, in addition to destroying the EC2 node itself."
+
+	get_common_options
+
+	# Extracted from Chef::Knife.delete_object, because it has a
+	# confirmation step built in... By specifying the '--purge'
+	# flag (and also explicitly confirming the server destruction!)
+	# the user is already making their intent known. It is not
+	# necessary to make them confirm two more times.
+	def destroy_item(itemClass, name, type_name)
+		object = itemClass.load(name)
+		object.destroy
+		puts "Deleted #{type_name} #{name}"
+	end
+
+	def run
+		$stdout.sync = true
 
-  get_common_options
-  
-  def run
-    $stdout.sync = true
+		vmname = @name_args[0]
 
-    vmname = @name_args[0]
+		if vmname.nil?
+			show_usage
+			fatal_exit("You must specify a virtual machine name")
+		end
 
-    if vmname.nil?
-      show_usage
-      fatal_exit("You must specify a virtual machine name")
-    end
-    
-    vim = get_vim_connection
+		vim = get_vim_connection
 
-    baseFolder = find_folder(config[:folder]);
+		baseFolder = find_folder(get_config(:folder));
 
-    vm = find_in_folder(baseFolder, RbVmomi::VIM::VirtualMachine, vmname) or
-      fatal_exit("VM #{vmname} not found")
+		vm = find_in_folder(baseFolder, RbVmomi::VIM::VirtualMachine, vmname) or
+		fatal_exit("VM #{vmname} not found")
 
-    vm.PowerOffVM_Task.wait_for_completion unless vm.runtime.powerState == "poweredOff"
-    vm.Destroy_Task
-    puts "Deleted virtual machine #{vmname}"
+		vm.PowerOffVM_Task.wait_for_completion unless vm.runtime.powerState == "poweredOff"
+		vm.Destroy_Task
+		puts "Deleted virtual machine #{vmname}"
 
-  end
+		if config[:purge]
+			destroy_item(Chef::Node, vmname, "node")
+			destroy_item(Chef::ApiClient, vmname, "client")
+		else
+			puts "Corresponding node and client for the #{vmname} server were not deleted and remain registered with the Chef Server"
+		end
+	end
 end

data/lib/chef/knife/vsphere_vm_list.rb

@@ -8,25 +8,51 @@ require 'chef/knife/BaseVsphereCommand'
 # Lists all known virtual machines in the configured datacenter
 class Chef::Knife::VsphereVmList < Chef::Knife::BaseVsphereCommand
 
-  banner "knife vsphere vm list"
+	banner "knife vsphere vm list"
 
-  get_common_options
-  
-  def run
+	get_common_options
 
-    $stdout.sync = true
+	option :recursive,
+		:long  => "--recursive",
+		:short => "-r",
+		:description => "Recurse down through sub-folders"
 
-    vim = get_vim_connection
+	option :only_folders,
+		:long  => "--only-folders",
+		:description => "Print only sub-folders"
 
-    baseFolder = find_folder(config[:folder]);
+	def traverse_folders(folder)
+		puts "#{ui.color("Folder", :cyan)}: "+(folder.path[3..-1].map{|x| x[1]}.*'/')
+		print_vms_in_folder(folder) unless get_config(:only_folders)
+		folders = find_all_in_folder(folder, RbVmomi::VIM::Folder)
+		folders.each do |child|
+			traverse_folders(child)
+		end
+	end
 
-    vms = find_all_in_folder(baseFolder, RbVmomi::VIM::VirtualMachine)
-    vms.each do |vm|
-      puts "#{ui.color("VM Name", :cyan)}: #{vm.name}"
-    end
-		folders = find_all_in_folder(baseFolder, RbVmomi::VIM::Folder)
-    folders.each do |folder|
-      puts "#{ui.color("Folder Name", :cyan)}: #{folder.name}"
+	def print_vms_in_folder(folder)
+		vms = find_all_in_folder(folder, RbVmomi::VIM::VirtualMachine)
+		vms.each do |vm|
+			puts "#{ui.color("VM Name", :cyan)}: #{vm.name}"
+		end
+	end
+
+	def print_subfolders(folder)
+		folders = find_all_in_folder(folder, RbVmomi::VIM::Folder)
+    folders.each do |subfolder|
+      puts "#{ui.color("Folder Name", :cyan)}: #{subfolder.name}"
     end
-  end
+	end
+
+	def run
+		$stdout.sync = true
+		vim = get_vim_connection
+		baseFolder = find_folder(get_config(:folder));
+		if get_config(:recursive)
+			traverse_folders(baseFolder)
+		else
+			print_subfolders(baseFolder)
+			print_vms_in_folder(baseFolder)
+		end
+	end
 end

data/lib/chef/knife/vsphere_vm_state.rb

@@ -43,7 +43,7 @@ class Chef::Knife::VsphereVmState < Chef::Knife::BaseVsphereCommand
    
     vim = get_vim_connection
 
-    baseFolder = find_folder(config[:folder]);
+    baseFolder = find_folder(get_config(:folder));
 
     vm = find_in_folder(baseFolder, RbVmomi::VIM::VirtualMachine, vmname) or
       abort "VM #{vmname} not found"

data/lib/knife-vsphere/version.rb

@@ -1,4 +1,4 @@
 module KnifeVsphere
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-vsphere
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-06 00:00:00.000000000 +01:00
+date: 2012-04-16 00:00:00.000000000 -05:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: netaddr
-  requirement: &70237366117520 !ruby/object:Gem::Requirement
+  requirement: &70231050321420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.5.0
   type: :runtime
   prerelease: false
-  version_requirements: *70237366117520
+  version_requirements: *70231050321420
 - !ruby/object:Gem::Dependency
   name: chef
-  requirement: &70237366113920 !ruby/object:Gem::Requirement
+  requirement: &70231050320800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 0.10.0
   type: :runtime
   prerelease: false
-  version_requirements: *70237366113920
+  version_requirements: *70231050320800
 - !ruby/object:Gem::Dependency
   name: rbvmomi
-  requirement: &70237366111900 !ruby/object:Gem::Requirement
+  requirement: &70231050320140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,7 +44,7 @@ dependencies:
         version: 1.2.3
   type: :runtime
   prerelease: false
-  version_requirements: *70237366111900
+  version_requirements: *70231050320140
 description: VMware vSphere Support for Chef's Knife Command
 email: ezra@cpan.org
 executables: []
@@ -55,6 +55,7 @@ files:
 - lib/chef/knife/vsphere_customization_list.rb
 - lib/chef/knife/vsphere_datastore_list.rb
 - lib/chef/knife/vsphere_template_list.rb
+- lib/chef/knife/vsphere_vlan_list.rb
 - lib/chef/knife/vsphere_vm_clone.rb
 - lib/chef/knife/vsphere_vm_delete.rb
 - lib/chef/knife/vsphere_vm_list.rb