fog-hyperv 0.0.1

data/lib/fog/hyperv/fog_extensions/enum.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Attributes
+    class Enum < Default
+      attr_reader :values
+
+      def initialize(model, name, options)
+        @values = options.fetch(:values, [])
+        super
+      end
+
+      def create_setter
+        model.class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              if new_#{name}.is_a?(Fixnum)
+                raise Fog::Hyperv::Errors::ServiceError, "\#{new_#{name}} is not in the range (0..#{values.length - 1})" unless new_#{name} >= 0 && new_#{name} < #{values.length}
+                attributes[:#{name}] = #{values}[new_#{name}]
+              elsif new_#{name}.nil?
+                attributes[:#{name}] = nil
+              else
+                new_#{name} = new_#{name}.to_s.to_sym unless new_#{name}.is_a? String
+                raise Fog::Hyperv::Errors::ServiceError, "\#{new_#{name}} is not one of #{values.is_a?(Hash) ? values.values : values})" unless #{(values.is_a?(Hash) ? values.values : values)}.include? new_#{name}
+                attributes[:#{name}] = new_#{name}
+              end
+            end
+        EOS
+      end
+
+      def create_getter
+        model.class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}_num
+              return nil if self.#{name}.nil?
+              if self.#{name}.is_a?(Fixnum)
+                self.#{name}
+              else
+                if #{values}.is_a?(Hash)
+                  #{values}.key(self.#{name})
+                else
+                  #{values}.index(self.#{name})
+                end
+              end
+            end
+
+            def #{name}_values
+              #{values}.freeze
+            end
+        EOS
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module Compute
+    class Hyperv
+      class Bios < Fog::Hyperv::Model
+        identity :vm_id, type: :string
+
+        attribute :computer_name, type: :string
+        # attribute :is_deleted, type: :boolean
+        attribute :num_lock_enabled, type: :boolean
+        # TODO? Enum values; :CD, :IDE, :LegacyNetworkAdapter, :Floppy (, :VHD, :NetworkAdapter)
+        attribute :startup_order, type: :array
+        attribute :vm_name, type: :string
+
+        def save
+          requires :computer_name, :vm_name
+
+          raise Fog::Hyperv::Errors::ServiceError, "Can't create Bios instances" unless persisted?
+
+          data = service.set_vm_bios(
+            computer_name: computer_name,
+            vm_name: vm_name,
+            passthru: true,
+
+            disable_num_lock: changed?(:num_lock_enabled) && !num_lock_enabled,
+            enable_num_lock: changed?(:num_lock_enabled) && num_lock_enabled,
+            startup_order: changed!(:startup_order),
+
+            _return_fields: self.class.attributes,
+            _json_depth: 1
+          )
+
+          merge_attributes(data)
+          self
+        end
+
+        def reload
+          requires :computer_name, :vm_name
+
+          data = service.get_vm_bios(
+            computer_name: computer_name,
+            vm_name: vm_name,
+
+            _return_fields: self.class.attributes,
+            _json_depth: 1
+          )
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class Hyperv
+      class Cluster < Fog::Hyperv::Model
+        identity :id, type: :string
+
+        attribute :description, type: :string
+        attribute :domain, type: :string
+        attribute :name, type: :string
+
+        def nodes
+          [service.get_cluster_node(cluster: name, _return_fields: [:description, :name, :node_name])].flatten
+        end
+
+        def servers
+          @servers ||= service.servers.class.new \
+            cluster: self,
+            service: service
+        end
+
+        def reload
+          requires_one :domain, :name
+
+          data = service.get_cluster(
+            domain: domain,
+            name: name,
+
+            _return_fields: self.class.attributes,
+            _json_depth: 1
+          )
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class Hyperv
+      class Clusters < Fog::Hyperv::VMCollection
+        model Fog::Compute::Hyperv::Cluster
+
+        get_method :get_cluster
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Hyperv
+      class ComPort < Fog::Hyperv::Model
+        identity :id
+
+        attribute :computer_name
+        attribute :debugger_mode, type: :enum, values: [ :On, :Off ]
+        attribute :name
+        attribute :path
+        
+        def save
+          raise Fog::Errors::NotImplemented
+        end
+
+        def reload
+          raise Fog::Errors::NotImplemented
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Fog
+  module Compute
+    class Hyperv
+      class DvdDrive < Fog::Hyperv::Model
+        identity :id
+
+        attribute :computer_name
+        # attribute :is_deleted
+        attribute :name
+        attribute :path
+        attribute :pool_name
+        attribute :controller_location
+        attribute :controller_number
+        attribute :controller_type, type: :enum, values: [ :IDE, :SCSI ]
+        attribute :dvd_media_type, type: :enum, values: [ :None, :ISO, :Passthrough ]
+        attribute :vm_id
+        attribute :vm_name
+        # TODO? VM Snapshots?
+        #
+        attr_accessor :to_controller_number, :to_controller_location
+
+        def save
+          requires :computer_name, :vm_name
+
+          data = service.set_vm_dvd_drive(
+            computer_name: computer_name,
+            vm_name: vm_name,
+            passthru: true,
+
+            controller_number: controller_number,
+            controller_location: controller_location,
+            resource_pool_name: pool_name,
+            path: path || '$null',
+            to_controller_number: to_controller_number,
+            to_controller_location: to_controller_location,
+
+            _return_fields: self.class.attributes,
+            _json_depth: 1
+          )
+          merge_attributes(data)
+          self
+        end
+
+        def reload
+          requires :computer_name, :vm_name
+
+          data = collection.get(
+            computer_name: computer_name,
+            vm_name: vm_name,
+            controller_location: controller_location,
+            controller_number: controller_number,
+
+            _return_fields: self.class.attributes,
+            _json_depth: 1
+          )
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class Hyperv
+      class DvdDrives < Fog::Hyperv::VMCollection
+        model Fog::Compute::Hyperv::DvdDrive
+
+        get_method :get_vm_dvd_drive
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module Compute
+    class Hyperv
+      class Firmware < Fog::Hyperv::Model
+        identity :vm_id
+
+        attribute :boot_order
+        attribute :computer_name
+        attribute :console_mode, type: :enum, values: [ :Default, :COM1, :COM2, :None ]
+        # attribute :is_deleted
+        attribute :preferred_network_boot_protocol, type: :enum, values: [ :IPv4, :IPv6 ]
+        attribute :secure_boot, type: :enum, values: [ :On, :Off ]
+        attribute :vm_name
+
+        def save
+          requires :computetr_name, :vm_name
+
+          raise Fog::Hyperv::Errors::ServiceError, "Can't create Firmware instances" unless persisted?
+
+          data = service.set_firmware(
+            computer_name: computer_name,
+            vm_name: vm_name,
+            passthru: true,
+
+            enable_secure_boot: changed?(:secure_boot) ? (secure_boot && 'On' || 'Off') : nil,
+            preferred_network_boot_protocol: changed!(:preferred_network_boot_protocol),
+            console_mode: changed!(:console_mode),
+
+            _return_fields: self.class.attributes
+          )
+
+          merge_attributes(data)
+          @old = dup
+          self
+        end
+
+        def reload
+          requires :computer_name, :vm_name
+
+          data = service.get_firmware(
+            computer_name: computer_name,
+            vm_name: vm_name,
+
+            _return_fields: self.class.attribute
+          )
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class Hyperv
+      class FloppyDrive < Fog::Hyperv::Model
+        identity :id
+
+        attribute :computer_name
+        attribute :disk
+        attribute :is_deleted
+        attribute :name
+        attribute :path
+        attribute :pool_name
+        attribute :vm_id
+        attribute :vm_name
+        # TODO? VM Snapshots?
+        #
+
+        def save
+          requires :computer_name, :vm_name
+
+          data = service.set_vm_floppy_disk_drive(
+            computer_name: computer_name,
+            vm_name: vm_name,
+            passthru: true,
+
+            resource_pool_name: pool_name,
+            path: path,
+
+            _return_fields: self.class.attributes,
+            _json_depth: 1
+          )
+
+          merge_attributes(data)
+          self
+        end
+
+        def reload
+          data = collection.get(
+            computer_name: computer_name,
+            vm_name: vm_name
+          )
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class Hyperv
+      class FloppyDrives < Fog::Hyperv::VMCollection
+        model Fog::Compute::Hyperv::FloppyDrive
+
+        get_method :get_vm_floppy_disk_drive
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+module Fog
+  module Compute
+    class Hyperv
+      class HardDrive < Fog::Hyperv::Model
+        identity :id
+
+        attribute :computer_name
+        attribute :controller_location
+        attribute :controller_number
+        attribute :controller_type, type: :enum, values: [ :IDE, :SCSI ]
+        attribute :disk
+        # attribute :is_deleted
+        attribute :maximum_iops
+        attribute :minimum_iops
+        attribute :name
+        attribute :path
+        attribute :pool_name
+        attribute :support_persistent_reservations
+        attribute :vm_id
+        attribute :vm_name
+        # TODO? VM Snapshots?
+
+        def vhd
+          return nil unless path && computer_name
+          @vhd ||= Fog::Compute::Hyperv::Vhd.new(service.get_vhd(computer_name: computer_name, path: path).merge(service: service))
+        end
+
+        def size_bytes
+          vhd && vhd.size_bytes || 0
+        end
+
+        def size_bytes=(bytes)
+          vhd.size_bytes = bytes if vhd
+        end
+
+        def save
+          requires :computer_name, :vm_name
+
+          if persisted?
+            data = service.set_vm_hard_disk_drive(
+              computer_name: old.computer_name,
+              vm_name: old.vm_name,
+              controller_location: old.controller_location,
+              controller_number: old.controller_number,
+              controller_type: old.controller_type,
+
+              disk_number: changed?(:disk) && disk && disk.number,
+              maximum_iops: changed?(:maximum_iops) && maximum_iops,
+              minimum_iops: changed?(:minimum_iops) && minimum_iops,
+              path: changed?(:path) && path,
+              resource_pool_name: changed?(:pool_name) && pool_name,
+              support_persistent_reservations: changed?(:support_persistent_reservations) && support_persistent_reservations,
+              to_controller_location: changed?(:controller_location) && controller_location,
+              to_controller_number: changed?(:controller_number) && controller_number,
+              to_controller_type: changed?(:controller_type) && controller_type,
+
+              passthru: true,
+              _return_fields: self.class.attributes,
+              _json_depth: 1
+            )
+            @vhd = nil if changed?(:path)
+          else
+            possible = %i(computer_name controller_location controller_number controller_type path vm_name).freeze
+            data = service.add_vm_hard_disk_drive(
+              attributes.select { |k, _v| possible.include? k }.merge(
+                disk_number: disk && disk.number,
+                resource_pool_name: pool_name,
+
+                passthru: true,
+                _return_fields: self.class.attributes,
+                _json_depth: 1
+              )
+            )
+          end
+
+          merge_attributes(data)
+          @old = dup
+          self
+        end
+
+        def reload
+          data = collection.get(
+            computer_name: computer_name,
+            vm_name: vm_name,
+            controller_location: controller_location,
+            controller_number: controller_number,
+            controller_type: controller_type
+          )
+
+          merge_attributes(data.attributes)
+          @old = data
+          self
+        end
+
+        def destroy
+          return unless persisted?
+
+          service.remove_vm_hard_disk_drive(
+            computer_name: computer_name,
+            vm_name: vm_name,
+
+            controller_location: controller_location,
+            controller_number: controller_number,
+            controller_type: controller_type
+          )
+        end
+      end
+    end
+  end
+end