fog-hyperv 0.0.9 → 0.1.1

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

@@ -1,85 +0,0 @@
-module Fog
-  module Attributes
-    class Enum < Default
-      attr_reader :values
-
-      def initialize(model, name, options)
-        @values = options.fetch(:values, [])
-
-        raise Fog::Hyperv::Errors::ServiceError, "#{values} is not a valid array or hash" \
-          unless values.class.to_s == 'Array' || values.class.to_s == 'Hash'
-
-        super
-      end
-
-      def ensure_value_getter
-        return if model.private_methods.include?("#{name}_values".to_sym)
-
-        model.class_eval <<-EOS, __FILE__, __LINE__
-            private
-            def #{name}_values
-              #{values}.freeze
-            end
-        EOS
-      end
-
-      def create_setter
-        ensure_value_getter
-
-        # Add a setter that always stores a symbol value
-        model.class_eval <<-EOS, __FILE__, __LINE__
-            def #{name}=(new_value)
-              _values = #{name}_values
-              if new_value.is_a?(Numeric)
-                # TODO: Better way to do class comparison in generated code
-                if _values.class.to_s == 'Array'
-                  raise Fog::Hyperv::Errors::ServiceError, "\#{new_value} is not in the range (0..\#{_values.length - 1})" \
-                    unless new_value >= 0 && new_value < _values.length
-                  attributes[:#{name}] = _values[new_value]
-                elsif _values.class.to_s == 'Hash'
-                  raise Fog::Hyperv::Errors::ServiceError, "\#{new_value} is not one of \#{_values.values})" \
-                    unless _values.values.include? new_value
-                  attributes[:#{name}] = _values.key(new_value)
-                end
-              elsif new_value.nil?
-                attributes[:#{name}] = nil
-              else
-                new_value = new_value.to_s.to_sym unless new_value.is_a? Symbol
-                # Ensure values is the array of enum symbols
-                _values = (_values.is_a?(Hash) ? _values.keys : _values)
-                raise Fog::Hyperv::Errors::ServiceError, "\#{new_value.inspect} is not one of \#{_values})" \
-                  unless _values.include? new_value
-                attributes[:#{name}] = new_value
-              end
-            end
-        EOS
-      end
-
-      def create_getter
-        ensure_value_getter
-
-        # Add a getter for <enum>_num to get the numeric value
-        model.class_eval <<-EOS, __FILE__, __LINE__
-            def #{name}_num
-              _values = #{name}_values
-              _value = attributes[:#{name}]
-
-              return nil if _value.nil?
-              if _value.is_a?(Numeric)
-                _value
-              else
-                if _values.is_a?(Hash)
-                  _values.send(:[], _value)
-                else
-                  _values.index(_value)
-                end
-              end
-            end
-        EOS
-        
-        # Add the default getter for the symbol value
-        super
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-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
-        
-        attr_reader :computer, :vm
-
-        def initialize(args = {})
-          super
-          @computer = args.delete :computer
-          @vm = args.delete :vm
-        end
-
-        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)
-          @old = dup
-          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)
-          self
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-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 initialize(attrs = {})
-        #   super
-
-          # @collections = {}
-          # self.class.ensure_collections!
-        # end
-
-        def nodes
-          attributes[:nodes] ||= id.nil? ? [] : [service.get_cluster_node(cluster: name, _return_fields: [:description, :name, :node_name])].flatten
-        end
-
-        def hosts
-          attributes[:hosts] ||= id.nil? ? [] : nodes.map { |n| service.hosts.get(n[:name]) }
-        end
-
-        def reload
-          requires_one :domain, :name
-
-          data = service.get_cluster(
-            domain: domain,
-            name: name,
-
-            _return_fields: self.class.attributes,
-            _json_depth: 1
-          )
-
-          attributes[:nodes] = nil
-          attributes[:hosts] = nil
-
-          merge_attributes(data.attributes)
-          self
-        end
-
-        # def self.ensure_collections!
-        #   return if @collections
-        #   @collections = true
-
-        #   Fog::Compute::Hyperv.collections.each do |coll|
-        #     # Don't recurse on hosts
-        #     next if coll == :hosts
-
-        #     coll_name = coll.to_s.split('_').map(&:capitalize).join
-        #     klass = Fog::Compute::Hyperv.const_get(coll_name)
-        #     next if klass.requires?(:vm)
-
-        #     define_method coll do
-        #       @collections[coll] ||= service.send(coll, cluster: self)
-        #     end
-        #   end
-        # end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Clusters < Fog::Hyperv::VMCollection
-        model Fog::Compute::Hyperv::Cluster
-
-        get_method :get_cluster
-
-        def get(name, filters = {})
-          super(filters.merge(name: name))
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class ComPort < Fog::Hyperv::Model
-        identity :id
-
-        attribute :computer_name
-        attribute :debugger_mode, type: :enum, values: %i[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

@@ -1,92 +0,0 @@
-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: %i[IDE SCSI]
-        attribute :dvd_media_type, type: :enum, values: %i[None ISO Passthrough]
-        attribute :vm_id
-        attribute :vm_name
-        # TODO? VM Snapshots?
-        #
-
-        def save
-          requires :computer_name, :vm_name
-
-          data = \
-            if persisted?
-              service.set_vm_dvd_drive(
-                computer_name: old.computer_name,
-                vm_name: old.vm_name,
-                controller_number: old.controller_number,
-                controller_location: old.controller_location,
-                passthru: true,
-
-                resource_pool_name: changed!(:pool_name),
-                path: changed?(:path) && (path || '$null'),
-                to_controller_number: changed!(:controller_number),
-                to_controller_location: changed!(:controller_location),
-
-                _return_fields: self.class.attributes,
-                _json_depth: 1
-              )
-            else
-              service.add_vm_dvd_drive(
-                computer_name: computer_name,
-                vm_name: vm_name,
-                passthru: true,
-
-                controller_number: controller_number,
-                controller_location: controller_location,
-                path: path,
-                resource_pool_name: pool_name,
-
-                _return_fields: self.class.attributes,
-                _json_depth: 1
-              )
-            end
-
-          merge_attributes(data)
-          @old = dup
-          self
-        end
-
-        def destroy
-          requires :computer_name, :vm_name, :controller_number, :controller_location
-
-          service.remove_vm_dvd_drive(
-            computer_name: computer_name,
-            vm_name: vm_name,
-            controller_number: controller_number,
-            controller_location: controller_location
-          )
-        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)
-          @old = data
-          self
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,53 +0,0 @@
-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: %i[Default COM1 COM2 None]
-        # attribute :is_deleted
-        attribute :preferred_network_boot_protocol, type: :enum, values: %i[IPv4 IPv6]
-        attribute :secure_boot, type: :enum, values: %i[On Off]
-        attribute :vm_name
-
-        def save
-          requires :computer_name, :vm_name
-
-          raise Fog::Hyperv::Errors::ServiceError, "Can't create Firmware instances" unless persisted?
-
-          data = service.set_vm_firmware(
-            computer_name: computer_name,
-            vm_name: vm_name,
-            passthru: true,
-
-            enable_secure_boot: changed!(:secure_boot),
-            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_vm_firmware(
-            computer_name: computer_name,
-            vm_name: vm_name,
-
-            _return_fields: self.class.attributes
-          )
-          merge_attributes(data)
-          @old = data
-          self
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-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
-          raise Fog::Hyperv::Errors::ServiceError, "Can't create new floppy drives" unless persisted?
-
-          requires :computer_name, :vm_name
-
-          data = \
-            service.set_vm_floppy_disk_drive(
-              computer_name: old.computer_name,
-              vm_name: old.vm_name,
-              passthru: true,
-
-              resource_pool_name: changed!(:pool_name),
-              path: changed?(:path) && (path || '$null'),
-
-              _return_fields: self.class.attributes,
-              _json_depth: 1
-            )
-
-          merge_attributes(data)
-          @old = dup
-          self
-        end
-
-        def reload
-          data = collection.get(
-            computer_name: computer_name,
-            vm_name: vm_name
-          )
-          merge_attributes(data.attributes)
-          @old = data
-          self
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,110 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class HardDrive < Fog::Hyperv::Model
-        identity :id
-
-        attribute :computer_name
-        attribute :controller_location
-        attribute :controller_number, type: :integer
-        attribute :controller_type, type: :enum, values: %i[IDE SCSI]
-        attribute :disk
-        # attribute :is_deleted
-        attribute :maximum_iops, type: :integer
-        attribute :minimum_iops, type: :integer
-        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 ||= service.vhds.get(path, computer_name: computer_name)
-        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,
-              passthru: true,
-
-              disk_number: changed?(:disk) && disk && disk.number,
-              maximum_iops: changed!(:maximum_iops),
-              minimum_iops: changed!(:minimum_iops),
-              path: changed!(:path),
-              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),
-
-              _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

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

@@ -1,11 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class HardDrives < Fog::Hyperv::VMCollection
-        model Fog::Compute::Hyperv::HardDrive
-
-        get_method :get_vm_hard_disk_drive
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Host < Fog::Hyperv::Model
-        identity :name
-
-        attribute :computer_name
-        attribute :fully_qualified_domain_name
-        attribute :logical_processor_count
-        attribute :memory_capacity
-        attribute :mac_address_minimum
-        attribute :mac_address_maximum
-        attribute :maximum_storage_migrations
-        attribute :maximum_virtual_machine_migrations
-        attribute :virtual_hard_disk_path
-        attribute :virtual_machine_path
-
-        def initialize(attrs = {})
-          super
-
-          @collections = {}
-          self.class.ensure_collections!
-        end
-
-        def self.ensure_collections!
-          return if @collections
-          @collections = true
-
-          Fog::Compute::Hyperv.collections.each do |coll|
-            # Hosts don't have host collections
-            next if coll == :hosts
-
-            coll_name = coll.to_s.split('_').map(&:capitalize).join
-            klass = Fog::Compute::Hyperv.const_get(coll_name)
-            next if klass.requires?(:vm)
-
-            define_method coll do
-              @collections[coll] ||= service.send(coll, computer: self)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Hosts < Fog::Hyperv::Collection
-        model Fog::Compute::Hyperv::Host
-
-        get_method :get_vm_host
-
-        def get(name, filters = {})
-          super filters.merge(computer_name: name)
-        end
-      end
-    end
-  end
-end