pvectl 0.2.0

data/lib/pvectl/repositories/task.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Pvectl
+  module Repositories
+    # Repository for Proxmox tasks (async operations).
+    #
+    # Tasks are identified by UPID (Unique Process ID) which encodes
+    # the node name, allowing us to query the correct node.
+    #
+    # @example Finding a task
+    #   repo = Task.new(connection)
+    #   task = repo.find("UPID:pve1:000ABC:...")
+    #   task.completed? #=> true/false
+    #
+    class Task < Base
+      # Finds a task by UPID.
+      #
+      # @param upid [String] Unique Process ID
+      # @return [Models::Task] Task model
+      def find(upid)
+        node = extract_node_from_upid(upid)
+        response = connection.client["nodes/#{node}/tasks/#{CGI.escape(upid)}/status"].get
+        data = extract_data(response)
+        build_model(data.merge(upid: upid))
+      end
+
+      # Waits for a task to complete.
+      #
+      # @param upid [String] Task UPID
+      # @param timeout [Integer] Max wait time in seconds
+      # @param interval [Integer] Poll interval in seconds
+      # @return [Models::Task] Completed task
+      # @raise [Timeout::Error] if task doesn't complete in time
+      def wait(upid, timeout: 60, interval: 2)
+        deadline = Time.now + timeout
+        loop do
+          task = find(upid)
+          return task if task.completed?
+
+          if Time.now > deadline
+            raise Timeout::Error, "Task #{upid} timed out after #{timeout}s"
+          end
+
+          sleep interval
+        end
+      end
+
+      # Not implemented - tasks are looked up by UPID, not listed
+      def list
+        raise NotImplementedError, "Use find(upid) to get task status"
+      end
+
+      # Not implemented - use find instead
+      def get(id)
+        find(id)
+      end
+
+      protected
+
+      # Builds Task model from API response.
+      #
+      # @param data [Hash] API response
+      # @return [Models::Task] Task model
+      def build_model(data)
+        Models::Task.new(data)
+      end
+
+      private
+
+      # Extracts node name from UPID.
+      # UPID format: UPID:node:pid:pstart:starttime:type:id:user:
+      #
+      # @param upid [String] UPID string
+      # @return [String] Node name
+      def extract_node_from_upid(upid)
+        upid.split(":")[1]
+      end
+    end
+  end
+end

data/lib/pvectl/repositories/task_list.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Repositories
+    # Repository for listing tasks (async operations) on a node.
+    # Uses GET /nodes/{node}/tasks to fetch recent operations.
+    class TaskList < Base
+      # @param node [String] node name (required)
+      # @param vmid [Integer, nil] filter by VMID
+      # @param limit [Integer] max entries (default 50)
+      # @param since [Integer, nil] start time (epoch)
+      # @param until_time [Integer, nil] end time (epoch)
+      # @param type_filter [String, nil] filter by task type
+      # @param status_filter [String, nil] filter by status
+      # @return [Array<Models::TaskEntry>]
+      def list(node:, vmid: nil, limit: 50, since: nil, until_time: nil,
+               type_filter: nil, status_filter: nil)
+        params = { limit: limit, source: "all" }
+        params[:vmid] = vmid if vmid
+        params[:since] = since if since
+        params[:until] = until_time if until_time
+        params[:typefilter] = type_filter if type_filter
+        params[:statusfilter] = status_filter if status_filter
+
+        response = connection.client["nodes/#{node}/tasks"].get(params: params)
+        models_from(response, Models::TaskEntry)
+      end
+    end
+  end
+end

data/lib/pvectl/repositories/task_log.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Pvectl
+  module Repositories
+    # Repository for reading a specific task's log output.
+    # Uses GET /nodes/{node}/tasks/{upid}/log endpoint.
+    class TaskLog < Base
+      # @param upid [String] task UPID
+      # @param start [Integer] line offset (default 0)
+      # @param limit [Integer] max lines (default 512)
+      # @return [Array<Models::TaskLogLine>]
+      def list(upid:, start: 0, limit: 512)
+        node = extract_node_from_upid(upid)
+        escaped = CGI.escape(upid)
+
+        response = connection.client["nodes/#{node}/tasks/#{escaped}/log"].get(
+          params: { start: start, limit: limit }
+        )
+        models_from(response, Models::TaskLogLine)
+      end
+
+      private
+
+      def extract_node_from_upid(upid)
+        upid.split(":")[1]
+      end
+    end
+  end
+end

data/lib/pvectl/repositories/time_config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Repositories
+    # Repository for Proxmox node time and timezone settings.
+    #
+    # Wraps the `/nodes/{node}/time` API endpoint:
+    # - GET fetches `{time, localtime, timezone}`
+    # - PUT sets the timezone (the only writable field)
+    #
+    # @example Fetching time
+    #   repo = TimeConfig.new(connection)
+    #   config = repo.fetch("pve1")
+    #   config.timezone #=> "Europe/Warsaw"
+    #
+    # @example Setting timezone
+    #   repo.set_timezone("pve1", "UTC")
+    #
+    # @see Pvectl::Models::TimeConfig Model returned by #fetch
+    #
+    class TimeConfig < Base
+      # Fetches time and timezone settings for a node.
+      #
+      # @param node_name [String] cluster node name
+      # @return [Models::TimeConfig] time configuration for the node
+      def fetch(node_name)
+        response = connection.client["nodes/#{node_name}/time"].get
+        data = extract_data(response) || {}
+        build_model(data.merge(node_name: node_name))
+      end
+
+      # Sets the timezone on a node.
+      #
+      # @param node_name [String] cluster node name
+      # @param timezone [String] IANA timezone identifier (e.g., "Europe/Warsaw")
+      # @return [nil] Proxmox returns null on success
+      def set_timezone(node_name, timezone)
+        connection.client["nodes/#{node_name}/time"].put(timezone: timezone)
+        nil
+      end
+
+      protected
+
+      # Builds TimeConfig model from API data.
+      #
+      # @param data [Hash] API response merged with `:node_name`
+      # @return [Models::TimeConfig]
+      def build_model(data)
+        Models::TimeConfig.new(data)
+      end
+    end
+  end
+end