fog-hyperv 0.0.9 → 0.1.1

data/lib/fog/hyperv/compute/models/vhd.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  # A VM hard drive - VHD - file
+  class Vhd < Fog::Hyperv::Model
+    # rubocop:disable Layout/HashAlignment
+
+    # VHD types
+    # @note Defined by Microsoft.Vhd.PowerShell.VhdType
+    VHD_TYPE_ENUM_VALUES = {
+      Unknown:      0,
+      Fixed:        2,
+      Dynamic:      3,
+      Differencing: 4
+    }.freeze
+
+    # VHD formats
+    # @note Defined by Microsoft.Vhd.PowerShell.VhdFormat
+    VHD_FORMAT_ENUM_VALUES = {
+      Unknown: 0,
+      VHD:     2,
+      VHDX:    3,
+      VHDSet:  4
+    }.freeze
+    # rubocop:enable Layout/HashAlignment
+
+    # @!attribute [r] disk_identifier
+    #   @return [String] the guid of this VHD
+    identity :disk_identifier
+
+    # @!attribute [r] computer_name
+    #   @return [String] the name of the computer hosting this VHD
+    attribute :computer_name
+
+    # @!attribute [r] attached
+    #   @return [Boolean] is the VHD attached to something
+    attribute :attached, type: :boolean
+    # @!attribute [r] block_size
+    #   @return [Integer] the block size of the VHD in bytes
+    attribute :block_size, type: :integer
+    # @!attribute [r] disk_number
+    #   @return [Integer,nil] the disk number
+    attribute :disk_number
+    # @!attribute [r] file_size
+    #   @return [Integer,nil] the size of the VHD file in bytes
+    attribute :file_size
+    # @!attribute [r] logical_sector_size
+    #   @return [512, 4096] the logical sector size for the VHD in bytes
+    attribute :logical_sector_size, type: :integer
+    # @!attribute [r] minimum_size
+    #   @return [Integer,nil] the minimum possible size of the VHD in bytes, for shrinking purposes
+    attribute :minimum_size
+    # @!attribute [r] parent_path
+    #   @return [String,nil] the path to the parent VHD
+    attribute :parent_path
+    # @!attribute [r] path
+    #   @return [String,nil] the path to the VHD on disk
+    attribute :path
+    # @!attribute [r] pool_name
+    #   @return [String] the name of the pool storing this VHD
+    attribute :pool_name
+    # @!attribute physical_sector_size_bytes
+    #   @return [512, 4096] the physical sector size for the VHD in bytes
+    attribute :physical_sector_size, type: :integer
+    # @!attribute size
+    #   @return [Integer,nil] the size of the VHD in bytes
+    #   @note Defaults to 32GB if not specified
+    attribute :size, default: 32 * 1024 * 1024 * 1024
+    # @!attribute [r] vhd_format
+    #   @return [:Unknown, :VHD, :VHDX, :VHDSet] the format of the VHD
+    #   @see VHD_FORMAT_ENUM_VALUES
+    attribute :vhd_format, type: :hypervenum, default: :VHDX, values: VHD_FORMAT_ENUM_VALUES
+    # @!attribute [r] vhd_type
+    #   @return [:Unknown, :Fixed, :Dynamic, :Differencing] the type of the VHD
+    #   @see VHD_TYPE_ENUM_VALUES
+    attribute :vhd_type, type: :hypervenum, default: :Dynamic, values: VHD_TYPE_ENUM_VALUES
+
+    # @!attribute [r] basename
+    #   @return [String] the basename of the VHD file, without extension
+    attribute :basename
+
+    # @!attribute [r] unc_path
+    # @return [String] the UNC path to the VHD file in a cluster
+    def unc_path
+      requires :path
+
+      "\\\\#{computer_name || 'localhost'}\\#{path.tr ':', '$'}"
+    end
+
+    # Save the VHD to Hyper-V
+    def create
+      if basename
+        requires :vm
+
+        attributes[:path] ||= vm.build_vhd_path("#{basename}.#{vhd_ext}")
+      end
+
+      requires_one :path, :disk_number
+
+      attrs = {
+        source_disk: disk_number,
+        logical_sector_size_bytes: logical_sector_size,
+        physical_sector_size_bytes: physical_sector_size
+      }.compact
+      case vhd_type
+      when :Dynamic
+        attrs[:dynamic] = true
+        requires :size unless disk_number
+      when :Differencing
+        requires :parent_path
+        attrs[:differencing] = true
+        attrs[:parent_path] = parent_path
+        attrs.delete :source_disk
+        attrs.delete :logical_sector_size_bytes
+      when :Fixed
+        attrs[:fixed] = true
+        requires :size unless disk_number
+      else
+        raise "Invalid VHD type #{vhd_type.inspect}, must be :Dynamic, :Fixed, or :Differencing"
+      end
+
+      merge_attributes(
+        service.new_vhd(
+          computer_name: computer_name,
+
+          path: path,
+          block_size_bytes: block_size,
+          size_bytes: size,
+          **attrs,
+
+          _return_fields: self.class.attributes - %i[basename]
+        )
+      )
+    end
+
+    def update
+      requires :path
+
+      return self unless changed?(:size)
+
+      service.resize_vhd(
+        computer_name: old.computer_name,
+        path: old.path,
+
+        size_bytes: size
+      )
+      @old.size = size
+
+      self
+    end
+
+    # Reload the VHD attributes from Hyper-V
+    def reload
+      requires_one :path, :disk_number
+
+      data = service.get_vhd(
+        computer_name: computer_name,
+        path: path,
+        disk_number: disk_number,
+
+        _return_fields: self.class.attributes - %i[basename]
+      )
+      return unless data
+
+      merge_attributes(data)
+    end
+
+    # Remove the VHD from disk
+    def destroy
+      requires :path
+
+      service.remove_item(
+        computer_name: computer_name,
+        path: path
+      )
+      true
+    end
+
+    # Optimizes the VHD on disk
+    #
+    # @param mode [:full,:pretrimmed,:prezeroed,:quick,:retrim,nil] the optimization mode to use,
+    #   will default to :full/:quick depending on VHD type
+    def optimize(mode: nil)
+      requires :path
+
+      service.optimize_vhd(
+        computer_name: computer_name,
+        path: path,
+        mode: mode
+      )
+      true
+    end
+
+    private
+
+    def merge_attributes(new_attributes = {})
+      new_attributes[:parent_path] = nil if new_attributes[:parent_path] == ''
+      new_attributes[:basename] = File.basename(new_attributes[:path].split('\\').last, '.*') if new_attributes[:path]
+
+      super
+    end
+
+    def vhd_ext
+      ext = vhd_format&.downcase || 'vhdx'
+      ext = 'vhds' if ext.downcase == 'vhdset'
+      ext = 'vhdx' if ext.downcase == 'unknown'
+      ext
+    end
+  end
+end

data/lib/fog/hyperv/compute/models/vhds.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Vhds < Fog::Hyperv::Collection
+    model Fog::Hyperv::Compute::Vhd
+
+    get_method :get_vhd
+
+    attribute :computer_name
+
+    def get(identifier, **filters)
+      id = identifier if identifier =~ /\A#{Fog::Hyperv::GUID}\z/i
+      path = identifier unless id
+
+      raise ArgumentError, 'Must provide a path or GUID' if (id.nil? || id.empty?) && (path.nil? || path.empty?)
+
+      super(disk_identifier: id, path: path, **filters)
+    end
+
+    protected
+
+    def search_attributes
+      super.merge(
+        _return_fields: model.attributes - %i[basename]
+      )
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/add_vm_dvd_drive.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def add_vm_dvd_drive(vm_id:, computer_name: nil, **options)
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Add-VMDvdDrive', { passthru: true, **options }]
+        ],
+        target_computer: computer_name
+      )
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/add_vm_hard_disk_drive.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def add_vm_hard_disk_drive(vm_id:, computer_name: nil, **options)
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Add-VMHardDiskDrive', { passthru: true, **options }]
+        ],
+        target_computer: computer_name
+      )
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/add_vm_network_adapter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def add_vm_network_adapter(computer_name: nil, **options)
+      requires_one options, :vm_id, :management_os
+      options.delete :management_os
+
+      if options[:vm_id]
+        vm_id = options.delete :vm_id
+        run_cmdlist(
+          [
+            ['$VM = Get-VM', { id: vm_id }],
+            ['$VM | Add-VMNetworkAdapter', { _always_include: %i[is_legacy], passthru: true, **options }]
+          ],
+          target_computer: computer_name
+        )
+      else
+        options.delete :vm_id
+        run_cmd('Add-VMNetworkAdapter', _target_computer: computer_name, management_os: true, passthru: true, **options)
+      end
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/connect_vm_network_adapter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def connect_vm_network_adapter(id:, computer_name: nil, **options)
+      requires_one options, :vm_id, :management_os
+      requires_one options, :switch_name, :switch_id
+      options.delete :management_os
+
+      cmdlist = []
+      if options[:vm_id]
+        vm_id = options.delete :vm_id
+        cmdlist += [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$NIC = $VM | Get-VMNetworkAdapter', { _by_id: id }]
+        ]
+      else
+        options.delete :vm_id
+        cmdlist << ['$NIC = Get-VMNetworkAdapter', { _by_id: id, management_os: true }]
+      end
+      if options[:switch_id]
+        switch_id = options.delete :switch_id
+        options.delete :switch_name
+        cmdlist += [
+          ['$Switch = Get-VMSwitch', { id: switch_id }],
+          ['$NIC | Connect-VMNetworkAdapter -VMSwitch @Switch', options]
+        ]
+      else
+        switch_name = options.delete :switch_name
+        options.delete :switch_id
+        cmdlist << ['$NIC | Connect-VMNetworkAdapter', { switch_name: switch_name, **options }]
+      end
+
+      run_cmdlist(cmdlist, skip_json: true, target_computer: computer_name)
+    end
+  end
+
+  class Mock
+    def connect_vm_network_adapter(*args); end
+  end
+end

data/lib/fog/hyperv/compute/requests/disable_vm_tpm.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def disable_vm_tpm(vm_id:, computer_name: nil, **options)
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Disable-VMTPM', options]
+        ],
+        skip_json: true,
+        target_computer: computer_name
+      )
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/disconnect_vm_network_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def disconnect_vm_network_adapter(id:, computer_name: nil, **options)
+      requires_one options, :vm_id, :management_os
+      options.delete :management_os
+
+      cmdlist = []
+      if options[:vm_id]
+        vm_id = options.delete :vm_id
+        cmdlist += [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$NIC = $VM | Get-VMNetworkAdapter', { _by_id: id }]
+        ]
+      else
+        options.delete :vm_id
+        cmdlist << ['$NIC = Get-VMNetworkAdapter', { _by_id: id, management_os: true }]
+      end
+      cmdlist << ['$NIC | Disconnect-VMNetworkAdapter', options]
+
+      run_cmdlist(commands, skip_json: true, target_computer: computer_name)
+    end
+  end
+
+  class Mock
+    def disconnect_vm_network_adapter(*args); end
+  end
+end

data/lib/fog/hyperv/compute/requests/enable_vm_tpm.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def enable_vm_tpm(vm_id:, computer_name: nil, **options)
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Enable-VMTPM', options]
+        ],
+        skip_json: true,
+        target_computer: computer_name
+      )
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_cluster.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_cluster(**options)
+      by_id = options.delete(:id)
+
+      run_cmd 'Get-Cluster', _by_id: by_id, **options
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_cluster_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_cluster_node(id:, **options)
+      run_cmdlist(
+        [
+          ['$Cluster = Get-Cluster', { _by_id: id }],
+          ['$Cluster | Get-ClusterNode', options]
+        ]
+      )
+    end
+  end
+
+  class Mock
+    def get_cluster_node(**args)
+      data = handle_mock_response args
+      data = data.find { |n| n[:name] == args[:name] } if args[:name]
+      data
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vhd.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vhd(computer_name: nil, **options)
+      requires_one options, :path, :disk_number unless options[:vm_id]
+      run_cmd 'Get-VHD', _target_computer: computer_name, **options
+    end
+  end
+
+  class Mock
+    def get_vhd(**args)
+      requires_one args, :vm_id, :path, :disk_number
+      data = handle_mock_response args
+
+      if args[:vm_id]
+        data = case args[:vm_id].downcase
+               when '20ff7fe3-fd54-425c-aa97-fbf3c2e7a868'
+                 data[1..]
+               when '416e49fd-28dd-413c-9743-aa3e69e4807d'
+                 data[0]
+               end
+      elsif args[:path]
+        data = data.find { |d| d[:path].casecmp(args[:path]).zero? }
+      elsif args[:disk_number]
+        Fog::Mock.not_implemented
+      end
+
+      data
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm(**options)
+      run_cmd('Get-VM', **options)
+    end
+  end
+
+  class Mock
+    def get_vm(**args)
+      data = handle_mock_response(**args)
+      data = data.find { |v| v[:name].casecmp(args[:name]).zero? } if args[:name]
+      data = data.find { |v| v[:id].casecmp(args[:id]).zero? } if args[:id]
+      data
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_bios.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_bios(vm_id:, computer_name: nil, **options)
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Get-VMBios', options]
+        ],
+        target_computer: computer_name
+      )
+    end
+  end
+
+  class Mock
+    def get_vm_bios(**args)
+      handle_mock_response(args).find { |b| b[:vm_id].casecmp(args[:vm_id]).zero? }
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_com_port.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_com_port(vm_id:, computer_name: nil, **options)
+      by_id = options.delete :id
+
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Get-VMComPort', { _by_id: by_id, **options }]
+        ],
+        target_computer: computer_name
+      )
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_dvd_drive.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_dvd_drive(vm_id:, computer_name: nil, **options)
+      by_id = options.delete :id
+
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Get-VMDvdDrive', { _by_id: by_id, **options }]
+        ],
+        target_computer: computer_name
+      )
+    end
+  end
+
+  class Mock
+    def get_vm_dvd_drive(**options)
+      requires options, :vm_id
+
+      handle_mock_response(args).find { |b| b[:vm_id].casecmp(args[:vm_id]).zero? }
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_firmware.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_firmware(vm_id:, computer_name: nil, **options)
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Get-VMFirmware', options]
+        ],
+        target_computer: computer_name
+      )
+    end
+  end
+
+  class Mock
+    def get_vm_firmware(**args)
+      handle_mock_response(args).find { |b| b[:vm_name].casecmp(args[:vm_name]).zero? }
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_floppy_disk_drive.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_floppy_disk_drive(vm_id:, computer_name: nil, **options)
+      by_id = options.delete :id
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Get-VMFloppyDiskDrive', { _by_id: by_id, **options }]
+        ],
+        target_computer: computer_name
+      )
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_group.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_group(computer_name: nil, **options)
+      requires_version '10.0'
+
+      run_cmd('Get-VMGroup', _target_computer: computer_name, **options)
+    end
+  end
+
+  class Mock
+    def get_vm_group(**_options)
+      requires_version '10.0'
+
+      # TODO
+      Fog::Mock.not_implemented
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_hard_disk_drive.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_hard_disk_drive(vm_id:, computer_name: nil, **options)
+      by_id = options.delete :id
+      run_cmdlist(
+        [
+          ['$VM = Get-VM', { id: vm_id }],
+          ['$VM | Get-VMHardDiskDrive', { _by_id: by_id, **options }]
+        ],
+        target_computer: computer_name
+      )
+    end
+  end
+
+  class Mock
+    def get_vm_hard_disk_drive(**args)
+      requires args, :vm_id
+
+      handle_mock_response(args).find { |b| b[:vm_id].casecmp(args[:vm_id]).zero? }
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_host.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_host(computer_name: nil, **options)
+      run_cmd 'Get-VMHost', _target_computer: computer_name, **options
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_host_cluster.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    def get_vm_host_cluster(cluster_name:, computer_name: nil, **options)
+      requires_version '10.0'
+
+      run_cmd 'Get-VMHostCluster', _target_computer: computer_name, cluster_name: cluster_name, **options
+    end
+  end
+
+  class Mock
+    def get_vm_host_cluster(**options)
+      requires_version '10.0'
+      requires options, :cluster_name
+
+      # TODO
+      Fog::Mock.not_implemented
+    end
+  end
+end

data/lib/fog/hyperv/compute/requests/get_vm_host_sbt.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Real
+    # Retrieve SecureBoot Templates for a VM Host
+    def get_vm_host_sbt(computer_name:, **options)
+      run_cmd '(Get-VMHost @Args).SecureBootTemplates', _target_computer: computer_name, **options
+    end
+  end
+end