fog-proxmox 0.13.0 → 0.14.0

data/lib/fog/{compute/proxmox → proxmox/compute}/models/volumes.rb

@@ -17,7 +17,7 @@
 # You should have received a copy of the GNU General Public License
 # along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
 
-require 'fog/compute/proxmox/models/volume'
+require 'fog/proxmox/compute/models/volume'
 
 module Fog
   module Proxmox

data/lib/fog/proxmox/core.rb

@@ -25,41 +25,55 @@ module Fog
   module Proxmox
     # Core module
     module Core
-      attr_accessor :pve_ticket
-      attr_reader :pve_csrftoken
-      attr_reader :pve_username
-      attr_reader :deadline
-      attr_reader :principal
+      attr_accessor :token
+      attr_reader :auth_method
+      attr_reader :expires
+      attr_reader :current_user
+
+      def user_token?
+        @auth_token == 'user_token'
+      end
 
       # fallback
       def self.not_found_class
-        Fog::Proxmox::Compute::NotFound
+        Fog::Proxmox::Core::NotFound
       end
 
-      def initialize_identity(options)
-        @principal = nil
-        @pve_ticket = nil
-        Fog::Proxmox::Variables.to_variables(self, options, 'pve')
-        @pve_uri = URI.parse(@pve_url)
-        missing_credentials = []
-        missing_credentials << :pve_username unless @pve_username
+      def initialize(options = {})
+        setup(options)
+        authenticate
+        @auth_token.missing_credentials(options)
+        @connection = Fog::Core::Connection.new(@proxmox_url, @persistent, @connection_options)
+      end
 
-        unless @pve_ticket
-          missing_credentials << :pve_password unless @pve_password
+      def setup(options)        
+        if options.respond_to?(:config_service?) && options.config_service?
+          configure(options)
+          return
         end
-
-        raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
+        Fog::Proxmox::Variables.to_variables(self, options, 'proxmox')
+        @connection_options = options[:connection_options] || {}
+        @connection_options[:disable_proxy] = true if ENV['DISABLE_PROXY'] == 'true'    
+        @connection_options[:ssl_verify_peer] = false if ENV['SSL_VERIFY_PEER'] == 'false'
+        @proxmox_must_reauthenticate = true
+        @persistent = options[:persistent] || false  
+        @token ||= options[:proxmox_token]   
+        @auth_method ||= options[:proxmox_auth_method]   
+        if @token
+          @proxmox_can_reauthenticate = false
+        else
+          @proxmox_can_reauthenticate = true
+        end   
       end
 
       def credentials
         options = {
           provider: 'proxmox',
-          pve_url: @pve_uri.to_s,
-          pve_ticket: @pve_ticket,
-          pve_csrftoken: @pve_csrftoken,
-          pve_username: @pve_username
+          proxmox_auth_method: @auth_method,
+          proxmox_url: @proxmox_uri.to_s,
+          current_user: @current_user
         }
-        pve_options.merge options
+        proxmox_options.merge options
       end
 
       def reload
@@ -68,16 +82,22 @@ module Fog
 
       private
 
+      def expired?
+        return false if @expires.nil?
+        return false if @expires == 0
+        return @expires - Time.now.utc.to_i < 60
+      end
+
       def request(params)
         retried = false     
         begin
-          response = @connection.request(params.merge(
-                                           headers: headers(params[:method], params[:headers])
-          ))
+          authenticate! if expired?
+          request_options = params.merge(path: "#{@path}/#{params[:path]}", headers: @auth_token.headers(params[:method], params.respond_to?(:headers) ? params[:headers] : {}, {}))
+          response = @connection.request(request_options)
         rescue Excon::Errors::Unauthorized => error
           # token expiration and token renewal possible
-          if error.response.body != 'Bad username or password' && !retried
-            authenticate
+          if !%w[Bad username or password, invalid token value!].include?(error.response.body) && @proxmox_can_reauthenticate && !retried
+            authenticate!
             retried = true
             retry
           # bad credentials or token renewal not possible
@@ -95,41 +115,30 @@ module Fog
         Fog::Proxmox::Json.get_data(response)
       end
 
-      def headers(method, additional_headers)
-        additional_headers ||= {}
-        headers_hash = { 'Accept' => 'application/json' }
-        # CSRF token is required to PUT, POST and DELETE http requests
-        if %w[PUT POST DELETE].include? method
-          headers_hash.store('CSRFPreventionToken', @pve_csrftoken)
-        end
-        # ticket must be present in cookie
-        headers_hash.store('Cookie', "PVEAuthCookie=#{@pve_ticket}") if @pve_ticket
-        headers_hash.merge additional_headers
-        headers_hash
-      end
-
-      def pve_options
-        Fog::Proxmox::Variables.to_hash(self, 'pve')
+      def proxmox_options
+        Fog::Proxmox::Variables.to_hash(self, 'proxmox')
       end
 
       def authenticate
-        options = pve_options
-        @pve_ticket = options[:pve_ticket]
-        Fog::Proxmox.authenticate(options, @connection_options)
-        @principal = Fog::Proxmox.credentials
-        @pve_username = Fog::Proxmox.credentials[:username]
-        @pve_ticket = Fog::Proxmox.credentials[:ticket]
-        @pve_deadline = Fog::Proxmox.credentials[:deadline]
-        @pve_csrftoken = Fog::Proxmox.credentials[:csrftoken]
-
-        @host       = @pve_uri.host
-        @api_path   = @pve_uri.path
-        @api_path.sub!(%r{/$}, '')
-        @port       = @pve_uri.port
-        @scheme     = @pve_uri.scheme
-
+        if @proxmox_must_reauthenticate
+          @token = nil if @proxmox_must_reauthenticate
+          @auth_token = Fog::Proxmox::Auth::Token.build(proxmox_options, @connection_options)
+          @current_user = proxmox_options[:proxmox_userid] ? proxmox_options[:proxmox_userid] : proxmox_options[:proxmox_username]
+          @token = @auth_token.token
+          @expires = @auth_token.expires
+          @proxmox_must_reauthenticate = false
+        else
+          @token = @proxmox_token
+        end
+        uri = URI.parse(@proxmox_url)
+        @path = uri.path
         true
       end
+
+      def authenticate!
+        @proxmox_must_reauthenticate = true
+        authenticate
+      end
     end
   end
 end

data/lib/fog/proxmox/hash.rb

@@ -23,13 +23,13 @@ module Fog
     module Hash
 
       def self.stringify(hash)
-        filtered = hash.reject { |_key,value| value.to_s.empty? }
+        filtered = hash.reject { |_key, value| value.nil? }
         a = filtered.to_a.collect { |item| item.join('=') }
         a.join(',')
       end
 
       def self.flatten(hash)
-        filtered = hash.reject { |_key,value| value.to_s.empty? }
+        filtered = hash.reject { |_key, value| value.nil? }
         a = filtered.to_a.collect { |item| item.join(': ') }
         a.join(',')
       end

data/lib/fog/proxmox/helpers/cpu_helper.rb

@@ -21,21 +21,60 @@ module Fog
   module Proxmox
     # module Cpu mixins
     module CpuHelper
-      CPU_REGEXP = /(\bcputype=)?([\w-]+)[,]?(\bflags=)?(\+[\w-]+)?[;]?(\+[\w-]+)?/
-      def self.extract(cpu,i)
-        cpu ? CPU_REGEXP.match(cpu.to_s)[i] : ''
+      CPU_REGEXP = /(\bcputype=)?(?<cputype>[\w-]+)[,]?(\bflags=)?(?<flags>[[\+\-][\w-]+[;]?]*)/
+      FLAGS = { spectre: 'spec-ctrl', pcid: 'pcid', ssbd: 'ssbd', ibpb: 'ibpb', virt_ssbd: 'virt-ssbd', amd_ssbd: 'amd-ssbd', amd_no_ssb: 'amd-no-ssb', md_clear: 'md-clear', pdpe1gb: 'pdpe1gb', hv_tlbflush: 'hv-tlbflush', aes: 'aes', hv_evmcs: 'hv-evmcs' }
+      def self.flags
+        FLAGS
+      end
+      
+      def self.extract(cpu, name)
+        captures_h = cpu ? CPU_REGEXP.match(cpu.to_s) : { cputype: '', flags: '' }
+        captures_h[name]
+      end
+
+      def self.extract_cputype(cpu)
+        extract(cpu, :cputype)
+      end
+
+      def self.extract_flags(cpu)
+        extract(cpu, :flags)
+      end
+
+      def self.flag_value(cpu, flag_key)
+        flag_value = '0'
+        raw_values = extract_flags(cpu).split(';').select { |flag| ['+' + flag_key, '-' + flag_key].include?(flag) }
+        unless raw_values.empty?
+          flag_value = raw_values[0].start_with?('+') ? '+1' : raw_values[0].start_with?('-') ? '-1' : '0'
+        end
+        flag_value
       end
 
-      def self.extract_type(cpu)
-        extract(cpu,2)
+      def self.hash_has_no_default_flag?(cpu_h, flag_name)
+        cpu_h.key?(flag_name) && ['-1', '+1'].include?(cpu_h[flag_name])
       end
 
-      def self.has_pcid?(cpu)
-        extract(cpu,5) == '+pcid'
+      def self.hash_flag(cpu_h, flag_name)
+        flag = ''
+        if cpu_h.key?(flag_name)
+          flag = '+' if cpu_h[flag_name] == '+1'
+          flag = '-' if cpu_h[flag_name] == '-1'
+        end
+        flag
       end
 
-      def self.has_spectre?(cpu)
-        extract(cpu,4) == '+spec-ctrl'
+      def self.flatten(cpu_h)
+        return '' unless cpu_h['cpu_type']
+    
+        cpu_type = "cputype=#{cpu_h['cpu_type']}"
+        num_flags = 0
+        FLAGS.each_key { |flag_key| num_flags += 1 if hash_has_no_default_flag?(cpu_h, flag_key.to_s) }
+        cpu_type += ',flags=' if num_flags > 0
+        flags_with_no_default_value = FLAGS.select { |flag_key, _flag_value| hash_has_no_default_flag?(cpu_h, flag_key.to_s) }
+        flags_with_no_default_value.each_with_index do |(flag_key, flag_value), index|
+          cpu_type += hash_flag(cpu_h, flag_key.to_s) + flag_value if hash_has_no_default_flag?(cpu_h, flag_key.to_s)
+          cpu_type += ';' if num_flags > index + 1
+        end
+        cpu_type
       end
     end
   end

data/lib/fog/proxmox/helpers/disk_helper.rb

@@ -23,13 +23,15 @@ module Fog
   module Proxmox
     # module Disk mixins
     module DiskHelper
-      
       DISKS_REGEXP = /^(scsi|sata|mp|rootfs|virtio|ide)(\d+){0,1}$/
       SERVER_DISK_REGEXP = /^(scsi|sata|virtio|ide)(\d+)$/
       MOUNT_POINT_REGEXP = /^(mp)(\d+)$/
       ROOTFS_REGEXP = /^(rootfs)$/
       CDROM_REGEXP = /^(.*)[,]{0,1}(media=cdrom)[,]{0,1}(.*)$/
+      TEMPLATE_REGEXP = /^(.*)(base-)(.*)$/
+      CLOUD_INIT_REGEXP = /^(.*)(cloudinit)(.*)$/
 
+      # Convert disk attributes hash into API Proxmox parameters string
       def self.flatten(disk)
         id = disk[:id]
         value = ''
@@ -42,12 +44,12 @@ module Fog
           value += 'none'
         end
         opts = disk[:options] if disk[:options]
-        main_a = [:id,:volid,:storage,:size]
-        opts = disk.reject { |key,_value| main_a.include? key } unless opts
+        main_a = [:id, :volid, :storage, :size]
+        opts ||= disk.reject { |key, _value| main_a.include? key }
         options = ''
         options += Fog::Proxmox::Hash.stringify(opts) if opts
-        if id == 'ide2' && !self.cdrom?(options)
-          options += ',' if !options.empty?
+        if id == 'ide2' && !cdrom?(options)
+          options += ',' unless options.empty?
           options += 'media=cdrom'
         end
         value += ',' if !options.empty? && !value.empty?
@@ -67,25 +69,26 @@ module Fog
         id.scan(/(\w+)(\d+)/).first
       end
 
+      # Convert API Proxmox parameter string into attribute hash value
       def self.extract_option(name, disk_value)
         values = disk_value.scan(/#{name}=(\w+)/)
         name_value = values.first if values
         name_value&.first
       end
 
+      # Convert API Proxmox volume/disk parameter string into volume/disk attributes hash value
       def self.extract_storage_volid_size(disk_value)
-        #volid definition: <VOULME_ID>:=<STORAGE_ID>:<storage type dependent volume name>
+        # volid definition: <VOLUME_ID>:=<STORAGE_ID>:<storage type dependent volume name>
         values_a = disk_value.scan(/^(([\w-]+)[:]{0,1}([\w\/\.-]+))/)
         no_cdrom = !disk_value.match(CDROM_REGEXP)
         creation = disk_value.split(',')[0].match(/^(([\w-]+)[:]{1}([\d]+))$/)
         values = values_a.first if values_a
         if no_cdrom
+          storage = values[1]
           if creation
-            storage = values[1]
             volid = nil
             size = values[2].to_i
           else
-            storage = values[1]
             volid = values[0]
             size = extract_size(disk_value)
           end
@@ -98,16 +101,16 @@ module Fog
       end
 
       def self.to_bytes(size)
-        val=size.match(/\d+(\w?)/)
-        m=0
-        case val[1] 
-          when "K" then m=1
-          when "M" then m=2
-          when "G" then m=3
-          when "T" then m=4
-          when "P" then m=5
+        val = size.match(/\d+(\w?)/)
+        m = 0
+        case val[1]
+          when "K" then m = 1
+          when "M" then m = 2
+          when "G" then m = 3
+          when "T" then m = 4
+          when "P" then m = 5
         end
-        val[0].to_i*1024**m
+        val[0].to_i * 1024**m
       end
 
       def self.modulo_bytes(size)
@@ -115,20 +118,20 @@ module Fog
       end
 
       def self.to_human_bytes(size)
-        units = ['Kb','Mb','Gb','Tb','Pb']
+        units = ['Kb', 'Mb', 'Gb', 'Tb', 'Pb']
         i = 0
         human_size = size.to_s + 'b'
         while i < 5 && size >= 1024
-          size = self.modulo_bytes(size)
+          size = modulo_bytes(size)
           human_size = size.to_s + units[i]
-          i+=1            
+          i += 1
         end
         human_size
       end
 
       def self.extract_size(disk_value)
-        size=extract_option('size', disk_value)
-	      size ? self.to_bytes(size) : "1G"
+        size = extract_option('size', disk_value)
+        size ? to_bytes(size) : "1G"
       end
 
       def self.disk?(id)
@@ -154,6 +157,23 @@ module Fog
       def self.container_disk?(id)
         rootfs?(id) || mount_point?(id)
       end
+
+      def self.template?(volid)
+        TEMPLATE_REGEXP.match(volid) ? true : false
+      end
+
+      def self.cloud_init?(volid)
+        CLOUD_INIT_REGEXP.match(volid) ? true : false
+      end
+
+      def self.of_type?(disk_h, vm_type)
+        id = disk_h['id'] if disk_h.key?('id')
+        id = disk_h[:id] if disk_h.key?(:id)
+        result = false
+        result = server_disk?(id) if vm_type == 'qemu'
+        result = container_disk?(id) if vm_type == 'lxc'
+        result
+      end
     end
   end
 end