knife-proxmox 0.0.12

data/TODO

@@ -0,0 +1,7 @@
+Description Resource    Path    Location    Type
+FIXME: storage = local debería ser tambien un parametro configurable    proxmox_template_list.rb    /knife-proxmox/lib/chef line 53 Studio Task
+TODO: Create a good gem using this tutorial http://guides.rubygems.org/make-your-own-gem/#writing-tests
+TODO: All inputs MUST be checked and errors MUST be catched.
+TODO: Testing of everything
+TODO: change ticket.gsub for CGI.escape(str)    proxmox_server_create.rb    /knife-proxmox/lib/chef line 110    Studio Task
+TODO: parameters for openvz should be in other object   proxmox_server_create.rb    /knife-proxmox/lib/chef line 55 Studio Task

data/knife-proxmox.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "knife-proxmox/version"
+
+Gem::Specification.new do |s|
+  s.name        = "knife-proxmox"
+  s.version     = Knife::Proxmox::VERSION
+  s.has_rdoc = false
+  s.authors     = ["Jorge Moratilla", "Sergio Galvan"]
+  s.email       = ["jorge@moratilla.com","sergalma@gmail.com"]
+  s.homepage = "http://wiki.opscode.com/display/chef"
+  s.summary = "ProxmoxVE Support for Chef's Knife Command"
+  s.description = s.summary
+  s.extra_rdoc_files = ["README", "LICENSE","TODO","CHANGELOG" ]
+
+  s.files         = Dir['lib/**/*.rb'] + Dir['./*']
+  s.add_dependency "chef", ">= 0.10.10"
+  s.add_dependency "rest-client", ">=1.6.7"
+  s.add_dependency "json", ">=1.5.4"
+  s.require_paths = ["lib"]
+
+end

data/lib/chef/knife/connection.rb

@@ -0,0 +1,34 @@
+# This class should be a singleton with all the logic to use proxmox
+
+class Connection
+  
+  @site = nil
+  @auth_params = nil
+  @servers = {}
+  @templates = {}
+  
+  def initialize()
+    @site = RestClient::Resource.new(Chef::Config[:knife][:pve_cluster_url])
+    @auth_params ||= begin
+      ticket = nil
+      csrf_prevention_token = nil
+      @site['access/ticket'].post :username=>Chef::Config[:knife][:pve_user_name],
+        :realm=>Chef::Config[:knife][:pve_user_realm],
+        :password=>Chef::Config[:knife][:pve_user_password] do |response, request, result, &block| 
+        if response.code == 200 then
+          data = JSON.parse(response.body)
+          ticket = data['data']['ticket']
+          csrf_prevention_token = data['data']['CSRFPreventionToken']
+          if !ticket.nil? then
+            token = 'PVEAuthCookie=' + ticket.gsub!(/:/,'%3A').gsub!(/=/,'%3D')
+          end
+        end
+      end
+      {:CSRFPreventionToken => csrf_prevention_token, :cookie => token} 
+    end
+    
+  end
+  
+  
+  
+end

data/lib/chef/knife/proxmox_base.rb

@@ -0,0 +1,251 @@
+require 'chef/knife'
+#TODO: Testing of everything
+#TODO: All inputs MUST be checked and errors MUST be catched.
+class Chef
+  class Knife
+    module ProxmoxBase
+      
+      def self.included(includer)
+        includer.class_eval do
+
+          deps do
+            require 'rubygems'
+            require 'rest_client'
+            require 'json'
+            require 'chef/json_compat'
+            require 'cgi'
+            require 'chef/log'
+            require 'set'
+            require 'net/ssh/multi'
+            require 'chef/api_client'
+            require 'chef/node'
+          end
+          
+          # options
+          option :pve_cluster_url,
+            :short => "-U URL",
+            :long  => "--pve_cluster_url URL",
+            :description => "Your URL to access Proxmox VE server/cluster",
+            :proc  => Proc.new {|url| Chef::Config[:knife][:pve_cluster_url] = url }
+            
+          option :pve_user_name,
+            :short => "-u username",
+            :long  => "--username username",
+            :description => "Your username in Proxmox VE",
+            :proc  => Proc.new {|username| Chef::Config[:knife][:pve_user_name] = username }
+            
+          option :pve_user_password,
+            :short => "-p password",
+            :long  => "--password password",
+            :description => "Your password in Proxmox VE",
+            :proc  => Proc.new {|password| Chef::Config[:knife][:pve_user_password] = password }
+            
+          option :pve_user_realm,
+            :short => "-r realm",
+            :long  => "--realm realm",
+            :description => "Your realm of Authentication in Proxmox VE",
+            :proc  => Proc.new {|realm| Chef::Config[:knife][:pve_user_realm] = realm }
+            
+          option :pve_node_name,
+            :short => "-n node",
+            :long  => "--node nodename",
+            :description => "Proxmox VE server name where you will actuate",
+            :proc  => Proc.new {|node| Chef::Config[:knife][:pve_node_name] = node }
+          
+        end
+      end
+      
+      # Checks that the parameter provided is defined in knife.rb
+      def check_global_parameter(value)
+        if (Chef::Config[:knife][value].nil? or Chef::Config[:knife][value].empty?) then
+          ui.error "knife[:#{value.to_s}] is empty, define a value for it and try again"
+          exit 1
+        end
+        Chef::Log.debug("knife[:#{value}] = " + Chef::Config[:knife][value])
+      end
+      
+      def check_config_parameter(value)
+        if (config[value].nil? or config[value].empty?) then
+          ui.error "--#{value} is empty, define a value for it and try again"
+          exit 1
+        end
+      end
+      
+      # Establishes the connection with proxmox server
+      def connection
+        # First, let's check we have all info needed to connect to pve
+        [:pve_cluster_url, :pve_node_name, :pve_user_name, :pve_user_password, :pve_user_realm].each do |value|
+          check_global_parameter(value)
+        end
+        
+        @connection ||= RestClient::Resource.new(Chef::Config[:knife][:pve_cluster_url])
+        @auth_params ||= begin
+          token = nil
+          csrf_prevention_token = nil
+          @connection['access/ticket'].post :username=>Chef::Config[:knife][:pve_user_name],
+            :realm=>Chef::Config[:knife][:pve_user_realm],
+            :password=>Chef::Config[:knife][:pve_user_password] do |response, request, result, &block| 
+            if response.code == 200 then
+              data = JSON.parse(response.body)
+              ticket = data['data']['ticket']
+              csrf_prevention_token = data['data']['CSRFPreventionToken']
+              if !ticket.nil? then
+                token = 'PVEAuthCookie=' + ticket.gsub!(/:/,'%3A').gsub!(/=/,'%3D')
+              end
+            end
+          end
+          {:CSRFPreventionToken => csrf_prevention_token, :cookie => token} 
+        end
+      end
+      
+      # new_vmid: calculates a new vmid from the highest existing vmid
+      def new_vmid
+        vmid ||= @connection['cluster/resources?type=vm'].get @auth_params do |response, request, result, &block|
+          data = JSON.parse(response.body)['data']
+          vmids = Set[]
+          data.each {|entry|
+            vmids.add entry['vmid']
+          }
+          (vmids.max + 1).to_s
+        end
+      end
+
+      # locate_config_value: find a value in arguments or default chef config properties
+      def locate_config_value(key)
+        key = key.to_sym
+        Chef::Config[:knife][key] || config[key]
+      end
+      
+      # template_number_to_name: converts the id from the template list to the real name in the storage
+      # of the node
+      def template_number_to_name(number,storage)
+        template_list = []
+        #TODO: esta parte hay que sacarla a un modulo comun de acceso a templates
+        @connection["nodes/#{Chef::Config[:knife][:pve_node_name]}/storage/#{storage}/content"].get @auth_params do |response, request, result, &block|
+          JSON.parse(response.body)['data'].each { |entry|
+            if entry['content'] == 'vztmpl' then
+              template_list << entry['volid']
+            end
+          }
+        end
+        return CGI.escape(template_list[number.to_i])
+      end
+      
+      # server_name_to_vmid: Use the name of the server to get the vmid
+      def server_name_to_vmid(name)
+        @connection['cluster/resources?type=vm'].get @auth_params do |response, request, result, &block|
+          data = JSON.parse(response.body)['data']
+          data.each {|entry|
+            return entry['vmid'] if entry['name'].to_s.match(name)
+          }
+        end
+      end
+      
+      # vmid_to_node: Specify the vmid and get the node in which is
+      def vmid_to_node(vmid)
+        @connection['cluster/resources?type=vm'].get @auth_params do |response, request, result, &block|
+          data = JSON.parse(response.body)['data']
+          data.each {|entry|
+            return entry['node'] if entry['vmid'].to_s.match(vmid.to_s)
+          }
+        end
+      end
+      
+      def action_response(action,response)
+        result = nil
+        taskid = nil
+        begin
+          if (response.code == 200) then
+            result = "OK"
+          else
+            result = "NOK: error code = " + response.code.to_s
+          end
+          taskid = JSON.parse(response.body)['data']
+          waitfor(taskid)
+          Chef::Log.debug("Action: #{action}, Result: #{result}\n")
+        rescue Exception => msg
+          result = "An exception ocurred.  Use -VV to show it"
+          Chef::Log.debug("Action: #{action}, Result: #{msg}\n")
+        end
+        ui.msg(result)
+      end
+      
+      # waitfor end of the task, need the taskid and the timeout
+      def waitfor(taskid, timeout=60)
+        taskstatus = nil
+        while taskstatus.nil? and timeout>= 0 do
+          print "."
+          @connection["nodes/#{Chef::Config[:knife][:pve_node_name]}/tasks/#{taskid}/status"].get @auth_params do |response, request, result, &block|
+            taskstatus = (JSON.parse(response.body)['data']['status'] == "stopped")?true:nil
+          end
+          timeout-=1
+          sleep(1)
+        end
+      end
+      
+      def server_start(vmid)
+        node = vmid_to_node(vmid)
+        ui.msg("Starting VM #{vmid} on node #{node}....")
+        @connection["nodes/#{node}/openvz/#{vmid}/status/start"].post "", @auth_params do |response, request, result, &block|
+          # take the response and extract the taskid
+          action_response("server start",response)
+        end
+        
+      end
+      
+      # server_stop: Stops the server
+      def server_stop(vmid)
+        node = vmid_to_node(vmid)
+        ui.msg("Stopping VM #{vmid} on node #{node}...")
+        @connection["nodes/#{node}/openvz/#{vmid}/status/stop"].post "", @auth_params do |response, request, result, &block|
+          # take the response and extract the taskid
+          action_response("server stop",response)
+        end
+      end
+      
+      def server_create(vmid,vm_definition)
+        ui.msg("Creating VM #{vmid}...")
+        @connection["nodes/#{Chef::Config[:knife][:pve_node_name]}/openvz"].post "#{vm_definition}", @auth_params do |response, request, result, &block|
+          action_response("server create",response)
+        end
+      end
+      
+      # server_get_address: Returns the IP Address of the machine to chef
+      # field is a string, and if it doesn't exist, it will return nil
+      def server_get_data(vmid,field)
+        node = vmid_to_node(vmid)
+        @connection["nodes/#{node}/openvz/#{vmid}/status/current"].get @auth_params do |response, request, result, &block|
+          #action_response("server get data",response)
+          data = JSON.parse(response.body)['data'][field]
+        end
+      end
+      # server_destroy: Destroys the server
+      def server_destroy(vmid)
+        node = vmid_to_node(vmid)
+        ui.msg("Destroying VM #{vmid} on node #{node}...")
+        @connection["nodes/#{node}/openvz/#{vmid}"].delete @auth_params do |response, request, result, &block|
+          action_response("server destroy",response)
+        end
+      end
+      
+      # 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(klass, name, type_name)
+        begin
+          object = klass.load(name)
+          object.destroy
+          ui.warn("Deleted #{type_name} #{name}")
+        rescue Net::HTTPServerException
+          ui.warn("Could not find a #{type_name} named #{name} to delete!")
+        end
+      end
+      
+      
+      
+      
+    end # module
+  end # class 
+end # class

data/lib/chef/knife/proxmox_server_create.rb

@@ -0,0 +1,234 @@
+require 'chef/knife/proxmox_base'
+
+class Chef
+  class Knife
+    class ProxmoxServerCreate < Knife
+      
+      include Knife::ProxmoxBase
+      
+      deps do
+        require 'readline'
+        require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
+      end
+      
+      banner "knife proxmox server create (options)"
+      
+      # TODO: parameters for openvz should be in other object
+      option :vm_hostname,
+        :short => "-H hostname",
+        :long  => "--hostname hostname",
+        :description => "VM instance hostname"
+
+      option :vm_cpus,
+        :short => "-C CPUs",
+        :long  => "--cpus number",
+        :description => "Number of cpus of the VM instance"
+
+      option :vm_memory,
+        :short => "-M MB",
+        :long  => "--mem MB",
+        :description => "Memory in MB"
+
+      option :vm_swap,
+        :short => "-SW",
+        :long  => "--swap MB",
+        :description => "Memory in MB for swap"
+
+      option :vm_vmid,
+        :short => "-I id",
+        :long  => "--vmid id",
+        :description => "Id for the VM"
+
+      option :vm_disk,
+        :short => "-D disk",
+        :long  => "--disk GB",
+        :description => "Disk space in GB"
+
+      option :vm_storage,
+        :short => "-ST name",
+        :long  => "--storage name",
+        :description => "Name of the storage where to reserve space"
+
+      option :vm_password,
+        :short => "-P password",
+        :long  => "--vm_pass password",
+        :description => "root password for VM (openvz only)",
+        :default     => "proxmox"
+
+      option :vm_netif,
+        :short => "-N netif",
+        :long  => "--netif netif_specification",
+        :description => "description of the network interface (experimental)"
+
+      option :vm_template,
+        :short => "-T number",
+        :long  => "--template number",
+        :description => "id of the template"
+
+      option :vm_ipaddress,
+        :short => "-ip ipaddress",
+        :long  => "--ipaddress IP Address",
+        :description => "force guest to use venet interface with this ip address"
+
+      option :bootstrap,
+        :long => "--[no-]bootstrap",
+        :description => "Bootstrap the server, enable by default",
+        :boolean => true,
+        :default => true
+        
+      option :bootstrap_version,
+        :long => "--bootstrap-version VERSION",
+        :description => "The version of Chef to install",
+        :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
+
+      option :distro,
+        :short => "-d DISTRO",
+        :long => "--distro DISTRO",
+        :description => "Bootstrap a distro using a template; default is 'chef-full'",
+        :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
+        :default => "chef-full"
+
+      option :template_file,
+        :long => "--template-file TEMPLATE",
+        :description => "Full path to location of template to use",
+        :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
+        :default => false
+
+      option :run_list,
+        :short => "-r RUN_LIST",
+        :long => "--run-list RUN_LIST",
+        :description => "Comma separated list of roles/recipes to apply",
+        :proc => lambda { |o| o.split(/[\s,]+/) },
+        :default => []
+
+      option :first_boot_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 => {}
+
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
+
+      option :host_key_verify,
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, enabled by default",
+        :boolean => true,
+        :default => true
+
+      option :environment,
+        :short=> "-e environment",
+        :long => "--environment environment",
+        :description => "Chef environment",
+        :proc => Proc.new {|env| Chef::Config[:knife][:environment] = env },
+        :default => '_default'
+
+      def run
+        # Needed
+        connection
+        
+        vm_id       = config[:vm_vmid]     || new_vmid
+        vm_hostname = config[:vm_hostname] || 'proxmox'
+        vm_storage  = config[:vm_storage]  || 'local'
+        vm_password = config[:vm_password] || 'pve123'
+        vm_cpus     = config[:vm_cpus]     || 1
+        vm_memory   = config[:vm_memory]   || 512
+        vm_disk     = config[:vm_disk]     || 4
+        vm_swap     = config[:vm_swap]     || 512
+        vm_ipaddress= config[:vm_ipaddress]|| nil
+        vm_netif    = config[:vm_netif]    || 'ifname%3Deth0%2Cbridge%3Dvmbr0'
+        vm_template = template_number_to_name(config[:vm_template],vm_storage) || 'local%3Avztmpl%2Fubuntu-11.10-x86_64-jorge2-.tar.gz'
+        
+        vm_definition = "vmid=#{vm_id}&hostname=#{vm_hostname}&storage=#{vm_storage}&password=#{vm_password}&ostemplate=#{vm_template}&memory=#{vm_memory}&swap=#{vm_swap}&disk=#{vm_disk}&cpus=#{vm_cpus}"
+        
+        # Add ip_address parameter to vm_definition if it's provided by CLI
+        if (config[:vm_ipaddress]) then 
+          vm_definition += "&ip_address=" + vm_ipaddress
+        elsif (config[:vm_netif] || vm_netif) then
+          vm_definition += "&netif=" + vm_netif
+        end
+        
+        Chef::Log.debug(vm_definition)
+        
+        server_create(vm_id,vm_definition)
+        ui.msg("Preparing the server to start")
+        sleep(5)
+        server_start(vm_id)
+        sleep(5)
+        
+        # which IP address to bootstrap
+        bootstrap_ip_address = server_get_data(vm_id,'ip')
+        ui.msg("New Server #{vm_id} has IP Address: #{server_get_data(vm_id,'ip')}")
+        
+        if bootstrap_ip_address.nil?
+          ui.error("No IP address available for bootstrapping.")
+          exit 1
+        end
+
+        print(".") until tcp_test_ssh(bootstrap_ip_address) {
+          sleep @initial_sleep_delay ||= 10
+          puts("done")
+        }
+
+        # bootstrapping the node
+        if config[:bootstrap]
+          bootstrap_for_node(bootstrap_ip_address).run
+        else
+          ui.msg("Skipping bootstrap of the server because --no-bootstrap used as argument.")   
+        end 
+      
+      end
+      
+      def tcp_test_ssh(hostname)
+        tcp_socket = TCPSocket.new(hostname, 22)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
+          yield
+          true
+        else
+          false
+        end
+      rescue Errno::ETIMEDOUT
+        false
+      rescue Errno::EPERM
+        false
+      rescue Errno::ECONNREFUSED
+        sleep 2
+        false
+      rescue Errno::EHOSTUNREACH
+        sleep 2
+        false
+      ensure
+        tcp_socket && tcp_socket.close
+      end
+
+      def bootstrap_for_node(bootstrap_ip_address)
+        bootstrap = Chef::Knife::Bootstrap.new
+        bootstrap.name_args = [bootstrap_ip_address]
+        bootstrap.config[:run_list] = config[:run_list]
+        bootstrap.config[:environment] = locate_config_value(:environment)
+        # bootstrap.config[:first_boot_attributes] = config[:first_boot_attributes]
+        bootstrap.config[:ssh_user] = "root"
+        bootstrap.config[:ssh_password] = config[:vm_password]
+        # bootstrap.config[:identity_file] = config[:identity_file]
+        # bootstrap.config[:host_key_verify] = config[:host_key_verify]
+        bootstrap.config[:chef_node_name] = config[:vm_hostname]
+        # bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+        bootstrap.config[:distro] = locate_config_value(:distro)
+        # bootstrap will run as root...sudo (by default) also messes up Ohai on CentOS boxes
+        # bootstrap.config[:use_sudo] = false
+        bootstrap.config[:template_file] = locate_config_value(:template_file)
+        
+        pp bootstrap.config
+        bootstrap
+      end
+    end
+  end
+end