fog-hyperv 0.0.9 → 0.1.1

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class FloppyDrive < Fog::Hyperv::Model
+    # @!attribute [r] id
+    #   @return [String] the combined GUID of this floppy drive
+    identity :id, type: :string
+
+    # @!attribute [r] vm_id
+    #   @return [String] the GUID of the VM this BIOS configuration is attached to
+    attribute :vm_id, type: :string
+    # @!attribute [r] computer_name
+    #   @return [String] the name of the computer running the VM that this BIOS configuration is attached to
+    attribute :computer_name, type: :string
+
+    # @!attribute [r] name
+    #   @return [String] the name of this floppy drive
+    attribute :name, type: :string
+    # @!attribute path
+    #   @return [String] the path this floppy drive is serving
+    attribute :path
+    # @!attribute pool_name
+    #   @return [String] the pool storing this floppy drive's image
+    attribute :pool_name
+
+    def update
+      requires :vm_id, :id
+
+      changes = {
+        resource_pool_name: changed!(:pool_name)
+      }.compact
+      changes[:path] = path if changed? :path
+      return self unless changes.any?
+
+      merge_attributes(
+        service.set_vm_floppy_disk_drive(
+          computer_name: computer_name,
+          vm_id: vm_id,
+          id: id,
+
+          **changes,
+
+          _always_include: changes.keys,
+          _return_fields: self.class.attributes
+        )
+      )
+    end
+
+    def reload
+      requires :vm_id, :id
+
+      data = service.get_vm_floppy_disk_drive(
+        computer_name: computer_name,
+        vm_id: vm_id,
+        id: id,
+
+        _return_fields: self.class.attributes
+      )
+      return unless data
+
+      merge_attributes(data)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class FloppyDrives < Fog::Hyperv::Collection
+    model Fog::Hyperv::Compute::FloppyDrive
+
+    get_method :get_vm_floppy_disk_drive
+
+    attribute :computer_name
+    attribute :vm_id
+
+    requires :vm_id
+
+    def get(id, **filters)
+      super(_by_id: id, **filters)
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'fog/hyperv/model'
+
+class Fog::Hyperv::Compute
+  # A hard drive attached to a VM
+  class HardDrive < Fog::Hyperv::Model
+    # @!attribute [r] id
+    #   @return [String] the GUID of this hard drive
+    identity :id
+
+    # @!attribute [r] computer_name
+    #   @return [String] the name of the computer running the VM that this hard drive is attached to
+    attribute :computer_name
+    # @!attribute [r] vm_id
+    #   @return [String] the GUID of the VM this hard drive is attached to
+    attribute :vm_id
+
+    # @!attribute controller_location
+    #   @return [String] the controller location this hard drive is attached to
+    attribute :controller_location
+    # @!attribute controller_number
+    #   @return [Integer] the controller number this hard drive is attached to
+    attribute :controller_number, type: :integer
+    # @!attribute [r] controller_type
+    #   @return [:IDE, :SCSI] the controller type this hard drive is attached to
+    attribute :controller_type, type: :hypervenum, values: %i[IDE SCSI]
+    # @!attribute disk
+    #   @return [Object] the attached physical disk
+    attribute :disk
+    # attribute :is_deleted
+    # @!attribute maximum_iops
+    #   @return [Integer] the maximum number of IOPS allocated for this hard drive
+    attribute :maximum_iops, type: :integer
+    # @!attribute minimum_iops
+    #   @return [Integer] the minimum number of IOPS allocated for this hard drive
+    attribute :minimum_iops, type: :integer
+    # @!attribute [r] name
+    #   @return [String] the name of this hard drive
+    attribute :name
+    # @!attribute path
+    #   @return [String] the path to the VHD file for this hard drive
+    attribute :path
+    # @!attribute pool_name
+    #   @return [String] the name of the pool storing this hard drive's image
+    attribute :pool_name
+    # @!attribute support_persistent_reservations
+    #   @return [Boolean] if the underlying hard drive supports SCSI persistent reservations.
+    #     This should be set when multiple VMs share the same underlying disk.
+    attribute :support_persistent_reservations
+    # TODO? VM Snapshots?
+
+    attribute :allow_unverified_paths, type: :boolean
+
+    has_one :vhd, :vhds
+
+    def initialize(attributes = {})
+      vhd = attributes[:vhd]
+      attributes[:path] ||= vhd&.path
+
+      super
+    end
+
+    # @!attribute vhd
+    # @return [Vhd,nil] the VHD that is attached to this hard drive
+    def vhd
+      return associations[:vhd] if associations[:vhd]
+      return unless path
+
+      associations[:vhd] = service.vhds.get(path, computer_name: computer_name)
+    end
+
+    def vhd=(new_vhd)
+      raise ArgumentError, 'Must be a VHD' unless new_vhd.nil? || new_vhd.is_a?(Vhd)
+
+      attributes[:path] = new_vhd&.path
+      associations[:vhd] = new_vhd
+    end
+
+    # @return [Boolean] does the hard drive have a VHD attached?
+    def vhd?
+      !vhd.nil?
+    end
+
+    # @!attribute [r] size_bytes
+    # @return [Integer,nil] the size of the underlying VHD if any
+    def size_bytes
+      vhd&.size
+    end
+
+    def create
+      requires :vm_id
+      requires_one :controller_location, :controller_number, :controller_type, :path
+
+      if associations[:vhd]
+        vhd.save if !vhd.persisted? || vhd.dirty?
+        attributes[:path] ||= vhd.path
+      end
+
+      merge_attributes(
+        service.add_vm_hard_disk_drive(
+          **attributes.slice(
+            :computer_name,
+            :vm_id,
+            :allow_unverified_paths,
+            :controller_location,
+            :controller_number,
+            :controller_type,
+            :maximum_iops,
+            :minimum_iops,
+            :path
+          ),
+          resource_pool_name: pool_name,
+
+          _return_fields: self.class.attributes - %i[allow_unverified_paths vhd]
+        )
+      )
+    end
+
+    def update
+      requires :id, :vm_id
+
+      changes = {
+        maximum_iops: changed!(:maximum_iops),
+        minimum_iops: changed!(:minimum_iops),
+        resource_pool_name: changed!(:pool_name),
+        support_persistent_reservations: changed!(:support_persistent_reservations),
+        to_controller_location: changed!(:controller_location),
+        to_controller_number: changed!(:controller_number),
+        to_controller_type: changed!(:controller_type)
+      }.compact
+      changes[:path] = path if changed?(:path)
+
+      if changes.any?
+        merge_attributes(
+          service.set_vm_hard_disk_drive(
+            computer_name: old.computer_name,
+            vm_id: old.vm_id,
+            id: old.id,
+
+            **changes,
+            allow_unverified_paths: allow_unverified_paths,
+
+            _always_include: changes.keys,
+            _return_fields: self.class.attributes - %i[allow_unverified_paths vhd]
+          )
+        )
+      end
+
+      if associations[:vhd]
+        vhd.save if !vhd.persisted? || vhd.dirty?
+        associations[:vhd] = nil if changed?(:path)
+      end
+
+      self
+    end
+
+    def reload
+      requires :id, :vm_id
+
+      data = service.get_vm_hard_disk_drive(
+        computer_name: computer_name,
+        vm_id: vm_id,
+        id: id,
+
+        _return_fields: self.class.attributes - %i[allow_unverified_paths vhd]
+      )
+      return unless data
+
+      merge_attributes(data)
+    end
+
+    def destroy(underlying: false)
+      return unless persisted?
+
+      requires :id, :vm_id
+
+      service.remove_vm_hard_disk_drive computer_name: computer_name, vm_id: vm_id, id: id
+      vhd.destroy if underlying && vhd?
+      true
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class HardDrives < Fog::Hyperv::Collection
+    model Fog::Hyperv::Compute::HardDrive
+
+    get_method :get_vm_hard_disk_drive
+
+    attribute :computer_name
+    attribute :vm_id
+
+    requires :vm_id
+
+    def get(id, **filters)
+      raise ArgumentError, 'Must provide a GUID' if id.nil? || id.empty?
+
+      super(_by_id: id, **filters)
+    end
+
+    protected
+
+    def search_attributes
+      super.merge(
+        _return_fields: model.attributes - %i[allow_unverified_paths vhd]
+      )
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Host < Fog::Hyperv::Model
+    # @!attribute [r] name
+    #   @return [String] the name of the host
+    identity :name
+    alias computer_name :name
+
+    # @!attribute [r] fully_qualified_domain_name
+    #   @return [String] the FQDN of this host
+    attribute :fully_qualified_domain_name
+    # @!attribute [r] logical_processor_count
+    #   @return [Integer] the number of logical CPUs on this host
+    attribute :logical_processor_count, type: :integer
+    # @!attribute [r] memory_capacity
+    #   @return [Integer] the amount of memory on this host
+    attribute :memory_capacity, type: :integer
+    # @!attribute [r] mac_address_minimum
+    #   @return [String] the lowest possible MAC address for VMs on this host
+    attribute :mac_address_minimum
+    # @!attribute [r] mac_address_maximum
+    #   @return [String] the highest possible MAC address for VMs on this host
+    attribute :mac_address_maximum
+    # @!attribute [r] maximum_storage_migrations
+    #   @return [String] the maximum number of simulatenous storage migrations on this host
+    attribute :maximum_storage_migrations, type: :integer
+    # @!attribute [r] maximum_virtual_machine_migrations
+    #   @return [String] the maximum number of simulatenous VMM migrations on this host
+    attribute :maximum_virtual_machine_migrations, type: :integer
+    # @!attribute [r] virtual_hard_disk_path
+    #   @return [String] the path where VHDs will be stored on this host
+    attribute :virtual_hard_disk_path
+    # @!attribute [r] virtual_machine_path
+    #   @return [String] the path where VMs will be stored on this host
+    attribute :virtual_machine_path
+
+    # @!attribute [r] network_adapters
+    #   @return [Array<NetworkAdapter>] the network adapters on this host
+    collection :network_adapters
+    # @!attribute [r] servers
+    #   @return [Array<Server>] the VMs running on this host
+    collection :servers
+    # @!attribute [r] switches
+    #   @return [Array<Switch>] the network switches available on this host
+    collection :switches
+
+    # @!attribute [r] secure_boot_templates
+    # @return [Array<String>] the available secure boot templates on this host
+    def secure_boot_templates
+      service.get_vm_host_sbt(computer_name: name)
+    end
+
+    def reload
+      requires :name
+
+      data = service.get_vm_host computer_name: computer_name, name: name
+      return unless data
+
+      merge_attributes(data)
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Fog::Hyperv::Compute
+  class Hosts < Fog::Hyperv::Collection
+    model Fog::Hyperv::Compute::Host
+
+    get_method :get_vm_host
+
+    def get(name, **filters)
+      super(computer_name: name, **filters)
+    end
+  end
+end