kitchen-proxmox 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3ed7c8556ee380cd5845babc8b085c3a660736b81ac8f1b1ac92cc62ec4840d
-  data.tar.gz: 8a82f387b8a24b8dfafc4dd99cb9baaa65c62483d3b564974d46a469ec40582e
+  metadata.gz: fa03e257c553dacbc24d63abaa1a21b0bdf7be8dd2434afef6d304b2925bd23e
+  data.tar.gz: eea6142b73c7f1b0d82ec61f628b0aae64fca365df598c815c282e37c47dbaaf
 SHA512:
-  metadata.gz: 750a0b65316bcce6dccdb70c6c0c5061e830ddd7bb26011a034d1fe2e081805b6ca928ee7f027a4d5ee4e472916fed0b56ca6c7914747953596a579d64682b48
-  data.tar.gz: 71499dc0562fa3aa1691d6712fc4b70c9a4f608e27d1cb22f9370c7f604915aa869ca800e0adc817b8c0b3f5b5d8670a32ec2630b69d6eb30b737dad7ed5f17a
+  metadata.gz: 4c558a3b1e537092dcc396e610f42a7695d088c316ae1cb3bfceacd1dbaab918c2b1751adc1123bf2e5855407bd2e840e7e698c34739b2524a8e9de3a43ff987
+  data.tar.gz: c59edb23fa7d0f06bc247db4c10a93b6c82c29402d3138e9477e6f815538bcaae5235651f058c914928626aeb11eaeaeba511f4c1e3ec3cc3884ef6b8a51cdaa

data/lib/kitchen/driver/proxmox/api_client.rb

@@ -58,7 +58,8 @@ module Kitchen
 
         def clone_vm(node:, template_id:, new_id:, **options)
           full = options.fetch(:full, true)
-          body = { newid: new_id, full: full ? 1 : 0, target: node }
+          target = options.fetch(:target, node)
+          body = { newid: new_id, full: full ? 1 : 0, target: }
           body[:name] = options[:name] if options[:name]
           body[:pool] = options[:pool] if options[:pool]
           body[:storage] = options[:storage] if options[:storage]
@@ -130,6 +131,10 @@ module Kitchen
           resources.select { |r| r['template'] == 1 }
         end
 
+        def list_storage(node:)
+          get("/api2/json/nodes/#{node}/storage")
+        end
+
         private
 
         def get(path)

data/lib/kitchen/driver/proxmox/errors.rb

@@ -33,6 +33,12 @@ module Kitchen
             response_body.match?(/does not exist/i) ||
             response_body.match?(/can't lock file.*lock-\d+/i)
         end
+
+        # Returns true when clone fails because the template uses local storage
+        # and cannot be cloned to a different node.
+        def local_storage_conflict?
+          response_body.match?(/uses local storage/i)
+        end
       end
     end
   end

data/lib/kitchen/driver/proxmox.rb

@@ -26,6 +26,7 @@ module Kitchen
       default_config :node_pool, nil
       default_config :template_id, nil
       default_config :template_name, nil
+      default_config :clone_type, 'auto'
 
       default_config :ssl_verify, true
       default_config :connect_timeout, 10
@@ -48,6 +49,7 @@ module Kitchen
         resolve_node(state)
         resolve_template(state)
         validate_config!
+        resolve_clone_strategy(state)
         clone_and_start(state)
       end
 
@@ -80,11 +82,13 @@ module Kitchen
         last_error = nil
         node = state[:node]
         template_id = state[:template_id] || config[:template_id]
+        template_node = state[:template_node] || node
+        full_clone = state[:full_clone]
 
         retries.times do |attempt|
           info("Creating Proxmox VM from template #{template_id}...")
 
-          vm_id, vm_name = allocate_and_clone(node, template_id)
+          vm_id, vm_name = allocate_and_clone(node, template_id, template_node, full_clone)
           state[:vm_id] = vm_id
           state[:vm_name] = vm_name
 
@@ -108,7 +112,7 @@ module Kitchen
         raise last_error
       end
 
-      def allocate_and_clone(node, template_id)
+      def allocate_and_clone(node, template_id, template_node, full_clone)
         retries = config[:clone_retries]
         last_error = nil
 
@@ -117,7 +121,7 @@ module Kitchen
           vm_name = generate_vm_name(instance.name)
 
           begin
-            clone_template(node, vm_id, vm_name, template_id)
+            clone_template(node, vm_id, vm_name, template_id, template_node, full_clone)
             return [vm_id, vm_name]
           rescue ApiError => e
             raise unless e.vmid_conflict?
@@ -145,13 +149,29 @@ module Kitchen
         "#{config[:vm_name_prefix]}#{suite_name}-#{Time.now.to_i}"
       end
 
-      def clone_template(node, vm_id, vm_name, template_id)
+      def clone_template(target_node, vm_id, vm_name, template_id, template_node, full_clone)
         upid = api_client.clone_vm(
-          node:, template_id:,
+          node: template_node, template_id:,
           new_id: vm_id, name: vm_name,
+          target: target_node, full: full_clone,
           pool: config[:pool], storage: config[:storage]
         )
-        api_client.wait_for_task(node:, upid:, timeout: config[:clone_timeout])
+        api_client.wait_for_task(node: template_node, upid:, timeout: config[:clone_timeout])
+      rescue ApiError => e
+        raise local_storage_error(template_id, template_node, target_node) if e.local_storage_conflict?
+
+        raise
+      end
+
+      def local_storage_error(template_id, template_node, target_node)
+        Kitchen::UserError.new(
+          "Cannot clone template #{template_id} from node '#{template_node}' to node '#{target_node}' " \
+          "because the template uses local storage.\n\n" \
+          "To fix this, either:\n" \
+          "  - Move the template disk to shared storage (e.g. NFS, Ceph, iSCSI)\n" \
+          "  - Pin the node to '#{template_node}' in .kitchen.yml: node: #{template_node}\n" \
+          "  - Create a copy of the template on '#{target_node}'"
+        )
       end
 
       def configure_hardware(node, vm_id)
@@ -215,6 +235,79 @@ module Kitchen
         nil
       end
 
+      def resolve_clone_strategy(state)
+        return if state[:full_clone] != nil # rubocop:disable Style/NonNilCheck
+
+        # Can't determine strategy without a template
+        template_id = state[:template_id] || config[:template_id]
+        return unless template_id
+
+        case config[:clone_type]
+        when 'full'
+          state[:full_clone] = true
+        when 'linked'
+          state[:full_clone] = false
+        else
+          detect_clone_strategy(state)
+        end
+      end
+
+      def detect_clone_strategy(state)
+        template_id = state[:template_id] || config[:template_id]
+        template_node = state[:template_node] || state[:node]
+        storage_info = template_storage_info(template_node, template_id)
+        shared = storage_info && storage_info['shared'] == 1
+        supports_linked = shared && linked_clone_capable_type?(storage_info['type'])
+
+        if supports_linked
+          state[:full_clone] = false
+        elsif shared
+          # Shared but doesn't support linked clones (e.g. plain LVM)
+          state[:full_clone] = true
+          warn("Storage '#{storage_info['storage']}' (type: #{storage_info['type']}) does not support linked clones. " \
+               'Using full clone. For faster clones, use lvmthin, ZFS, Ceph RBD, or file-based storage (NFS/dir).')
+        else
+          # Local storage — full clone and pin to template node
+          state[:full_clone] = true
+          pin_to_template_node(state, template_node)
+        end
+      end
+
+      LINKED_CLONE_STORAGE_TYPES = %w[lvmthin nfs dir cephfs rbd zfspool btrfs].freeze
+
+      def linked_clone_capable_type?(type)
+        LINKED_CLONE_STORAGE_TYPES.include?(type.to_s)
+      end
+
+      def template_storage_info(template_node, template_id)
+        vm_conf = api_client.vm_config(node: template_node, vm_id: template_id)
+        storage_name = extract_storage_name(vm_conf)
+        return nil unless storage_name
+
+        storages = api_client.list_storage(node: template_node)
+        storages.find { |s| s['storage'] == storage_name }
+      end
+
+      def extract_storage_name(vm_conf)
+        # Find the first real disk field (scsi0, virtio0, ide0, sata0, etc.)
+        disk_field = vm_conf.find do |k, v|
+          k.match?(/^(scsi|virtio|ide|sata)\d+$/) && !v.start_with?('none')
+        end
+        return nil unless disk_field
+
+        # Format: "StorageName:disk-name,option=val,..."
+        disk_field[1].split(':').first
+      end
+
+      def pin_to_template_node(state, template_node)
+        return if state[:node] == template_node
+
+        warn("Template uses local storage on node '#{template_node}' — " \
+             "pinning clone target to '#{template_node}'. " \
+             'Move template to shared storage for cross-node flexibility.')
+        state[:node] = template_node
+      end
+
       def validate_config!
         errors = []
         errors << 'Set template_id OR template_name, not both.' if config[:template_id] && config[:template_name]
@@ -249,7 +342,9 @@ module Kitchen
         node = state[:node]
         selected = matches.find { |t| t['node'] == node } || matches.first
         state[:template_id] = selected['vmid']
-        info("Resolved template '#{config[:template_name]}' to VMID #{state[:template_id]}")
+        state[:template_node] = selected['node']
+        info("Resolved template '#{config[:template_name]}' to VMID #{state[:template_id]} " \
+             "on node #{state[:template_node]}")
       end
 
       def resolve_node(state)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-proxmox
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Richard Nixon