knife-xapi 0.3.6 → 0.4.1

data/lib/chef/knife/xapi_base.rb

@@ -1,6 +1,6 @@
 # Xapi Base Module
 #
-# Description:: Setup the Session and auth for xapi 
+# Description:: Setup the Session and auth for xapi
 #   other common methods used for talking with the xapi
 #
 # Author:: Jesse Nelson <spheromak@gmail.com>
@@ -21,27 +21,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# ruby 1.8.7 doesn't like ||= with  Constants
-unless defined?(XAPI_TEMP_REGEX)
-  XAPI_TEMP_REGEX = /^CentOS 5.*\(64-bit\)/
-end
-
-unless defined?(XAPI_DEFAULTS)
-  XAPI_DEFAULTS = {
-    :domain => "",
-    :ssh_user => "root",
-    :ssh_port => "22",
-    :install_repo =>  "http://isoredirect.centos.org/centos/6/os/x86_64/",
-    :xapi_disk_size => "graphical utf8",
-    :xapi_disk_size => "8g",
-    :xapi_cpus => "1g",
-    :xapi_mem => "1g",
-    :bootstrap_template => "ubuntu10.04-gems",
-    :template_file => false,
-    :run_list => [],
-    :json_attributes => {}
-  }
-end
 
 require 'chef/knife'
 require 'units/standard'
@@ -50,15 +29,17 @@ require 'xenapi'
 class Chef::Knife
     module XapiBase
 
+    attr :defaults
 
     def self.included(includer)
       includer.class_eval do
+
         deps do
           require 'xenapi'
           require 'highline'
           require 'highline/import'
-          require 'readline'  
-        end 
+          require 'readline'
+        end
 
         option :xapi_host,
           :short => "-h SERVER_URL",
@@ -77,36 +58,51 @@ class Chef::Knife
           :long => "--xapi-username USERNAME",
           :proc => Proc.new { |key| Chef::Config[:knife][:xapi_username] = key },
           :description => "Your xenserver username"
-      
+
         option :domain,
           :short => "-f Name",
           :long => "--domain Name",
           :description => "the domain name for the guest",
           :proc => Proc.new { |key| Chef::Config[:knife][:domain] = key }
-
       end
+    end
+
+
+
+    def self.set_defaults(config)
+      @defaults ||= Hash.new
+      @defaults.merge!(config)
+    end
+
+    # set the default template
+    self.set_defaults( { :template_regex =>  /^CentOS 5.*\(64-bit\)/ } )
+
+    def self.defaults
+      @defaults ||= Hash.new
+    end
 
+    def self.get_default(key)
+      @defaults[key] || nil
     end
 
-    # highline setup
     def h
       @highline ||= ui.highline
-    end 
+    end
 
     # setup and return an authed xen api instance
     def xapi
-      @xapi ||= begin 
+      @xapi ||= begin
 
         ui.fatal "Must provide a xapi host with --host "unless locate_config_value(:xapi_host)
         session = XenApi::Client.new(  locate_config_value(:xapi_host) )
-        
+
         # get the password from the user
         password =  locate_config_value(:xapi_password) || nil
         username =  locate_config_value(:xapi_username) || "root"
         if password.nil?  or password.empty?
           password = h.ask("Enter password for user #{username}:  " ) { |input| input.echo = "*" }
         end
-        session.login_with_password(username, password) 
+        session.login_with_password(username, password)
 
         session
       end
@@ -114,7 +110,7 @@ class Chef::Knife
 
     def locate_config_value(key)
       key = key.to_sym
-      config[key] || Chef::Config[:knife][key]  || XAPI_DEFAULTS[key] 
+      config[key] || Chef::Config[:knife][key]  || Chef::Knife::XapiBase.get_default(key)
     end
 
     # get template by name_label
@@ -123,12 +119,13 @@ class Chef::Knife
     end
 
     #
-    # find a template matching what the user provided 
-    # 
+    # find a template matching what the user provided
+    #
     # returns a ref to the vm or nil if nothing found
-    # 
-    def find_template(template=XAPI_TEMP_REGEX)
-      # if we got a string then try to find that template exact 
+    #
+    def find_template(template)
+      template = locate_config_value(:template_regex) if template.nil?
+      # if we got a string then try to find that template exact
       #  if no exact template matches, search
       if template.is_a?(String)
         found = get_template(template)
@@ -137,23 +134,23 @@ class Chef::Knife
 
       #  make sure our nil template gets set to default
       if template.nil?
-        template = XAPI_TEMP_REGEX
-      end 
+        template = locate_config_value(:template_regex)
+      end
 
       Chef::Log.debug "Name: #{template.class}"
       # quick and dirty string to regex
       unless template.is_a?(Regexp)
-        template = /#{template}/ 
+        template = /#{template}/
       end
 
-      # loop over all vm's and find the template 
+      # loop over all vm's and find the template
       # Wish there was a better API method for this, and there might be
       #  but i couldn't find it
       Chef::Log.debug "Using regex: #{template}"
       xapi.VM.get_all_records().each_value do |vm|
         if vm["is_a_template"] and  vm["name_label"] =~ template
           Chef::Log.debug "Matched: #{h.color(vm["name_label"], :yellow )}"
-          found = vm # we're gonna go with the last found 
+          found = vm # we're gonna go with the last found
         end
       end
 
@@ -164,26 +161,67 @@ class Chef::Knife
       end
       return nil
     end
- 
-    # present a list of options for a user to select 
+
+    # present a list of options for a user to select
     # return the selected item
     def user_select(items)
-      choose do |menu|
+      h.choose do |menu|
         menu.index  = :number
         menu.prompt = "Please Choose One:"
         menu.select_by =  :index_or_name
         items.each do |item|
-          menu.choice item.to_sym do |command| 
-            say "Using: #{command}" 
+          menu.choice item.to_sym do |command|
+            ui.msg "Using: #{command}"
             selected = command.to_s
           end
         end
+        menu.choice :all do return :all end
         menu.choice :exit do exit 1 end
       end
     end
 
+    # destroy/remove VM refs and exit
+    def cleanup(vm_ref)
+      # shutdown and dest
+      unless xapi.VM.get_power_state(vm_ref) == "Halted"
+        ui.msg "Shutting down Guest"
+        task = xapi.Async.VM.hard_shutdown(vm_ref)
+        get_task_ref(task) unless task == "Halted"
+      end
+
+      ui.msg "Removing disks attached to Guest"
+      Chef::Log.debug "getting vbds attached to #{vm_ref}"
+      wait_tasks = []
+      xapi.VM.get_VBDs(vm_ref).to_a.each do |vbd|
+        next unless vbd
+
+        Chef::Log.debug "removing vbd: #{vbd}"
+        wait_tasks << xapi.Async.VDI.destroy( xapi.VBD.get_record(vbd)["VDI"] )
+        wait_tasks << xapi.Async.VBD.destroy(vbd)
+      end
+
+      # wait for disk cleanup to finish up
+      unless wait_tasks.empty?
+        ui.msg "waiting for disks to cleanup"
+        wait_tasks.each do |task|
+          wait_on_task(task)
+        end
+      end
+
+      ui.msg "Destroying Guest"
+      task = xapi.Async.VM.destroy(vm_ref)
+      wait_on_task(task)
+    end
+
+    # cleanup a vm and exit (fail)
+    def fail(ref=nil)
+      ui.warn "Error encountered clenaing up and exiting"
+      cleanup ref if ref
+      exit 1
+    end
+
     # generate a random mac address
-    def generate_mac 
+    def generate_mac
       ("%02x"%(rand(64)*4|2))+(0..4).inject(""){|s,x|s+":%02x"%rand(256)}
     end
 
@@ -191,19 +229,19 @@ class Chef::Knife
     def add_vif_by_name(vm_ref, dev_num, net_name)
       Chef::Log.debug "Looking up vif for: #{h.color(net_name, :cyan)}"
       network_ref = xapi.network.get_by_name_label(net_name).first
-      if network_ref.nil? 
-        if net_name =~ /Network (\d)+$/  # special handing for 'Network X' As displayed by XenCenter   
+      if network_ref.nil?
+        if net_name =~ /Network (\d)+$/  # special handing for 'Network X' As displayed by XenCenter
           add_vif_by_name(vm_ref, dev_num, "Pool-wide network associated with eth#{$1}")
         else
           ui.warn "#{h.color(net_name,:red)} not found, moving on"
         end
-        return 
+        return
       end
 
       mac = generate_mac
       Chef::Log.debug "Provisioning:  #{h.color(net_name, :cyan)}, #{h.color(mac,:green)}, #{h.color(network_ref, :yellow)}"
 
-      vif = { 
+      vif = {
         'device'  => dev_num.to_s,
         'network' => network_ref,
         'VM'  => vm_ref,
@@ -227,7 +265,7 @@ class Chef::Knife
 
     # returns sr_ref to the default sr on pool
     def find_default_sr()
-      xapi.pool.get_default_SR( xapi.pool.get_all()[0] ) 
+      xapi.pool.get_default_SR( xapi.pool.get_all()[0] )
     end
 
     # return an SR record from the name_label
@@ -259,7 +297,7 @@ class Chef::Knife
     def create_vdi(name, sr_ref, size)
       vdi_record = {
         "name_label" => "#{name}",
-        "name_description" => "Root disk for #{name} created by knfie xapi",
+        "name_description" => "Root disk for #{name} created by #{ENV['USER']} with knfie xapi",
         "SR" => sr_ref,
         "virtual_size" => input_to_bytes(size).to_s,
         "type" => "system",
@@ -267,7 +305,7 @@ class Chef::Knife
         "read_only" => false,
         "other_config" => {},
       }
-    
+
       # Async create the VDI
       task = xapi.Async.VDI.create(vdi_record)
       ui.msg "waiting for VDI Create"
@@ -282,35 +320,41 @@ class Chef::Knife
         sleep 1
       end
     end
-   
+
     # return the opaque ref of the task that was run by a task record if it succeded.
-    # else it returns nil 
+    # else it returns nil
     def get_task_ref(task)
+      Chef::Log.debug "Waiting on task #{task}"
       wait_on_task(task)
-      case xapi.task.get_status(task) 
+      status_ = xapi.task.get_status(task)
+
+      case status_
       when "success"
-        # xapi task record returns result as  <value>OpaqueRef:....</value>  
+        puts "#{h.color "#{status_}", :green }"
+        # xapi task record returns result as  <value>OpaqueRef:....</value>
         # we want the ref. this way it will work if they fix it to return jsut the ref
         ref = xapi.task.get_result(task).match(/OpaqueRef:[^<]+/).to_s
+
         #cleanup our task
         xapi.task.destroy(task)
         return ref
-      else 
-        ui.msg( "#{h.color 'ERROR:', :red } Task returned: #{xapi.task.get_result(task)}"   )
-        return nil
+      else
+        ui.msg( "#{h.color "#{status_}", :red } ")
+        ui.msg( "#{h.color 'ERROR:', :red } #{xapi.task.get_error_info(task)}"   )
       end
     end
 
 
-    # create vbd and return a ref 
-    def create_vbd(vm_ref, vdi_ref, position)
+    # create vbd and return a ref
+    # defaults to bootable
+    def create_vbd(vm_ref, vdi_ref, position, boot=true)
       vbd_record = {
         "VM" => vm_ref,
         "VDI" => vdi_ref,
         "empty" => false,
         "other_config" => {"owner"=>""},
         "userdevice" => position.to_s,
-        "bootable" => true,
+        "bootable" => boot,
         "mode" => "RW",
         "qos_algorithm_type" => "",
         "qos_algorithm_params" => {},
@@ -320,7 +364,7 @@ class Chef::Knife
 
       task = xapi.Async.VBD.create(vbd_record)
       ui.msg "Waiting for VBD create"
-      vbd_ref = get_task_ref(task) 
+      vbd_ref = get_task_ref(task)
     end
 
     # try to get a guest ip and return it
@@ -334,7 +378,51 @@ class Chef::Knife
         end
       end
       return guest_ip
-    end 
+    end
+
+    def get_vbds_from_vdi(vdi_ref)
+      return xapi.VDI.get_VBDs(vdi_ref)
+    end
+
+    def get_all_vdis()
+      return xapi.VDI.get_all()
+    end
 
+    def get_vdi_by_uuid(id)
+      return xapi.VDI.get_by_uuid(id)
+    end
+
+    def get_vdi_by_name_label(name)
+      return xapi.VDI.get_by_name_label(name)
+    end
+
+    def print_vdi_info(vdi_ref)
+      puts "#{h.color "VDI name: " + xapi.VDI.get_name_label(vdi_ref), :green}"
+      puts "  -Description: " + xapi.VDI.get_name_description(vdi_ref)
+      puts "  -Type: " + xapi.VDI.get_type(vdi_ref)
+    end
+
+    def yes_no_prompt(str)
+      print str
+      choice = STDIN.gets
+
+      while !(choice.match(/^yes$|^no$/))
+        puts "Invalid input! Type \'yes\' or \'no\':"
+        choice = STDIN.gets
+      end
+
+      if choice.match('yes')
+        return true
+      else
+        return false
+      end
+    end
+
+    def destroy_vdi(vdi_ref)
+      task = xapi.Async.VDI.destroy(vdi_ref)
+      print "Destroying volume "
+      puts "#{h.color xapi.VDI.get_name_label(vdi_ref), :cyan}"
+      task_ref = get_task_ref(task)
+    end
   end
 end

data/lib/chef/knife/xapi_guest_create.rb

@@ -8,9 +8,9 @@
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -24,17 +24,30 @@ require 'chef/knife/xapi_base'
 class Chef
   class Knife
     class XapiGuestCreate < Knife
+      require 'timeout'
       include Chef::Knife::XapiBase
 
-      require 'timeout'
+      Chef::Knife::XapiBase.set_defaults( {
+        :domain => "",
+        :ssh_user => "root",
+        :ssh_port => "22",
+        :ping_timeout => 600,
+        :install_repo =>  "http://isoredirect.centos.org/centos/6/os/x86_64/",
+        :kernel_params => "graphical utf8",
+        :xapi_disk_size => "8g",
+        :xapi_cpus => "1",
+        :xapi_mem => "1g",
+        :bootstrap_template => "ubuntu10.04-gems",
+        :template_file => false,
+        :run_list => [],
+        :json_attributes => {}
+      })
 
       deps do
         require 'chef/knife/bootstrap'
         Chef::Knife::Bootstrap.load_deps
       end
 
-
-
       banner "knife xapi guest create NAME [NETWORKS] (options)"
 
       option :xapi_vm_template,
@@ -107,6 +120,10 @@ class Chef
         :long => "--ssh-port PORT",
         :description => "The ssh port"
 
+      option :ping_timeout,
+        :long => "--ping-timeout",
+        :description => "Seconds to timeout waiting for ip from guest"
+
       option :bootstrap_version,
         :long => "--bootstrap-version VERSION",
         :description => "The version of Chef to install"
@@ -120,7 +137,7 @@ class Chef
         :short => "-F FILEPATH",
         :long => "--template-file TEMPLATE",
         :description => "Full path to location of template to use"
-   
+
       option :json_attributes,
         :short => "-j JSON_ATTRIBS",
         :long => "--json-attributes",
@@ -153,7 +170,6 @@ class Chef
       rescue Errno::ECONNREFUSED
         sleep 2
         false
-      # This happens on EC2 quite often
       rescue Errno::EHOSTUNREACH
         sleep 2
         false
@@ -163,11 +179,11 @@ class Chef
 
       def wait_for_guest_ip(vm_ref)
         begin
-          timeout(480) do
-            ui.msg "Waiting for guest ip address" 
+          timeout( locate_config_value(:ping_timeout).to_i ) do
+            ui.msg "Waiting for guest ip address"
             guest_ip = ""
             while guest_ip.empty?
-              print(".") 
+              print(".")
               sleep  @initial_sleep_delay ||=  10
               vgm =  xapi.VM.get_guest_metrics(vm_ref)
               next if "OpaqueRef:NULL" == vgm
@@ -176,56 +192,41 @@ class Chef
                 guest_ip = networks["0/ip"]
               end
             end
-            puts "\n" 
+            puts "\n"
             return guest_ip
-          end 
+          end
         rescue Timeout::Error
           ui.msg "Timeout waiting for XAPI to report IP address "
         end
       end
 
-      # destroy/remove VM refs and exit
-      def cleanup(vm_ref)
-        ui.warn "Cleaning up work and exiting"
-        # shutdown and dest
-        unless xapi.VM.get_power_state(vm_ref) == "Halted"
-          print "Shutting down Guest"
-          task = xapi.Async.VM.hard_shutdown(vm_ref)
-          wait_on_task(task)
-          print " #{h.color "Done", :green} \n"
-        end
-
-        print "Destroying Guest"
-        task = xapi.Async.VM.destroy(vm_ref)
-        wait_on_task(task)
-        print " #{h.color "Done", :green} \n"
-        exit 1 
-      end
-
 
-      def run 
+      def run
         server_name = @name_args[0]
         domainname = locate_config_value(:domain)
         if domainname.empty?
           fqdn = server_name
-        else 
+        else
           fqdn = "#{server_name}.#{domainname}"
         end
-      
+
         # get the template vm we are going to build from
         template_ref = find_template( locate_config_value(:xapi_vm_template) )
 
-        Chef::Log.debug "Cloning Guest from Template: #{h.color(template_ref, :bold, :cyan )}" 
-        vm_ref = xapi.VM.clone(template_ref, fqdn)  
+        Chef::Log.debug "Cloning Guest from Template: #{h.color(template_ref, :bold, :cyan )}"
+        task = xapi.Async.VM.clone(template_ref, fqdn)
+        ui.msg "Waiting on Template Clone"
+        vm_ref = get_task_ref(task)
+
+        Chef::Log.debug "New VM ref: #{vm_ref}"
 
         # TODO: lift alot of this
         begin
-          xapi.VM.set_name_description(vm_ref, "VM from knife-xapi as #{server_name}")
+          xapi.VM.set_name_description(vm_ref, "VM from knife-xapi as #{server_name} by #{ENV['USER']}")
 
           # configure the install repo
           repo = locate_config_value(:install_repo)
           xapi.VM.set_other_config(vm_ref, { "install-repository" => repo } )
-          
 
           cpus = locate_config_value( :xapi_cpus ).to_s
 
@@ -234,84 +235,88 @@ class Chef
 
           memory_size = input_to_bytes( locate_config_value(:xapi_mem) ).to_s
           #  static-min <= dynamic-min = dynamic-max = static-max
-          xapi.VM.set_memory_limits(vm_ref, memory_size, memory_size, memory_size, memory_size) 
+          xapi.VM.set_memory_limits(vm_ref, memory_size, memory_size, memory_size, memory_size)
 
-          # 
+          #
           # setup the Boot args
           #
-          boot_args = locate_config_value(:kernel_params) 
+          boot_args = locate_config_value(:kernel_params)
 
           # if no hostname param set hostname to given vm name
-          boot_args << " hostname=#{server_name}" unless boot_args.match(/hostname=.+\s?/) 
+          boot_args << " hostname=#{server_name}" unless boot_args.match(/hostname=.+\s?/)
           # if domainname is supplied we put that in there as well
-          boot_args << " domainname=#{domainname}" unless boot_args.match(/domainname=.+\s?/) 
+          boot_args << " dnsdomain=#{domainname}" unless boot_args.match(/dnsdomain=.+\s?/)
 
-          xapi.VM.set_PV_args( vm_ref, boot_args ) 
+          xapi.VM.set_PV_args( vm_ref, boot_args )
 
           # TODO: validate that the vm gets a network here
           networks = @name_args[1..-1]
           # if the user has provided networks
-          if networks.length >= 1  
+          if networks.length >= 1
             clear_vm_vifs( xapi.VM.get_record( vm_ref ) )
-            networks.each_with_index do |net, index| 
+            networks.each_with_index do |net, index|
               add_vif_by_name(vm_ref, index, net)
             end
           end
 
           if locate_config_value(:xapi_sr)
-            sr_ref = get_sr_by_name( locate_config_value(:xapi_sr) ) 
+            sr_ref = get_sr_by_name( locate_config_value(:xapi_sr) )
           else
             sr_ref = find_default_sr
           end
 
           if sr_ref.nil?
             ui.error "SR specified not found or can't be used Aborting"
-            cleanup(vm_ref)
-          end 
-          Chef::Log.debug "SR: #{h.color sr_ref, :cyan}" 
-
-          # Create the VDI
-          vdi_ref = create_vdi("#{server_name}-root", sr_ref, locate_config_value(:xapi_disk_size) )
-          # if vdi_ref is nill we need to bail/cleanup
-          cleanup(vm_ref) unless vdi_ref
-          ui.msg( "#{ h.color "OK", :green} ")
-
-          # Attach the VDI to the VM
-          vbd_ref = create_vbd(vm_ref, vdi_ref, 0)
-          cleanup(vm_ref) unless vbd_ref 
-          ui.msg( "#{ h.color "OK", :green}" )
- 
-          ui.msg "Provisioning new Guest: #{h.color(fqdn, :bold, :cyan )}" 
+            fail(vm_ref) if sr_ref.nil?
+          end
+          Chef::Log.debug "SR: #{h.color sr_ref, :cyan}"
+        
+          # setup disks 
+          if locate_config_value(:xapi_disk_size)
+            # when a template already has disks, we decide the position number based on it. 
+	    	    position = xapi.VM.get_VBDs(vm_ref).length
+
+            # Create the VDI
+            vdi_ref = create_vdi("#{server_name}-root", sr_ref, locate_config_value(:xapi_disk_size) )
+            fail(vm_ref) unless vdi_ref
+
+            # Attach the VDI to the VM
+            # if its position is 0 set it bootable
+            vbd_ref = create_vbd(vm_ref, vdi_ref, position, position == 0)
+            fail(vm_ref) unless vbd_ref
+          end
+
+
+          ui.msg "Provisioning new Guest: #{h.color(fqdn, :bold, :cyan )}"
           ui.msg "Boot Args: #{h.color boot_args,:bold, :cyan}"
           ui.msg "Install Repo: #{ h.color(repo,:bold, :cyan)}"
-          ui.msg "Memory: #{ h.color( locate_config_value(:xapi_mem).to_s, :bold, :cyan)}" 
+          ui.msg "Memory: #{ h.color( locate_config_value(:xapi_mem).to_s, :bold, :cyan)}"
           ui.msg "CPUs:   #{ h.color( locate_config_value(:xapi_cpus).to_s, :bold, :cyan)}"
           ui.msg "Disk:   #{ h.color( locate_config_value(:xapi_disk_size).to_s, :bold, :cyan)}"
           provisioned = xapi.VM.provision(vm_ref)
 
           ui.msg "Starting new Guest #{h.color( provisioned, :cyan)} "
           task = xapi.Async.VM.start(vm_ref, false, true)
-          wait_on_task(task) 
+          wait_on_task(task)
           ui.msg( "#{ h.color "OK!", :green}" )
 
-          exit 0 unless locate_config_value(:run_list)       
+          exit 0 unless locate_config_value(:run_list)
         rescue Exception => e
           ui.msg "#{h.color 'ERROR:'} #{h.color( e.message, :red )}"
           # have to use join here to pass a string to highline
           puts "Nested backtrace:"
           ui.msg "#{h.color( e.backtrace.join("\n"), :yellow)}"
-          
-          cleanup(vm_ref)
+          fail(vm_ref)
         end
 
         if locate_config_value(:run_list).empty? or ! locate_config_value(:template_file)
-          exit 0 
+          exit 0
         end
 
         guest_addr = wait_for_guest_ip(vm_ref)
         if guest_addr.nil? or guest_addr.empty?
           ui.msg("ip seems wrong using host+domain name instead")
-          guest_addr = "#{host_name}.#{domainname}"
+          guest_addr = "#{server_name}.#{domainname}"
         end
         ui.msg "Trying to connect to guest @ #{guest_addr} "
 
@@ -323,12 +328,11 @@ class Chef
             }
           end
         rescue Timeout::Error
-          ui.msg "Timeout trying to login cleaning up"
-          cleanup(vm_ref)
+          ui.msg "Timeout trying to login Wont bootstrap"
+          fail
         end
 
-        
-        begin 
+        begin
           bootstrap = Chef::Knife::Bootstrap.new
           bootstrap.name_args = [ guest_addr ]
           bootstrap.config[:run_list] = locate_config_value(:run_list)
@@ -345,15 +349,14 @@ class Chef
           bootstrap.config[:environment] = config[:environment]
           bootstrap.config[:host_key_verify] = false
           bootstrap.config[:run_list] = locate_config_value(:run_list)
-          
+
           bootstrap.run
-        rescue Exception => e 
+        rescue Exception => e
           ui.msg "#{h.color 'ERROR:'} #{h.color( e.message, :red )}"
           puts "Nested backtrace:"
           ui.msg "#{h.color( e.backtrace.join("\n"), :yellow)}"
-          cleanup(vm_ref)
+          fail
         end
-
       end
 
     end

data/lib/chef/knife/xapi_guest_delete.rb

@@ -26,6 +26,11 @@ class Chef
     class XapiGuestDelete < Knife
       include Chef::Knife::XapiBase
 
+      deps do
+        require 'chef/api_client'
+        require 'chef/json_compat'
+      end
+
       banner "knife xapi guest delete NAME_LABEL (options)"
 
       option :uuid,
@@ -33,9 +38,30 @@ class Chef
           :long => "--uuid",
           :description => "Treat the label as a UUID not a name label"
 
+      option :keep_client,
+        :short => "-C",
+        :long => "--keep-client",
+        :description => "Keep client info on the chef-server"
+
+      option :keep_node,
+        :short => "-N",
+        :long => "--keep-node",
+        :description => "Keep node info on the chef-server"
+
       def run 
         server_name = @name_args[0]
 
+        if server_name.nil?
+          puts "Error: No VM Name specified..."
+          puts "Usage: " + banner
+          exit 1
+        end
+
+        name = server_name
+        if config[:uuid]
+          name = get_name_label(vm)
+        end
+
         vms = [] 
         if config[:uuid]
           vms << xapi.VM.get_by_uuid(server_name)
@@ -45,30 +71,48 @@ class Chef
         vms.flatten! 
 
         if vms.empty? 
-          ui.msg "VM not found: #{h.color server_name, :red}" 
+          puts "VM not found: #{h.color server_name, :red}" 
           exit 1
         elsif vms.length > 1
-          ui.msg "Multiple VM matches found use guest list if you are unsure"
+          puts "Multiple VM matches found use guest list if you are unsure"
           vm = user_select(vms)
         else 
           vm = vms.first
         end
+       
+        # Cleanup the VM
+        if vm == :all
+          vms.each {|vm| cleanup(vm) }
+        else 
+          cleanup(vm)
+        end
 
-        # shutdown and dest
-        unless xapi.VM.get_power_state(vm) == "Halted" 
-          print "Shutting down Guest:" 
-          task = xapi.Async.VM.hard_shutdown(vm)
-          wait_on_task(task)
-          print " #{h.color "Done", :green} \n"
+        #############################################
+        # Delete client and node on the chef server #
+        #############################################
+        unless config[:keep_client]
+          client_list = Chef::ApiClient.list
+
+          if client_list.has_key?(name)	
+            ui.msg "Removing client  #{h.color name, :cyan} from chef"
+            delete_object(Chef::ApiClient, name)
+          else
+            puts "Client not found on the chef server.. Nothing to delete.."
+          end
         end
 
-        print "Destroying Guest: #{h.color( server_name, :cyan)} " 
-        task = xapi.Async.VM.destroy(vm) 
-        wait_on_task(task)
-        print " #{h.color "Done", :green}\n"
+        unless config[:keep_node]
+          env = Chef::Config[:environment]
+          node_list = env ? Chef::Node.list_by_environment(env) : Chef::Node.list
+          if node_list.has_key?(name)
+            ui.msg "Removing node #{h.color name, :cyan} from chef "
+            delete_object(Chef::Node, name)
+          else
+            puts "Node not found on the chef server.. Nothing to delete.."
+          end
+        end
       end
 
     end
   end
 end
-

data/lib/chef/knife/xapi_vdi_create.rb

@@ -0,0 +1,90 @@
+#
+# Author:: Jesse Nelson (<spheromak@gmail.com>)
+#
+# Copyright:: Copyright (c) 2012 Jesse Nelson
+#
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+require 'chef/knife/xapi_base'
+
+class Chef
+  class Knife
+    class XapiVdiCreate < Knife
+      require 'timeout'
+      include Chef::Knife::XapiBase
+
+      banner "knife xapi vdi create NAME (options)"
+
+      option :xapi_sr,
+        :short => "-S Storage repo to provision VM from",
+        :long  => "--xapi-sr",
+        :proc => Proc.new { |key| Chef::Config[:knife][:xapi_sr] = key },
+        :description => "The Xen SR to use, If blank will use pool/hypervisor default"
+
+      option :xapi_disk_size,
+        :short => "-D Size of disk. 1g 512m etc",
+        :long  =>  "--xapi-disk-size",
+        :description => "The size of the root disk, use 'm' 'g' 't' if no unit specified assumes g",
+        :proc => Proc.new { |key| Chef::Config[:knife][:xapi_disk_size] = key.to_s }
+
+      def run
+        disk_name = @name_args[0]
+        if disk_name.nil?
+          puts "Error: No Disk Name specified..."
+          puts "Usage: " + banner
+          exit 1
+        end
+
+        begin
+          if locate_config_value(:xapi_sr)
+            sr_ref = get_sr_by_name( locate_config_value(:xapi_sr) )
+          else
+            sr_ref = find_default_sr
+          end
+
+          if sr_ref.nil?
+            ui.error "SR specified not found or can't be used Aborting"
+          end
+          Chef::Log.debug "SR: #{h.color sr_ref, :cyan}"
+
+	    	  size = locate_config_value(:xapi_disk_size) 
+
+          vdi_record = {
+            "name_label" => disk_name,
+            "name_description" => "#{disk_name} created by #{ENV['USER']}",
+            "SR" => sr_ref,
+            "virtual_size" => input_to_bytes(size).to_s,
+            "type" => "system",
+            "sharable" => false,
+            "read_only" => false,
+            "other_config" => {},
+          }
+
+          # Async create the VDI
+          task = xapi.Async.VDI.create(vdi_record)
+          ui.msg "waiting for VDI Create.."
+          vdi_ref = get_task_ref(task)
+
+          ui.msg "Disk Name:   #{ h.color( disk_name, :bold, :cyan)}"
+          ui.msg "Disk Size:   #{ h.color( size.to_s, :bold, :cyan)}"
+
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/knife/xapi_vdi_delete.rb

@@ -0,0 +1,131 @@
+#
+# Author:: Jesse Nelson (<spheromak@gmail.com>)
+#
+# Copyright:: Copyright (c) 2012 Jesse Nelson
+#
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+require 'chef/knife/xapi_base'
+
+class Chef
+  class Knife
+    class XapiVdiDelete < Knife
+      include Chef::Knife::XapiBase
+
+      banner "knife xapi vdi delete NAME_LABEL (options)"
+
+      option :uuid,
+        :short => "-U",
+        :long => "--uuid",
+        :description => "Treat the label as a UUID not a name label"
+
+      option :cleanup,
+        :short => "-C",
+        :long => "--cleanup",
+        :description => "Clean up all orphaned volumes."
+
+      option :interactive,
+        :short => "-I",
+        :long => "--interactive",
+        :description => "Interactive clean-up of orphaned volumes"
+
+      def run 
+        if config[:interactive]
+          # Get all VDIs known to the system
+          vdis = get_all_vdis()
+          first = true
+
+          for vdi_ in vdis do
+            vbds = get_vbds_from_vdi(vdi_)
+            if vbds.empty? and xapi.VDI.get_type(vdi_).match('system')
+              if first
+                puts "================================================"
+                first = false
+              end
+
+              print_vdi_info(vdi_)
+              ret = yes_no_prompt("  No VM attached! Do you want to destroy this volume? (Type \'yes\' or \'no\'): ")
+
+              if ret
+                destroy_vdi(vdi_)
+              end
+              puts "================================================"
+            end
+          end
+
+        elsif config[:cleanup]
+          orphaned_vdis = []
+          vdis = get_all_vdis()
+
+          for vdi_ in vdis do
+            vbds = get_vbds_from_vdi(vdi_)
+            if vbds.empty? and xapi.VDI.get_type(vdi_).match('system')
+              orphaned_vdis << vdi_
+            end
+          end
+
+          for item in orphaned_vdis do
+            print_vdi_info(item)
+          end
+
+          unless orphaned_vdis.empty?
+            ret = yes_no_prompt("Do you want to destroy all these volumes? (Type \'yes\' or \'no\'): ")
+            if ret
+              for item in orphaned_vdis do
+                destroy_vdi(item)
+              end
+            end
+          end
+
+        else
+          vdi_name = @name_args[0]
+          if vdi_name.nil?
+            puts "Error: No VDI Name specified..."
+            puts "Usage: " + banner
+            exit 1
+          end
+
+          vdis = [] 
+          if config[:uuid]
+            vdis << get_vdi_by_uuid(vdi_name)
+          else
+            vdis << get_vdi_by_name_label(vdi_name)
+          end
+          vdis.flatten! 
+
+          if vdis.empty? 
+            puts "VDI not found: #{h.color vdi_name, :red}" 
+            exit 1
+          elsif vdis.length > 1
+            puts "Multiple VDI matches found. Use vdi list if you are unsure"
+            vdi = user_select(vdis)
+          else 
+            vdi = vdis.first
+          end
+
+          vbds = get_vbds_from_vdi(vdi)
+
+          if vbds.empty? 
+            destroy_vdi(vdi)
+          else
+            puts "ERROR! The VDI is still in use."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/xapi_vdi_list.rb

@@ -0,0 +1,60 @@
+#
+# Author:: Jesse Nelson (<spheromak@gmail.com>)
+#
+# Copyright:: Copyright (c) 2012 Jesse Nelson
+#
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+require 'chef/knife/xapi_base'
+
+class Chef
+  class Knife
+    class XapiVdiList < Knife
+      include Chef::Knife::XapiBase
+
+      banner "knife xapi vdi list"
+
+      def run 
+          # Get all VDIs known to the system
+          vdis = xapi.VDI.get_all()
+
+          puts "================================================"
+          for vdi_ in vdis do
+            puts "#{h.color "VDI name: " + xapi.VDI.get_name_label(vdi_), :green}"
+            puts "  -UUID: " + xapi.VDI.get_uuid(vdi_)
+            puts "  -Description: " + xapi.VDI.get_name_description(vdi_)
+            puts "  -Type: " + xapi.VDI.get_type(vdi_)
+
+            vbds = xapi.VDI.get_VBDs(vdi_)
+            for vbd in vbds do
+              vm = xapi.VBD.get_VM(vbd)
+              state = xapi.VM.get_power_state(vm)
+              puts "    -VM name: " + xapi.VM.get_name_label(vm)
+              puts "    -VM state: " + state + "\n"
+            end
+
+            if vbds.empty? and xapi.VDI.get_type(vdi_).match('system')
+                puts "  No VM attached!"
+                #puts "  No VM attached! Use vdi delete --cleanup to delete this volume."
+            end
+            puts "================================================"
+          end
+      end
+    end
+  end
+end
+

data/lib/knife-xapi/version.rb

@@ -1,3 +1,3 @@
 module KnifeXenserver
-  VERSION = "0.3.6"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-xapi
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-14 00:00:00.000000000 Z
+date: 2012-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -87,6 +87,9 @@ files:
 - lib/chef/knife/xapi_guest_create.rb
 - lib/chef/knife/xapi_guest_delete.rb
 - lib/chef/knife/xapi_guest_list.rb
+- lib/chef/knife/xapi_vdi_create.rb
+- lib/chef/knife/xapi_vdi_delete.rb
+- lib/chef/knife/xapi_vdi_list.rb
 - lib/knife-xapi/version.rb
 homepage: https://github.com/spheromak/knife-xapi
 licenses: []
@@ -108,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Xen API Support for Chef's Knife Command