fog-hyperv 0.0.8 → 0.1.0

data/lib/fog/collection.rb

@@ -1,152 +0,0 @@
-require 'fog/core/collection'
-
-module Fog
-  module Hyperv
-    class Collection < Fog::Collection
-      def self.get_method(method = nil)
-        @get_method ||= method
-      end
-
-      def self.requires
-        @requires ||= []
-      end
-
-      def self.requires?(req)
-        requires.include? req
-      end
-
-      def all(filters = {})
-        requires(*self.class.requires)
-        data = service.send(method, search_attributes.merge(filters))
-        data = [] unless data
-
-        load [data].flatten
-      end
-
-      def get(filters = {})
-        data = all(filters).first
-        data if data
-      rescue Fog::Hyperv::Errors::PSError => err
-        raise Fog::Errors::NotFound, err if err.message =~ /Hyper-V was unable to find|^No .* is found/
-        raise err
-      end
-
-      def new(options = {})
-        requires(*self.class.requires)
-        super(creation_attributes.merge(options))
-      end
-
-      def create(attributes = {})
-        object = new(attributes)
-        object.save
-        object
-      end
-
-      protected
-
-      def search_attributes
-        attributes.dup.merge(
-          _return_fields: model.attributes - model.lazy_attributes,
-          _json_depth: 1
-        )
-      end
-
-      def creation_attributes
-        attributes.dup
-      end
-
-      private
-
-      def method
-        self.class.get_method
-      end
-    end
-
-    class ComputerCollection < Fog::Hyperv::Collection
-      def self.requires_computer
-        requires << :computer
-      end
-
-      attr_accessor :cluster
-      attr_accessor :computer
-
-      def new(attributes = {})
-        object = super
-        object.computer_name ||= computer.name if computer && object.respond_to?(:computer_name)
-        object
-      end
-
-      protected
-
-      def creation_attributes
-        attrs = super
-        attrs[:cluster] = cluster if cluster
-        attrs[:computer] = computer if computer
-        attrs[:computer_name] = computer.name if computer
-        attrs
-      end
-
-      def search_attributes
-        attrs = super
-        attrs.delete :cluster
-        attrs.delete :computer
-        attrs[:computer_name] ||= cluster.hosts.map(&:name) if cluster
-        attrs[:computer_name] ||= computer.name if computer
-        attrs
-      end
-    end
-
-    class VMCollection < Fog::Hyperv::ComputerCollection
-      def self.match_on(attr = nil)
-        @match_on ||= attr
-      end
-
-      def self.requires_vm
-        requires << :vm
-      end
-
-      attr_accessor :vm
-
-      def new(attributes = {})
-        object = super
-        object.computer_name ||= vm.computer_name if vm && object.respond_to?(:computer_name)
-        # Ensure both ID and Name are populated, regardless of `match_on`
-        object.vm_id ||= vm.id if vm && object.respond_to?(:vm_id)
-        object.vm_name ||= vm.name if vm && object.respond_to?(:vm_name)
-        object
-      end
-
-      def inspect
-        # To avoid recursing on VM
-        to_s
-      end
-
-      protected
-
-      def creation_attributes
-        attrs = super
-        attrs[:vm] = vm if vm
-        attrs[:computer_name] = vm.computer_name if vm && vm.computer_name
-        attrs[:cluster_name] = vm.cluster_name if vm && vm.cluster_name
-
-        attrs
-      end
-
-      def search_attributes
-        attrs = super
-        attrs.delete :vm
-        if vm
-          attrs[:computer_name] ||= vm.computer_name
-          attrs[match] = vm.send(match)
-        end
-        attrs
-      end
-
-      private
-
-      def match
-        self.class.match_on || :vm_name
-      end
-    end
-  end
-end

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
-          @nodes ||= [service.get_cluster_node(cluster: name, _return_fields: [:description, :name, :node_name])].flatten
-        end
-
-        def hosts
-          @hosts ||= 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
-          )
-
-          @nodes = nil
-          @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