pvectl 0.2.0

data/lib/pvectl/repositories/capabilities.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Repositories
+    # Repository for Proxmox node capabilities.
+    #
+    # Aggregates feature information from the two most useful capability
+    # endpoints — QEMU CPU models and QEMU machine types — into a flat
+    # collection of Capability models. The cpu-flags and migration
+    # capability endpoints are intentionally out of scope for the initial
+    # implementation (YAGNI); they can be added when there is a concrete
+    # consumer need.
+    #
+    # @example List capabilities for a node
+    #   repo = Capabilities.new(connection)
+    #   caps = repo.list(node: "pve1")
+    #   caps.each { |c| puts "#{c.kind}: #{c.name}" }
+    #
+    # @see Pvectl::Models::Capability
+    #
+    class Capabilities < Base
+      # CPU capability endpoint path (without leading slash).
+      CPU_ENDPOINT = "capabilities/qemu/cpu"
+
+      # Machine type capability endpoint path (without leading slash).
+      MACHINES_ENDPOINT = "capabilities/qemu/machines"
+
+      # Lists capabilities for a node.
+      #
+      # Combines `GET /nodes/{node}/capabilities/qemu/cpu` and
+      # `GET /nodes/{node}/capabilities/qemu/machines`. Each entry becomes
+      # a Capability instance — CPU models first, then machine types.
+      #
+      # @param node [String] cluster node name (required)
+      # @return [Array<Models::Capability>]
+      # @raise [ArgumentError] when `node` is nil/empty
+      # @raise [StandardError] propagated from the API on auth/connection failure
+      def list(node:)
+        raise ArgumentError, "node is required" if node.nil? || node.to_s.empty?
+
+        cpus(node) + machines(node)
+      end
+
+      private
+
+      # Fetches CPU model capabilities.
+      #
+      # @param node [String]
+      # @return [Array<Models::Capability>]
+      def cpus(node)
+        response = connection.client["nodes/#{node}/#{CPU_ENDPOINT}"].get
+        unwrap(response).map { |data| build_cpu(data, node) }
+      end
+
+      # Fetches machine type capabilities.
+      #
+      # @param node [String]
+      # @return [Array<Models::Capability>]
+      def machines(node)
+        response = connection.client["nodes/#{node}/#{MACHINES_ENDPOINT}"].get
+        unwrap(response).map { |data| build_machine(data, node) }
+      end
+
+      # Builds a CPU capability model.
+      #
+      # @param data [Hash] one entry from the CPU endpoint
+      # @param node [String]
+      # @return [Models::Capability]
+      def build_cpu(data, node)
+        Models::Capability.new(
+          node_name: node,
+          kind: :cpu,
+          name: data[:name],
+          vendor: data[:vendor],
+          custom: data[:custom] || false
+        )
+      end
+
+      # Builds a machine type capability model.
+      #
+      # @param data [Hash] one entry from the machines endpoint
+      # @param node [String]
+      # @return [Models::Capability]
+      def build_machine(data, node)
+        Models::Capability.new(
+          node_name: node,
+          kind: :machine,
+          name: data[:id],
+          machine_type: data[:type],
+          version: data[:version],
+          changes: data[:changes]
+        )
+      end
+    end
+  end
+end

data/lib/pvectl/repositories/container.rb

@@ -0,0 +1,503 @@
+# frozen_string_literal: true
+
+require_relative "task_list"
+
+module Pvectl
+  module Repositories
+    # Repository for LXC containers.
+    #
+    # Uses the `/cluster/resources` API endpoint to list containers across the cluster.
+    # Filters to only include LXC containers (excludes QEMU VMs).
+    #
+    # @example Listing all containers
+    #   repo = Container.new(connection)
+    #   containers = repo.list
+    #   containers.each { |ct| puts "#{ct.vmid}: #{ct.name}" }
+    #
+    # @example Listing containers on a specific node
+    #   containers = repo.list(node: "pve-node1")
+    #
+    # @example Getting a single container
+    #   ct = repo.get(100)
+    #   puts ct.name if ct
+    #
+    # @see Pvectl::Models::Container Container model
+    # @see Pvectl::Connection API connection
+    #
+    class Container < Base
+      # Lists all containers in the cluster.
+      #
+      # Uses `/cluster/resources?type=lxc` endpoint for efficient cluster-wide
+      # listing. Filters to only include LXC containers (type == "lxc").
+      #
+      # @param node [String, nil] filter by node name
+      # @return [Array<Models::Container>] collection of Container models
+      def list(node: nil)
+        response = connection.client["cluster/resources"].get(params: { type: "vm" })
+        containers = unwrap(response).select { |r| r[:type] == "lxc" }
+        containers = containers.select { |r| r[:node] == node } if node
+        containers.map { |data| build_model(data) }
+      end
+
+      # Gets a single container by CTID.
+      #
+      # @param ctid [Integer, String] container identifier
+      # @return [Models::Container, nil] Container model or nil if not found
+      def get(ctid)
+        list.find { |ct| ct.vmid == ctid.to_i }
+      end
+
+      # Describes a container with comprehensive details from multiple API endpoints.
+      #
+      # @param ctid [Integer, String] container identifier
+      # @return [Models::Container, nil] Container model with full details, or nil if not found
+      def describe(ctid)
+        ctid = ctid.to_i
+
+        basic_data = find_container_basic_data(ctid)
+        return nil if basic_data.nil?
+
+        node = basic_data[:node]
+
+        config = fetch_config(node, ctid)
+        status = fetch_status(node, ctid)
+        snapshots = fetch_snapshots(node, ctid)
+        tasks = fetch_tasks(node, ctid)
+        firewall = fetch_firewall(node, ctid)
+
+        build_describe_model(basic_data, config, status, snapshots, tasks, firewall)
+      end
+
+      # Deletes a container from the cluster.
+      #
+      # @param ctid [Integer, String] Container identifier
+      # @param node [String] Node name
+      # @param destroy_disks [Boolean] destroy unreferenced disks (default: true)
+      # @param purge [Boolean] remove from HA, replication, backups (default: false)
+      # @param force [Boolean] force removal (default: false)
+      # @return [String] Task UPID
+      def delete(ctid, node, destroy_disks: true, purge: false, force: false)
+        params = {}
+        params["destroy-unreferenced-disks"] = 1 if destroy_disks
+        params[:purge] = 1 if purge
+        params[:force] = 1 if force
+
+        connection.client["nodes/#{node}/lxc/#{ctid}"].delete(params)
+      end
+
+      # Starts a container.
+      #
+      # @param ctid [Integer, String] Container identifier
+      # @param node [String] Node name
+      # @return [String] Task UPID
+      def start(ctid, node)
+        connection.client["nodes/#{node}/lxc/#{ctid}/status/start"].post
+      end
+
+      # Stops a container (hard stop).
+      #
+      # @param ctid [Integer, String] Container identifier
+      # @param node [String] Node name
+      # @return [String] Task UPID
+      def stop(ctid, node)
+        connection.client["nodes/#{node}/lxc/#{ctid}/status/stop"].post
+      end
+
+      # Shuts down a container gracefully.
+      #
+      # @param ctid [Integer, String] Container identifier
+      # @param node [String] Node name
+      # @return [String] Task UPID
+      def shutdown(ctid, node)
+        connection.client["nodes/#{node}/lxc/#{ctid}/status/shutdown"].post
+      end
+
+      # Clones a container to create a new container.
+      #
+      # Posts to `/nodes/{node}/lxc/{ctid}/clone` with the specified parameters.
+      # Note: LXC API uses `hostname` parameter (not `name` like QEMU).
+      #
+      # @param ctid [Integer, String] source container identifier
+      # @param node [String] source node name
+      # @param new_ctid [Integer] CTID for the new cloned container
+      # @param options [Hash] optional clone parameters
+      # @option options [String] :hostname hostname for the new container
+      # @option options [String] :target target node for the clone
+      # @option options [String] :storage target storage for the clone
+      # @option options [Boolean] :full full clone (true) or linked clone (false)
+      # @option options [String] :description description for the new container
+      # @option options [String] :pool resource pool for the new container
+      # @return [String] Task UPID
+      def clone(ctid, node, new_ctid, options = {})
+        params = { newid: new_ctid }
+        params[:hostname] = options[:hostname] if options[:hostname]
+        params[:target] = options[:target] if options[:target]
+        params[:storage] = options[:storage] if options[:storage]
+        params[:full] = options[:full] ? 1 : 0 if options.key?(:full)
+        params[:description] = options[:description] if options[:description]
+        params[:pool] = options[:pool] if options[:pool]
+
+        connection.client["nodes/#{node}/lxc/#{ctid}/clone"].post(params)
+      end
+
+      # Converts a container to a template.
+      #
+      # This is an irreversible operation. The container will become read-only
+      # and can only be used as a source for cloning.
+      #
+      # @param ctid [Integer, String] Container identifier
+      # @param node [String] Node name
+      # @return [void]
+      def convert_to_template(ctid, node)
+        connection.client["nodes/#{node}/lxc/#{ctid}/template"].post({})
+      end
+
+      # Migrates a container to another node.
+      #
+      # @param ctid [Integer, String] container identifier
+      # @param node [String] current node name
+      # @param params [Hash] migration parameters (:target, :online, :restart, :targetstorage)
+      # @return [String] Task UPID
+      # @raise [ArgumentError] if node name or ctid format is invalid
+      def migrate(ctid, node, params = {})
+        unless node.match?(/\A[a-z][a-z0-9-]*\z/)
+          raise ArgumentError, "Invalid node name: #{node}"
+        end
+        unless ctid.is_a?(Integer) && ctid.positive?
+          raise ArgumentError, "Invalid CTID: #{ctid}"
+        end
+
+        connection.client["nodes/#{node}/lxc/#{ctid}/migrate"].post(params)
+      end
+
+      # Moves a container volume to a different storage on the same node.
+      #
+      # POSTs to +/nodes/{node}/lxc/{ctid}/move_volume+ with the volume identifier
+      # and target storage. The operation is asynchronous — the returned UPID
+      # can be polled via Repositories::Task to track completion.
+      #
+      # @param ctid [Integer, String] container identifier
+      # @param node [String] node name where the container currently resides
+      # @param volume [String] volume identifier (e.g., "rootfs", "mp0")
+      # @param target_storage [String] destination storage ID
+      # @param delete [Boolean] delete the source volume after copy (default: false)
+      # @param bwlimit [Integer, nil] I/O bandwidth limit in KiB/s
+      # @return [String] Task UPID
+      #
+      # @example Move rootfs to a different storage
+      #   repo.move_volume(200, "pve1", "rootfs", "local-lvm")
+      #   #=> "UPID:pve1:..."
+      #
+      # @example Move and delete source volume
+      #   repo.move_volume(200, "pve1", "mp0", "ceph-pool", delete: true)
+      def move_volume(ctid, node, volume, target_storage, delete: false, bwlimit: nil)
+        params = { volume: volume, storage: target_storage }
+        params[:delete] = 1 if delete
+        params[:bwlimit] = bwlimit if bwlimit
+
+        connection.client["nodes/#{node}/lxc/#{ctid}/move_volume"].post(params)
+      end
+
+      # Checks whether a feature (clone, snapshot, copy) is available for a container.
+      #
+      # Calls +GET /nodes/{node}/lxc/{vmid}/feature+ with the feature and
+      # optional snapshot name. The Proxmox LXC API returns +hasFeature+ (0/1).
+      # Unlike the QEMU variant, the LXC endpoint does not return a +nodes+ array;
+      # this method always returns +nodes: []+ for shape compatibility.
+      #
+      # @param ctid [Integer, String] container identifier
+      # @param node [String] node currently hosting the container
+      # @param feature [String] feature name (one of: clone, snapshot, copy)
+      # @param snapname [String, nil] snapshot name (required for some checks)
+      # @return [Hash] result with :available (Boolean) and :nodes (Array<String>)
+      #
+      # @example Check whether container 200 can be cloned
+      #   repo.feature_available?(200, "pve1", "clone")
+      #   #=> { available: true, nodes: [] }
+      def feature_available?(ctid, node, feature, snapname: nil)
+        params = { feature: feature }
+        params[:snapname] = snapname unless snapname.nil?
+
+        response = connection.client["nodes/#{node}/lxc/#{ctid}/feature"].get(params: params)
+        data = extract_data(response)
+
+        {
+          available: data[:hasFeature].to_i == 1,
+          nodes: Array(data[:nodes])
+        }
+      end
+
+      # Returns the next available CTID from the Proxmox cluster.
+      #
+      # Uses the +/cluster/nextid+ API endpoint which performs server-side allocation.
+      # This is more reliable than client-side scanning because it detects stale
+      # config files that don't appear in +/cluster/resources+.
+      #
+      # @return [Integer] next available CTID
+      def next_available_ctid
+        connection.client["cluster/nextid"].get.to_i
+      end
+
+      # Restarts a container (reboot).
+      #
+      # @param ctid [Integer, String] Container identifier
+      # @param node [String] Node name
+      # @return [String] Task UPID
+      def restart(ctid, node)
+        connection.client["nodes/#{node}/lxc/#{ctid}/status/reboot"].post
+      end
+
+      # Opens a terminal proxy session for a container.
+      #
+      # @param ctid [Integer, String] Container identifier
+      # @param node [String] Node name
+      # @return [Hash] termproxy data with :port, :ticket, :user keys
+      def termproxy(ctid, node)
+        response = connection.client["nodes/#{node}/lxc/#{ctid}/termproxy"].post({})
+        extract_data(response)
+      end
+
+      # Creates a new LXC container on the specified node.
+      #
+      # Posts to `/nodes/{node}/lxc` with the container configuration parameters.
+      # The ctid is merged into params automatically.
+      #
+      # @param node [String] target node name
+      # @param ctid [Integer] container identifier
+      # @param params [Hash] container configuration parameters (hostname, ostemplate, etc.)
+      # @return [String] Task UPID
+      #
+      # @example Create a basic container
+      #   repo.create("pve1", 200, { hostname: "web-ct", ostemplate: "local:vztmpl/debian-12.tar.zst" })
+      #   #=> "UPID:pve1:..."
+      def create(node, ctid, params = {})
+        api_params = params.merge(vmid: ctid)
+        connection.client["nodes/#{node}/lxc"].post(api_params)
+      end
+
+      # Updates an existing LXC container configuration.
+      #
+      # PUTs to +/nodes/{node}/lxc/{ctid}/config+ with configuration parameters.
+      # This is a synchronous operation — changes are applied immediately.
+      #
+      # @param ctid [Integer, String] container identifier
+      # @param node [String] node name
+      # @param params [Hash] container configuration parameters to update
+      # @return [nil]
+      def update(ctid, node, params = {})
+        connection.client["nodes/#{node}/lxc/#{ctid}/config"].put(params)
+      end
+
+      # Resizes a container disk.
+      #
+      # PUTs to +/nodes/{node}/lxc/{ctid}/resize+ with disk identifier
+      # and new size. This is a synchronous, irreversible operation —
+      # Proxmox does not support shrinking disks.
+      #
+      # @param ctid [Integer, String] container identifier
+      # @param node [String] node name
+      # @param disk [String] disk identifier (e.g., "rootfs", "mp0")
+      # @param size [String] new size, absolute ("50G") or relative ("+10G")
+      # @return [nil]
+      def resize(ctid, node, disk:, size:)
+        connection.client["nodes/#{node}/lxc/#{ctid}/resize"].put({ disk: disk, size: size })
+      end
+
+      # Fetches container configuration.
+      #
+      # @param node [String] node name
+      # @param ctid [Integer] container identifier
+      # @return [Hash] config data
+      def fetch_config(node, ctid)
+        resp = connection.client["nodes/#{node}/lxc/#{ctid}/config"].get
+        extract_data(resp)
+      rescue StandardError
+        {}
+      end
+
+      protected
+
+      # Builds Container model from API response data.
+      #
+      # @param data [Hash] API response hash
+      # @return [Models::Container] Container model instance
+      def build_model(data)
+        Models::Container.new(
+          vmid: data[:vmid],
+          name: data[:name],
+          status: data[:status],
+          node: data[:node],
+          cpu: data[:cpu],
+          maxcpu: data[:maxcpu],
+          mem: data[:mem],
+          maxmem: data[:maxmem],
+          swap: data[:swap],
+          maxswap: data[:maxswap],
+          disk: data[:disk],
+          maxdisk: data[:maxdisk],
+          uptime: data[:uptime],
+          template: data[:template],
+          tags: data[:tags],
+          pool: data[:pool],
+          lock: data[:lock],
+          netin: data[:netin],
+          netout: data[:netout],
+          type: data[:type]
+        )
+      end
+
+      private
+
+      # Finds container basic data from cluster resources.
+      #
+      # @param ctid [Integer] container identifier
+      # @return [Hash, nil] container data or nil if not found
+      def find_container_basic_data(ctid)
+        response = connection.client["cluster/resources"].get(params: { type: "vm" })
+        unwrap(response).find { |r| r[:type] == "lxc" && r[:vmid] == ctid }
+      end
+
+      # Fetches container runtime status.
+      #
+      # @param node [String] node name
+      # @param ctid [Integer] container identifier
+      # @return [Hash] status data
+      def fetch_status(node, ctid)
+        resp = connection.client["nodes/#{node}/lxc/#{ctid}/status/current"].get
+        extract_data(resp)
+      rescue StandardError
+        {}
+      end
+
+      # Fetches container snapshots.
+      #
+      # @param node [String] node name
+      # @param ctid [Integer] container identifier
+      # @return [Array<Hash>] snapshots list (excluding "current")
+      def fetch_snapshots(node, ctid)
+        resp = connection.client["nodes/#{node}/lxc/#{ctid}/snapshot"].get
+        unwrap(resp).reject { |s| s[:name] == "current" }
+      rescue StandardError
+        []
+      end
+
+      # Fetches firewall configuration (options, rules, aliases, IP sets).
+      #
+      # @param node [String] node name
+      # @param ctid [Integer] container identifier
+      # @return [Hash] firewall data with :options, :rules, :aliases, :ipset keys
+      def fetch_firewall(node, ctid)
+        base = "nodes/#{node}/lxc/#{ctid}/firewall"
+        options = (extract_data(connection.client["#{base}/options"].get) rescue {})
+        rules = (unwrap(connection.client["#{base}/rules"].get) rescue [])
+        aliases_data = (unwrap(connection.client["#{base}/aliases"].get) rescue [])
+        ipset = (unwrap(connection.client["#{base}/ipset"].get) rescue [])
+        { options: options, rules: rules, aliases: aliases_data, ipset: ipset }
+      rescue StandardError
+        {}
+      end
+
+      # Fetches recent task history for the container.
+      #
+      # @param node [String] node name
+      # @param ctid [Integer] container identifier
+      # @param limit [Integer] max entries (default 10)
+      # @return [Array<Models::TaskEntry>] recent tasks
+      def fetch_tasks(node, ctid, limit: 10)
+        task_list_repo = TaskList.new(connection)
+        task_list_repo.list(node: node, vmid: ctid, limit: limit)
+      rescue StandardError
+        []
+      end
+
+      # Extracts network interfaces from config.
+      # Network interfaces are stored as net0, net1, etc. keys.
+      #
+      # @param config [Hash] container config
+      # @return [Array<Hash>] parsed network interfaces
+      def extract_network_interfaces(config)
+        interfaces = []
+        config.each do |key, value|
+          next unless key.to_s.match?(/^net\d+$/)
+
+          parsed = parse_network_interface(key.to_s, value)
+          interfaces << parsed if parsed
+        end
+        interfaces
+      end
+
+      # Parses a single network interface string.
+      #
+      # @param key [String] interface key (e.g., "net0")
+      # @param value [String] interface configuration string
+      # @return [Hash] parsed interface data
+      def parse_network_interface(key, value)
+        return nil unless value.is_a?(String)
+
+        interface = { id: key }
+
+        # Parse key=value pairs from the interface string
+        value.split(",").each do |part|
+          k, v = part.split("=", 2)
+          interface[k.to_sym] = v if k && v
+        end
+
+        interface
+      end
+
+      # Builds Container model with describe-specific attributes.
+      #
+      # @param basic_data [Hash] basic container data from cluster/resources
+      # @param config [Hash] container config from /nodes/{node}/lxc/{ctid}/config
+      # @param status [Hash] container status from /nodes/{node}/lxc/{ctid}/status/current
+      # @param snapshots [Array<Hash>] container snapshots
+      # @return [Models::Container] Container model
+      def build_describe_model(basic_data, config, status, snapshots = [], tasks = [], firewall = {})
+        network_interfaces = extract_network_interfaces(config)
+
+        Models::Container.new(
+          # Basic attributes from cluster/resources
+          vmid: basic_data[:vmid],
+          name: basic_data[:name],
+          status: basic_data[:status],
+          node: basic_data[:node],
+          type: basic_data[:type],
+          cpu: basic_data[:cpu],
+          maxcpu: basic_data[:maxcpu],
+          mem: basic_data[:mem],
+          maxmem: basic_data[:maxmem],
+          swap: basic_data[:swap],
+          maxswap: basic_data[:maxswap],
+          disk: basic_data[:disk],
+          maxdisk: basic_data[:maxdisk],
+          uptime: basic_data[:uptime],
+          template: basic_data[:template],
+          tags: basic_data[:tags],
+          pool: basic_data[:pool],
+          lock: basic_data[:lock],
+          netin: basic_data[:netin],
+          netout: basic_data[:netout],
+
+          # Config attributes (kept for backward compat)
+          ostype: config[:ostype],
+          arch: config[:arch],
+          unprivileged: config[:unprivileged],
+          features: config[:features],
+          rootfs: config[:rootfs],
+          description: config[:description],
+          hostname: config[:hostname],
+
+          # Status attributes
+          pid: status[:pid],
+          ha: status[:ha],
+
+          # Parsed network interfaces
+          network_interfaces: network_interfaces,
+
+          # Raw API data for comprehensive describe
+          describe_data: { config: config, status: status, snapshots: snapshots, tasks: tasks, firewall: firewall }
+        )
+      end
+    end
+  end
+end

data/lib/pvectl/repositories/disk.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Repositories
+    # Repository for physical disks on Proxmox nodes.
+    #
+    # Uses the `/nodes/{node}/disks/list` API endpoint to fetch
+    # physical disk information per node.
+    #
+    # @example Listing all disks across the cluster
+    #   repo = Disk.new(connection)
+    #   disks = repo.list
+    #   disks.each { |d| puts "#{d.node}: #{d.devpath} (#{d.type})" }
+    #
+    # @example Listing disks on a specific node
+    #   disks = repo.list(node: "pve1")
+    #
+    # @see Pvectl::Models::PhysicalDisk PhysicalDisk model
+    # @see Pvectl::Connection API connection
+    #
+    class Disk < Base
+      # Lists physical disks, optionally filtered by node.
+      #
+      # When node is nil, iterates over all online nodes in the cluster.
+      # When node is specified, queries only that node.
+      #
+      # @param node [String, nil] filter by node name
+      # @return [Array<Models::PhysicalDisk>] collection of PhysicalDisk models
+      def list(node: nil)
+        if node
+          disks_for_node(node)
+        else
+          online_nodes.flat_map { |node_name| disks_for_node(node_name) }
+        end
+      end
+
+      # Fetches SMART data for a specific disk on a node.
+      #
+      # @param node_name [String] node name
+      # @param disk_path [String] device path (e.g., "/dev/nvme0n1")
+      # @return [Hash{Symbol => untyped}] SMART data with keys: :health, :type, :attributes, :text
+      def smart(node_name, disk_path)
+        response = connection.client["nodes/#{node_name}/disks/smart"].get(params: { disk: disk_path })
+        extract_data(response)
+      rescue StandardError
+        {}
+      end
+
+      protected
+
+      # Builds PhysicalDisk model from API response data.
+      #
+      # @param data [Hash] API response hash
+      # @return [Models::PhysicalDisk] PhysicalDisk model instance
+      def build_model(data)
+        Models::PhysicalDisk.new(data)
+      end
+
+      private
+
+      # Fetches disks for a single node.
+      #
+      # @param node_name [String] node name
+      # @return [Array<Models::PhysicalDisk>] disks on that node
+      def disks_for_node(node_name)
+        response = connection.client["nodes/#{node_name}/disks/list"].get
+        disks_data = unwrap(response)
+        disks_data.map { |data| build_model(data.merge(node: node_name)) }
+      rescue StandardError
+        []
+      end
+
+      # Fetches list of online node names.
+      #
+      # @return [Array<String>] online node names
+      def online_nodes
+        response = connection.client["nodes"].get
+        nodes_data = unwrap(response)
+        nodes_data
+          .select { |n| n[:status] == "online" }
+          .map { |n| n[:node] || n[:name] }
+      rescue StandardError
+        []
+      end
+    end
+  end
+end