knife-xapi 0.5.4 → 0.6.0

data/lib/chef/knife/xapi_guest_create.rb

@@ -18,7 +18,6 @@
 # limitations under the License.
 #
 
-
 require 'chef/knife/xapi_base'
 
 class Chef
@@ -27,136 +26,142 @@ class Chef
       require 'timeout'
       include Chef::Knife::XapiBase
 
-      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 => "chef-full",
-        :template_file => false,
-        :run_list => [],
-        :json_attributes => {}
-      })
+      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: 'chef-full',
+        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)"
+      banner 'knife xapi guest create NAME [NETWORKS] (options)'
 
       option :xapi_vm_template,
-        :short => "-T Template Name Label",
-        :long => "--xapi-vm-template",
-        :proc => Proc.new { |key| Chef::Config[:knife][:xapi_vm_template] = key },
-        :description => "xapi template name to create from. accepts an string or regex"
+             short: '-T Template Name Label',
+             long: '--xapi-vm-template',
+             proc: proc { |key| Chef::Config[:knife][:xapi_vm_template] = key },
+             description: 'xapi template name to create from. accepts an string or regex'
 
       option :install_repo,
-        :short => "-R If you're using a builtin template you will need to specify a repo url",
-        :long => "--install-repo",
-        :description => "Install repo for this template (if needed)",
-        :proc => Proc.new { |key| Chef::Config[:knife][:install_repo] = key }
+             short: "-R If you're using a builtin template you will need to specify a repo url",
+             long: '--install-repo',
+             description: 'Install repo for this template (if needed)',
+             proc: proc { |key| Chef::Config[:knife][:install_repo] = key }
+
+      option :macaddress,
+             short: '-m MAC Address',
+             long: '--mac-address',
+             description: 'Use a pre-generated MAC address (optional)',
+             proc: proc { |key| Chef::Config[:knife][:macaddress] = key }
 
       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"
+             short: '-S Storage repo to provision VM from',
+             long: '--xapi-sr',
+             proc: proc { |key| Chef::Config[:knife][:xapi_sr] = key },
+             description: 'The Xen SR to use, If blank will use pool/hypervisor default'
 
       option :kernel_params,
-        :short => "-B Set of kernel boot params to pass to the vm",
-        :long => "--kernel-params",
-        :description => "You can add more boot options to the vm e.g.: \"ks='http://foo.local/ks'\"",
-        :proc => Proc.new { |key| Chef::Config[:knife][:kernel_params] = key }
+             short: '-B Set of kernel boot params to pass to the vm',
+             long: '--kernel-params',
+             description: "You can add more boot options to the vm e.g.: \"ks='http://foo.local/ks'\"",
+             proc: proc { |key| Chef::Config[:knife][:kernel_params] = key }
 
       option :xapi_skip_disk,
-        :long => "--xapi-skip-disk",
-        :proc =>  Proc.new { |key| Chef::Config[:knife][:xapi_skip_disk] = key },
-        :description => "Don't try to add disks to the new VM"
+             long: '--xapi-skip-disk',
+             proc: proc { |key| Chef::Config[:knife][:xapi_skip_disk] = key },
+             description: "Don't try to add disks to the new VM"
 
       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 }
+             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 { |key| Chef::Config[:knife][:xapi_disk_size] = key.to_s }
 
       option :xapi_cpus,
-        :short => "-C Number of VCPUs to provision",
-        :long =>  "--xapi-cpus",
-        :description => "Number of VCPUS this vm should have 1 4 8 etc",
-        :proc => Proc.new { |key| Chef::Config[:knife][:xapi_cpus] = key.to_s }
+             short: '-C Number of VCPUs to provision',
+             long: '--xapi-cpus',
+             description: 'Number of VCPUS this vm should have 1 4 8 etc',
+             proc: proc { |key| Chef::Config[:knife][:xapi_cpus] = key.to_s }
 
       option :xapi_mem,
-        :short => "-M Ammount of memory to provision",
-        :long => "--xapi-mem",
-        :description => "Ammount of memory the VM should have specify with m g etc 512m, 2g if no unit spcified it assumes gigabytes",
-        :proc => Proc.new { |key| Chef::Config[:knife][:xapi_mem] = key.to_s }
+             short: '-M Ammount of memory to provision',
+             long: '--xapi-mem',
+             description: 'Ammount of memory the VM should have specify with m g etc 512m, 2g if no unit spcified it assumes gigabytes',
+             proc: proc { |key| Chef::Config[:knife][:xapi_mem] = key.to_s }
 
       option :chef_node_name,
-        :short => "-N NAME",
-        :long => "--node-name NAME",
-        :description => "The Chef node name for your new node"
+             short: '-N NAME',
+             long: '--node-name NAME',
+             description: 'The Chef node name for your new node'
 
       option :ssh_key_name,
-        :short => "-S KEY",
-        :long => "--ssh-key KEY",
-        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_key_name] = key },
-        :description => "The SSH key id"
+             short: '-S KEY',
+             long: '--ssh-key KEY',
+             proc: proc { |key| Chef::Config[:knife][:ssh_key_name] = key },
+             description: 'The SSH key id'
 
       option :ssh_user,
-        :short => "-x USERNAME",
-        :long => "--ssh-user USERNAME",
-        :description => "The ssh username",
-        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_user] = key }
+             short: '-x USERNAME',
+             long: '--ssh-user USERNAME',
+             description: 'The ssh username',
+             proc: proc { |key| Chef::Config[:knife][:ssh_user] = key }
 
       option :ssh_password,
-        :short => "-P PASSWORD",
-        :long => "--ssh-password PASSWORD",
-        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_password] = key },
-        :description => "The ssh password"
+             short: '-P PASSWORD',
+             long: '--ssh-password PASSWORD',
+             proc: proc { |key| Chef::Config[:knife][:ssh_password] = key },
+             description: 'The ssh password'
 
       option :ssh_port,
-        :short => "-p PORT",
-        :long => "--ssh-port PORT",
-        :description => "The ssh port"
+             short: '-p PORT',
+             long: '--ssh-port PORT',
+             description: 'The ssh port'
 
       option :ping_timeout,
-        :long => "--ping-timeout",
-        :description => "Seconds to timeout waiting for ip from guest"
+             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"
+             long: '--bootstrap-version VERSION',
+             description: 'The version of Chef to install'
 
       option :bootstrap_template,
-        :short => "-d Template Name",
-        :long => "--bootstrap-template Template Name",
-        :description => "Bootstrap using a specific template"
+             short: '-d Template Name',
+             long: '--bootstrap-template Template Name',
+             description: 'Bootstrap using a specific template'
 
       option :template_file,
-        :short => "-F FILEPATH",
-        :long => "--template-file TEMPLATE",
-        :description => "Full path to location of template to use"
+             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",
-        :description => "A JSON string to be added to the first run of chef-client",
-        :proc => lambda { |o| JSON.parse(o) }
+             short: '-j JSON_ATTRIBS',
+             long: '--json-attributes',
+             description: 'A JSON string to be added to the first run of chef-client',
+             proc: lambda { |o| JSON.parse(o) }
 
       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,]+/) }
+             short: '-r RUN_LIST',
+             long: '--run-list RUN_LIST',
+             description: 'Comma separated list of roles/recipes to apply',
+             proc: lambda { |o| o.split(/[\s,]+/) }
 
       def tcp_test_ssh(hostname)
-        tcp_socket = TCPSocket.new(hostname, locate_config_value(:ssh_port) )
+        tcp_socket = TCPSocket.new(hostname, locate_config_value(: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}")
@@ -195,35 +200,53 @@ class Chef
         end
       end
 
-      def pingable?(guest_ip, timeout=5)
+      def pingable?(guest_ip, timeout = 5)
         sleep(20)
         system "ping -c 1 -t #{timeout} #{guest_ip} >/dev/null"
       end
 
       def get_guest_ip(vm_ref)
-        begin
-          timeout( locate_config_value(:ping_timeout).to_i ) do
-            ui.msg "Waiting for guest ip address"
-            guest_ip = ""
-            while guest_ip.empty?
-              print(".")
-              sleep  @initial_sleep_delay ||=  10
-              vgm =  xapi.VM.get_guest_metrics(vm_ref)
-              next if "OpaqueRef:NULL" == vgm
-              networks = xapi.VM_guest_metrics.get_networks(vgm)
-              if networks.has_key?("0/ip")
-                guest_ip = networks["0/ip"]
-              end
+        timeout(locate_config_value(:ping_timeout).to_i) do
+          ui.msg 'Waiting for guest ip address'
+          guest_ip = ''
+          while guest_ip.empty?
+            print('.')
+            sleep @initial_sleep_delay ||=  10
+            vgm =  xapi.VM.get_guest_metrics(vm_ref)
+            next if 'OpaqueRef:NULL' == vgm
+            networks = xapi.VM_guest_metrics.get_networks(vgm)
+            if networks.key?('0/ip')
+              guest_ip = networks['0/ip']
             end
-            puts "\n"
-            return guest_ip
           end
-        rescue Timeout::Error
-          ui.msg "Timeout waiting for XAPI to report IP address "
+          puts "\n"
+          return guest_ip
         end
+      rescue Timeout::Error
+        ui.msg 'Timeout waiting for XAPI to report IP address '
       end
 
 
+      def resolve_sr_ref
+        ui_sr = locate_config_value(:xapi_sr)
+        sr_ref = nil
+        if locate_config_value(:xapi_sr)
+          if is_uuid?(ui_sr)
+            sr_ref = get_sr_by_uuid(ui_sr)
+          else
+            sr_ref = get_sr_by_name(ui_sr)
+          end
+        else
+          sr_ref = find_default_sr
+        end
+
+        if sr_ref.nil?
+          ui.error "SR specified not found or can't be used Aborting"
+          fail(vm_ref) if sr_ref.nil?
+        end
+        sr_ref
+      end
+
       def run
         server_name = @name_args[0]
         domainname = locate_config_value(:domain)
@@ -234,11 +257,18 @@ class Chef
         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 )}"
-        task = xapi.Async.VM.clone(template_ref, fqdn)
-        ui.msg "Waiting on Template Clone"
+        template_ref = find_template(locate_config_value(:xapi_vm_template))
+        sr_ref = resolve_sr_ref 
+
+        if locate_config_value(:xapi_sr)
+		      Chef::Log.debug "Copying Guest from Template: #{h.color(template_ref, :bold, :cyan)}"
+          task = xapi.Async.VM.copy(template_ref, fqdn, sr_ref)
+        else 
+		      Chef::Log.debug "Cloning Guest from Template: #{h.color(template_ref, :bold, :cyan)}"
+          task = xapi.Async.VM.clone(template_ref, fqdn)
+        end
+
+        ui.msg 'Waiting on Template Clone'
         vm_ref = get_task_ref(task)
 
         Chef::Log.debug "New VM ref: #{vm_ref}"
@@ -251,23 +281,25 @@ class Chef
           repo = locate_config_value(:install_repo)
 
           # make sure we don't clobber existing params
-          other_config = Hash.new 
+          other_config = {}
           record = xapi.VM.get_record(vm_ref)
-          if record.has_key? "other_config"
-            other_config = record["other_config"] 
+          if record.key? 'other_config'
+            other_config = record['other_config']
           end
-          other_config["install-repository"] = repo
-          # for some reason the deb disks template is wonkey and has weird entry here
+          other_config['install-repository'] = repo
+         
+          # remove any disk config/xml template might be trying to do (ubuntu)
           other_config.delete_if {|k,v| k=="disks"} 
+
           Chef::Log.debug "Other_config: #{other_config.inspect}"
           xapi.VM.set_other_config(vm_ref, other_config)
 
-          cpus = locate_config_value( :xapi_cpus ).to_s
+          cpus = locate_config_value(:xapi_cpus).to_s
 
-          xapi.VM.set_VCPUs_max( vm_ref, cpus )
-          xapi.VM.set_VCPUs_at_startup( vm_ref, cpus )
+          xapi.VM.set_VCPUs_max(vm_ref, cpus)
+          xapi.VM.set_VCPUs_at_startup(vm_ref, cpus)
 
-          memory_size = input_to_bytes( locate_config_value(:xapi_mem) ).to_s
+          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)
 
@@ -283,100 +315,89 @@ class Chef
           boot_args << " domain=#{domainname}" unless boot_args.match(/domain=.+\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
-            clear_vm_vifs( xapi.VM.get_record( vm_ref ) )
+            clear_vm_vifs(xapi.VM.get_record(vm_ref))
             networks.each_with_index do |net, index|
               add_vif_by_name(vm_ref, index, net)
             end
           end
 
-          unless locate_config_value(:xapi_skip_disk)
-            sr_ref = nil
-            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"
-              fail(vm_ref) if sr_ref.nil?
-            end
-            Chef::Log.debug "SR: #{h.color sr_ref, :cyan}"
-       
+          Chef::Log.debug "SR: #{h.color sr_ref, :cyan}"
 
+          unless locate_config_value(:xapi_skip_disk)
             disk_size = locate_config_value(:xapi_disk_size)
-            # setup disks 
-            if disk_size != nil and disk_size.to_i > 0
-              # when a template already has disks, we decide the position number based on it. 
-              position = xapi.VM.get_VBDs(vm_ref).length 
+            # setup disks
+            if !disk_size.nil? && disk_size.to_i > 0
+              # 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) )
+              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
-              position == 0 ?  bootable=true : bootable=false
+              position == 0 ?  bootable = true : bootable = false
 
               vbd_ref = create_vbd(vm_ref, vdi_ref, position, bootable)
               fail(vm_ref) unless vbd_ref
             end
           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 "CPUs:   #{ h.color( locate_config_value(:xapi_cpus).to_s, :bold, :cyan)}"
-          ui.msg "Disk:   #{ h.color( disk_size.to_s, :bold, :cyan)}"
+          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 "CPUs:   #{ h.color(locate_config_value(:xapi_cpus).to_s, :bold, :cyan)}"
+          ui.msg "Disk:   #{ h.color(disk_size.to_s, :bold, :cyan)}"
           provisioned = xapi.VM.provision(vm_ref)
 
-          ui.msg "Starting new Guest #{h.color( provisioned, :cyan)} "
+          ui.msg "Starting new Guest #{h.color(provisioned, :cyan)} "
           start(vm_ref)
 
           exit 0 unless locate_config_value(:run_list)
-        rescue Exception => e
-          ui.msg "#{h.color 'ERROR:'} #{h.color( e.message, :red )}"
+        rescue => 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)}"
-          fail(vm_ref)
+          puts 'Nested backtrace:'
+          ui.msg "#{h.color(e.backtrace.join("\n"), :yellow)}"
+          raise(vm_ref)
         end
 
         if locate_config_value(:run_list).empty?
-          unless ( locate_config_value(:template_file) or locate_config_value(:bootstrap_template) )
+          unless locate_config_value(:template_file) or
+                 locate_config_value(:bootstrap_template) != 'chef-full' 
             exit 0
           end
         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")
+        if guest_addr.nil? || guest_addr.empty?
+          ui.msg('ip seems wrong using host+domain name instead')
           guest_addr = "#{server_name}.#{domainname}"
         end
         ui.msg "Trying to connect to guest @ #{guest_addr} "
 
         begin
           timeout(480) do
-            print(".") until tcp_test_ssh(guest_addr) {
+            print('.') until tcp_test_ssh(guest_addr) do
               sleep @initial_sleep_delay ||=  10
-              ui.msg( "#{ h.color "OK!", :green}" )
-            }
+              ui.msg("#{ h.color 'OK!', :green}")
+            end
           end
         rescue Timeout::Error
-          ui.msg "Timeout trying to login Wont bootstrap"
-          fail
+          ui.msg 'Timeout trying to login Wont bootstrap'
+          raise
         end
 
         begin
           bootstrap = Chef::Knife::Bootstrap.new
-          bootstrap.name_args = [ guest_addr ]
+          bootstrap.name_args = [guest_addr]
           bootstrap.config[:run_list] = locate_config_value(:run_list)
           bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
           bootstrap.config[:ssh_port] = locate_config_value(:ssh_port)
@@ -393,15 +414,13 @@ class Chef
           bootstrap.config[:run_list] = locate_config_value(:run_list)
 
           bootstrap.run
-        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)}"
-          fail
+        rescue => e
+          ui.msg "#{h.color 'ERROR:'} #{h.color(e.message, :red)}"
+          puts 'Nested backtrace:'
+          ui.msg "#{h.color(e.backtrace.join("\n"), :yellow)}"
+          raise
         end
       end
-
     end
   end
 end
-