knife-xapi 0.3.5 → 0.3.6

data/lib/chef/knife/xapi_base.rb

@@ -26,6 +26,23 @@ 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'
 require 'xenapi'
@@ -33,6 +50,7 @@ require 'xenapi'
 class Chef::Knife
     module XapiBase
 
+
     def self.included(includer)
       includer.class_eval do
         deps do
@@ -45,17 +63,27 @@ class Chef::Knife
         option :xapi_host,
           :short => "-h SERVER_URL",
           :long => "--host SERVER_URL",
+          :proc => Proc.new { |key| Chef::Config[:knife][:xapi_host] = key },
           :description => "The url to the xenserver, http://somehost.local.lan/"
 
         option :xapi_password,
           :short => "-K PASSWORD",
           :long => "--xapi-password PASSWORD",
+          :proc => Proc.new { |key| Chef::Config[:knife][:xapi_password] = key },
           :description => "Your xenserver password"
 
         option :xapi_username,
           :short => "-A USERNAME",
           :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
@@ -86,7 +114,7 @@ class Chef::Knife
 
     def locate_config_value(key)
       key = key.to_sym
-      config[key] || Chef::Config[:knife][key] 
+      config[key] || Chef::Config[:knife][key]  || XAPI_DEFAULTS[key] 
     end
 
     # get template by name_label

data/lib/chef/knife/xapi_guest_create.rb

@@ -25,6 +25,7 @@ class Chef
   class Knife
     class XapiGuestCreate < Knife
       include Chef::Knife::XapiBase
+
       require 'timeout'
 
       deps do
@@ -32,53 +33,51 @@ class Chef
         Chef::Knife::Bootstrap.load_deps
       end
 
+
+
       banner "knife xapi guest create NAME [NETWORKS] (options)"
 
-      option :vm_template,
+      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"
 
-      option :domain,
-        :short => "-f Name",
-        :long => "--domain Name",
-        :description => "the domain name for the guest",
-        :default => "" 
-
       option :install_repo,
         :short => "-R If you're using a builtin template you will need to specify a repo url",
-        :long => "--xapi-install-repo",
+        :long => "--install-repo",
         :description => "Install repo for this template (if needed)",
-        :default => "http://isoredirect.centos.org/centos/6/os/x86_64/"
+        :proc => Proc.new { |key| Chef::Config[:knife][:install_repo] = 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"
 
       option :kernel_params,
         :short => "-B Set of kernel boot params to pass to the vm",
-        :long => "--xapi-kernel-params",
+        :long => "--kernel-params",
         :description => "You can add more boot options to the vm e.g.: \"ks='http://foo.local/ks'\"",
-        :default => "graphical utf8" 
+        :proc => Proc.new { |key| Chef::Config[:knife][:kernel_params] = key }
 
       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",
-        :default => "8g"
+        :proc => Proc.new { |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",
-        :default => 2
+        :proc => Proc.new { |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",
-        :default => "1g"
+        :proc => Proc.new { |key| Chef::Config[:knife][:xapi_mem] = key.to_s }
 
       option :chef_node_name,
         :short => "-N NAME",
@@ -88,24 +87,25 @@ class Chef
       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"
 
       option :ssh_user,
         :short => "-x USERNAME",
         :long => "--ssh-user USERNAME",
         :description => "The ssh username",
-        :default => "root"
+        :proc => Proc.new { |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"
 
       option :ssh_port,
         :short => "-p PORT",
         :long => "--ssh-port PORT",
-        :description => "The ssh port",
-        :default => "22"
+        :description => "The ssh port"
 
       option :bootstrap_version,
         :long => "--bootstrap-version VERSION",
@@ -114,31 +114,27 @@ class Chef
       option :bootstrap_template,
         :short => "-d Template Name",
         :long => "--bootstrap-template Template Name",
-        :description => "Bootstrap using a specific template",
-        :default => "ubuntu10.04-gems"
+        :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",
-        :default => false
-    
+        :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) },
-        :default => {}
+        :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,]+/) },
-        :default => [] 
+        :proc => lambda { |o| o.split(/[\s,]+/) }
 
       def tcp_test_ssh(hostname)
-        tcp_socket = TCPSocket.new(hostname, config[: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}")
@@ -209,13 +205,18 @@ class Chef
 
       def run 
         server_name = @name_args[0]
-        $stdout.sync = true
+        domainname = locate_config_value(:domain)
+        if domainname.empty?
+          fqdn = server_name
+        else 
+          fqdn = "#{server_name}.#{domainname}"
+        end
       
         # get the template vm we are going to build from
-        template_ref = find_template( locate_config_value(:vm_template) )
+        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, server_name)  
+        vm_ref = xapi.VM.clone(template_ref, fqdn)  
 
         # TODO: lift alot of this
         begin
@@ -239,7 +240,6 @@ class Chef
           # setup the Boot args
           #
           boot_args = locate_config_value(:kernel_params) 
-          domainname = locate_config_value(:domain)
 
           # if no hostname param set hostname to given vm name
           boot_args << " hostname=#{server_name}" unless boot_args.match(/hostname=.+\s?/) 
@@ -281,7 +281,7 @@ class Chef
           cleanup(vm_ref) unless vbd_ref 
           ui.msg( "#{ h.color "OK", :green}" )
  
-          ui.msg "Provisioning new Guest: #{h.color(vm_ref, :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)}" 
@@ -327,29 +327,24 @@ class Chef
           cleanup(vm_ref)
         end
 
-
+        
         begin 
-          if domainname.empty?
-            server = server_name
-          else 
-            server = "#{server_name}.#{domainname}"
-          end
           bootstrap = Chef::Knife::Bootstrap.new
           bootstrap.name_args = [ guest_addr ]
-          bootstrap.config[:run_list] = config[:run_list]
-          bootstrap.config[:ssh_user] = config[:ssh_user]
-          bootstrap.config[:ssh_port] = config[:ssh_port]
-          bootstrap.config[:ssh_password] = config[:ssh_password]
-          bootstrap.config[:identity_file] = config[:identity_file]
-          bootstrap.config[:chef_node_name] = config[:chef_node_name] || server
+          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)
+          bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
+          bootstrap.config[:identity_file] = locate_config_value(:identity_file)
+          bootstrap.config[:chef_node_name] = config[:chef_node_name] || fqdn
           bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
           bootstrap.config[:first_boot_attributes] = locate_config_value(:json_attributes)
           bootstrap.config[:distro] = locate_config_value(:bootstrap_template)
-          bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
+          bootstrap.config[:use_sudo] = true unless locate_config_value(:ssh_user) == 'root'
           bootstrap.config[:template_file] = locate_config_value(:template_file)
           bootstrap.config[:environment] = config[:environment]
           bootstrap.config[:host_key_verify] = false
-          bootstrap.config[:run_list] = config[:run_list]
+          bootstrap.config[:run_list] = locate_config_value(:run_list)
           
           bootstrap.run
         rescue Exception => e 

data/lib/chef/knife/xapi_guest_delete.rb

@@ -35,7 +35,7 @@ class Chef
 
       def run 
         server_name = @name_args[0]
-        $stdout.sync = true
+
         vms = [] 
         if config[:uuid]
           vms << xapi.VM.get_by_uuid(server_name)

data/lib/knife-xapi/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-xapi
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
   prerelease: 
 platform: ruby
 authors: