pvectl 0.2.0

data/lib/pvectl/services/move_disk.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates moving a VM disk or container volume to a different storage
+    # on the same node.
+    #
+    # Operates on one resource at a time (single VM or single container).
+    # Async mode (default): returns UPID immediately, no blocking.
+    # Sync mode (--wait): polls Task until completion or timeout.
+    #
+    # @example Move VM disk async (default)
+    #   service = MoveDisk.new(
+    #     vm_repository: vm_repo,
+    #     container_repository: ct_repo,
+    #     task_repository: task_repo
+    #   )
+    #   result = service.execute(:vm, vm, disk: "scsi0", target_storage: "storage2")
+    #
+    # @example Move container volume with --wait
+    #   service = MoveDisk.new(..., options: { wait: true })
+    #   result = service.execute(:container, ct, disk: "rootfs", target_storage: "storage2")
+    #
+    class MoveDisk
+      DEFAULT_TIMEOUT = 600
+
+      # Creates a new MoveDisk service.
+      #
+      # @param vm_repository [Repositories::Vm] VM repository
+      # @param container_repository [Repositories::Container] Container repository
+      # @param task_repository [Repositories::Task] Task repository
+      # @param options [Hash] Options (format, delete_source, bandwidth, timeout, wait)
+      def initialize(vm_repository:, container_repository:, task_repository:, options: {})
+        @vm_repository = vm_repository
+        @container_repository = container_repository
+        @task_repository = task_repository
+        @options = options
+      end
+
+      # Executes the move operation on a single resource.
+      #
+      # @param resource_type [Symbol] :vm or :container
+      # @param resource [Models::Vm, Models::Container] resource to operate on
+      # @param disk [String] disk/volume identifier (e.g., "scsi0", "rootfs")
+      # @param target_storage [String] destination storage ID
+      # @return [Models::VmOperationResult, Models::ContainerOperationResult]
+      def execute(resource_type, resource, disk:, target_storage:)
+        @resource_type = resource_type
+        move_single(resource, disk, target_storage)
+      end
+
+      private
+
+      # Performs the move on a single resource and builds the result.
+      #
+      # @param resource [Models::Vm, Models::Container] resource
+      # @param disk [String] disk/volume identifier
+      # @param target_storage [String] destination storage ID
+      # @return [Models::VmOperationResult, Models::ContainerOperationResult]
+      def move_single(resource, disk, target_storage)
+        upid = invoke_repository(resource, disk, target_storage)
+
+        if @options[:wait]
+          task = @task_repository.wait(upid, timeout: timeout)
+          build_result(resource,
+                       operation: :move_disk,
+                       task: task,
+                       success: task.successful?)
+        else
+          build_result(resource,
+                       operation: :move_disk,
+                       task_upid: upid,
+                       success: :pending)
+        end
+      rescue StandardError => e
+        build_result(resource,
+                     operation: :move_disk,
+                     success: false,
+                     error: e.message)
+      end
+
+      # Calls the appropriate repository method based on resource type.
+      #
+      # @param resource [Models::Vm, Models::Container] resource
+      # @param disk [String] disk/volume identifier
+      # @param target_storage [String] destination storage ID
+      # @return [String] Task UPID
+      def invoke_repository(resource, disk, target_storage)
+        if @resource_type == :vm
+          @vm_repository.move_disk(
+            resource.vmid,
+            resource.node,
+            disk,
+            target_storage,
+            format: @options[:format],
+            delete: @options[:delete_source] ? true : false,
+            bwlimit: @options[:bandwidth]
+          )
+        else
+          @container_repository.move_volume(
+            resource.vmid,
+            resource.node,
+            disk,
+            target_storage,
+            delete: @options[:delete_source] ? true : false,
+            bwlimit: @options[:bandwidth]
+          )
+        end
+      end
+
+      # Builds typed OperationResult for the current resource type.
+      #
+      # @param resource [Models::Vm, Models::Container] resource
+      # @param attrs [Hash] result attributes
+      # @return [Models::VmOperationResult, Models::ContainerOperationResult]
+      def build_result(resource, **attrs)
+        if @resource_type == :vm
+          Models::VmOperationResult.new(vm: resource, **attrs)
+        else
+          Models::ContainerOperationResult.new(container: resource, **attrs)
+        end
+      end
+
+      # Returns configured timeout.
+      #
+      # @return [Integer] timeout in seconds
+      def timeout
+        @options[:timeout] || DEFAULT_TIMEOUT
+      end
+    end
+  end
+end

data/lib/pvectl/services/pull_config.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates pulling resource configurations from the cluster
+    # and converting them to YAML manifests.
+    #
+    # @example Pull a single VM
+    #   service = PullConfig.new(vm_repository: vm_repo, container_repository: ct_repo)
+    #   result = service.execute(type: :vm, ids: [100])
+    #   result[:manifests].each { |m| puts m[:yaml] }
+    class PullConfig
+      # @param vm_repository [Repositories::Vm] VM repository
+      # @param container_repository [Repositories::Container] container repository
+      def initialize(vm_repository:, container_repository:)
+        @vm_repository = vm_repository
+        @container_repository = container_repository
+      end
+
+      # Executes the pull operation.
+      #
+      # @param type [Symbol] :vm or :container
+      # @param ids [Array<Integer>] specific resource IDs (optional)
+      # @param all [Boolean] pull all resources
+      # @param node [String, nil] limit to specific node
+      # @param selector [Object, nil] selector for filtering
+      # @return [Hash] { manifests: Array<Hash>, errors: Array<String> }
+      def execute(type:, ids: [], all: false, node: nil, selector: nil)
+        repo = repository_for(type)
+        manifests = []
+        errors = []
+
+        if all || selector
+          resources = repo.list(node: node)
+          resources = selector.apply(resources) if selector
+          resources.reject!(&:template?)
+        else
+          resources = ids.filter_map do |id|
+            resource = repo.get(id.to_i)
+            unless resource
+              errors << "#{type_label(type)} #{id} not found"
+              nil
+            else
+              resource
+            end
+          end
+        end
+
+        resources.each do |resource|
+          result = pull_single(repo, resource, type)
+          if result[:error]
+            errors << result[:error]
+          else
+            manifests << result
+          end
+        end
+
+        { manifests: manifests, errors: errors }
+      end
+
+      private
+
+      def repository_for(type)
+        type == :container ? @container_repository : @vm_repository
+      end
+
+      def pull_single(repo, resource, type)
+        config = repo.fetch_config(resource.node, resource.vmid)
+        nested = ConfigSerializer.to_nested(config, type: type)
+        metadata = build_metadata(resource, type)
+        yaml = ManifestSerializer.to_yaml(nested, type: type, metadata: metadata)
+
+        { metadata: metadata, yaml: yaml, vmid: resource.vmid }
+      rescue StandardError => e
+        { error: "Error pulling #{type_label(type)} #{resource.vmid}: #{e.message}" }
+      end
+
+      def build_metadata(resource, type)
+        name = type == :container ? resource.hostname : resource.name
+        {
+          vmid: resource.vmid,
+          name: name,
+          node: resource.node,
+          status: resource.status,
+          tags: resource.tags
+        }.compact
+      end
+
+      def type_label(type)
+        type == :container ? "Container" : "VM"
+      end
+    end
+  end
+end