fog-hyperv 0.0.8 → 0.1.0

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

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

@@ -1,145 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class NetworkAdapter < Fog::Hyperv::Model
-        identity :id
-
-        # attribute :acl_list
-        attribute :computer_name
-        attribute :connected
-        attribute :dynamic_mac_address_enabled, type: :boolean, default: true
-        attribute :ip_addresses
-        # attribute :is_deleted
-        attribute :is_external_adapter
-        attribute :is_legacy
-        attribute :is_management_os
-        # attribute :isolation_setting # Might need lazy loading
-        attribute :mac_address
-        attribute :name, type: :string, default: 'Network Adapter'
-        # attribute :router_guard, type: :enum, values: [ :On, :Off ]
-        # attribute :status, type: :enum, values: STATUS_ENUM_VALUES
-        attribute :switch_id
-        attribute :switch_name, type: :string
-        attribute :vm_id
-        attribute :vm_name
-        # attribute :vlan_setting # Might need lazy loading
-
-        def connect(switch, options = {})
-          requires :name, :computer_name, :vm_name
-
-          switch = switch.name if switch.is_a? Fog::Compute::Hyperv::Switch
-
-          service.connect_vm_network_adapter options.merge(
-            computer_name: computer_name,
-            name: name,
-            switch_name: switch,
-            vm_name: vm_name
-          )
-        end
-
-        def disconnect(options = {})
-          requires :name, :computer_name, :vm_name
-
-          service.disconnect_vm_network_adapter options.merge(
-            computer_name: computer_name,
-            name: name,
-            vm_name: vm_name
-          )
-        end
-
-        def switch
-          service.switches.get switch_name, computer_name: computer_name if switch_name
-        end
-
-        def ip_addresses
-          attributes[:ip_addresses] = [] \
-            if attributes[:ip_addresses] == ''
-          attributes[:ip_addresses]
-        end
-
-        def save
-          requires :name, :computer_name, :vm_name
-
-          data = \
-            if !persisted?
-              service.add_vm_network_adapter(
-                computer_name: computer_name,
-                name: name,
-                vm_name: vm_name,
-                passthru: true,
-
-                dynamic_mac_address: dynamic_mac_address_enabled,
-                is_legacy: !!is_legacy,
-                static_mac_address: !dynamic_mac_address_enabled && mac_address,
-                switch_name: switch_name,
-
-                _return_fields: self.class.attributes,
-                _json_depth: 1
-              )
-            else
-              ret = service.set_vm_network_adapter(
-                computer_name: old.computer_name,
-                name: old.name,
-                vm_name: old.vm_name,
-                passthru: true,
-
-                dynamic_mac_address: changed?(:dynamic_mac_address_enabled) && dynamic_mac_address_enabled, 
-                static_mac_address: changed!(:mac_address) || ((changed!(:dynamic_mac_address_enabled) == false) && mac_address),
-
-                _return_fields: self.class.attributes,
-                _json_depth: 1
-              )
-
-              if changed?(:switch_name)
-                service.disconnect_vm_network_adapter(
-                  computer_name: ret.computer_name,
-                  name: ret.name,
-                  vm_name: ret.vm_name
-                ) unless switch_name
-
-                service.connect_vm_network_adapter(
-                  computer_name: ret.computer_name,
-                  name: ret.name,
-                  vm_name: ret.vm_name,
-                  switch_name: switch_name
-                ) if switch_name
-              end
-              ret[:switch_name] = switch_name
-              ret
-            end
-
-          if data.is_a? Array
-            data = data.find { |e| e[:id] == id } if id
-            data = data.last unless id
-          end
-
-          merge_attributes(data)
-          @old = dup
-          self
-        end
-
-        def destroy
-          requires :vm_name, :name, :computer_name, :id
-
-          service.remove_vm_network_adapter(
-            name: name,
-            computer_name: computer_name,
-            vm_name: vm_name
-          )
-        end
-
-        def reload
-          data = collection.get(
-            name,
-            computer_name: computer_name,
-            vm_name: vm_name,
-            _suffix: "| Where Id -Eq '#{id}'"
-          )
-          merge_attributes(data.attributes)
-          @old = data
-          self
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class NetworkAdapters < Fog::Hyperv::VMCollection
-        model Fog::Compute::Hyperv::NetworkAdapter
-
-        get_method :get_vm_network_adapter
-
-        def all(filters = {})
-          super filters.merge(all: !vm)
-        end
-
-        def get(name, filters = {})
-          super filters.merge(name: name, all: !vm)
-        end
-      end
-    end
-  end
-end

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

@@ -1,220 +0,0 @@
-require 'fog/compute/models/server'
-
-module Fog
-  module Compute
-    class Hyperv
-      class Server < Fog::Compute::Server
-        extend Fog::Hyperv::ModelExtends
-        include Fog::Hyperv::ModelIncludes
-
-        VM_STATUS_ENUM_VALUES = {
-          Unknown: 1,
-          Running: 2,
-          Off: 3,
-          Stopping: 4,
-          Saved: 6,
-          Paused: 9,
-          Starting: 10,
-          Reset: 11,
-          Saving: 32773,
-          Pausing: 32776,
-          Resuming: 32777,
-          FastSaved: 32779,
-          FastSaving: 32780,
-          ForceShutdown: 32781,
-          ForceReboot: 32782,
-          RunningCritical: 32783,
-          OffCritical: 32784,
-          StoppingCritical: 32785,
-          SavedCritical: 32786,
-          PausedCritical: 32787,
-          StartingCritical: 32788,
-          ResetCritical: 32789,
-          SavingCritical: 32790,
-          PausingCritical: 32791,
-          ResumingCritical: 32792,
-          FastSavedCritical: 32793,
-          FastSavingCritical: 32794,
-        }.freeze
-
-        identity :id, type: :string
-
-        attribute :name, type: :string
-        attribute :computer_name, type: :string
-        attribute :com_port1
-        attribute :com_port2
-        attribute :dynamic_memory_enabled, type: :boolean, default: false
-        attribute :generation, type: :integer, default: 1 # 1 => bios, 2 => uefi
-        attribute :is_clustered, type: :boolean, default: false
-        attribute :state, type: :enum, values: VM_STATUS_ENUM_VALUES
-        attribute :status, type: :string
-        attribute :memory_assigned, type: :integer
-        attribute :memory_maximum, type: :integer, default: 17_179_869_184
-        attribute :memory_minimum, type: :integer, default: 536_870_912
-        attribute :memory_startup, type: :integer, default: 536_870_912
-        attribute :notes, type: :string
-        attribute :processor_count, type: :integer, default: 1
-
-        lazy_attributes :network_adapters,
-          :dvd_drives,
-          :hard_drives,
-          :floppy_drive
-
-        attr_accessor :cluster_name
-
-        %i(network_adapters dvd_drives floppy_drives hard_drives vhds).each do |attr|
-          define_method attr do
-            if persisted?
-              attributes[attr] ||= service.send(attr, vm: self)
-            else
-              attributes[attr] ||= [] unless persisted?
-            end
-          end
-        end
-
-        %i(com_port1 com_port2).each do |attr|
-          define_method "#{attr}=".to_sym do |data|
-            attributes[attr] = Fog::Compute::Hyperv::ComPort.new(data) if data.is_a?(Hash)
-          end
-        end
-
-        def initialize(attrs = {})
-          super
-
-          @cluster = attrs.delete :cluster
-          @computer = attrs.delete :computer
-        end
-
-        def bios
-          @bios ||= begin
-                      if generation == 1
-                        Fog::Compute::Hyperv::Bios.new(service.get_vm_bios(computer_name: computer_name, vm_name: name).merge service: service)
-                      elsif generation == 2
-                        Fog::Compute::Hyperv::Firmware.new(service.get_vm_firmware(computer_name: computer_name, vm_name: name).merge service: service)
-                      end
-                    end
-        end
-        alias firmware :bios
-
-        alias vm_id :id
-        alias vm_name :name
-
-        # TODO: Do this properly
-        def set_vlan(vlan_id, options = {})
-          requires :name, :computer_name
-          if vlan_id
-            options[:access] = true
-            options[:vlan_id] = vlan_id
-          else
-            options[:untagged] = true
-          end
-
-          service.set_vm_network_adapter_vlan options.merge(
-            vm_name: name,
-            computer_name: computer_name
-          )
-        end
-
-        def start(options = {})
-          requires :name, :computer_name
-          service.start_vm options.merge(
-            name: name,
-            computer_name: computer_name
-          )
-        end
-
-        def stop(options = {})
-          requires :name, :computer_name
-          service.stop_vm options.merge(
-            name: name,
-            computer_name: computer_name
-          )
-        end
-
-        def restart(options = {})
-          requires :name, :computer_name
-          service.restart_vm options.merge(
-            name: name,
-            computer_name: computer_name
-          )
-        end
-        alias reboot :restart
-
-        def destroy(options = {})
-          requires :name, :computer_name
-          stop turn_off: true if ready?
-          service.remove_vm options.merge(
-            name: name,
-            computer_name: computer_name
-          )
-        end
-
-        def add_interface(options = {})
-          network_adapters.create options
-        end
-
-        def save(options = {})
-          requires :name
-
-          data = \
-            if !persisted?
-              usable = %i(name memory_startup generation boot_device switch_name no_vhd new_vhd_path new_vhd_size_bytes).freeze
-              service.new_vm \
-                attributes.select { |k, _v| usable.include? k }
-                .merge(options)
-                .merge(_return_fields: self.class.attributes, _json_depth: 1)
-            else
-              service.set_vm options.merge(
-                computer_name: old.computer_name,
-                name: old.name,
-                passthru: true,
-
-                processor_count: changed!(:processor_count),
-                dynamic_memory: changed?(:dynamic_memory_enabled) && dynamic_memory_enabled,
-                static_memory: changed?(:dynamic_memory_enabled) && !dynamic_memory_enabled,
-                memory_minimum_bytes: changed?(:memory_minimum) && dynamic_memory_enabled && memory_minimum,
-                memory_maximum_bytes: changed?(:memory_maximum) && dynamic_memory_enabled && memory_maximum,
-                memory_startup_bytes: changed!(:memory_startup),
-                notes: changed!(:notes),
-                new_name: changed!(:name),
-
-                _return_fields: self.class.attributes,
-                _json_depth: 1
-              )
-            end
-
-          merge_attributes(data)
-          @old = dup
-          self
-        end
-
-        def reload
-          data = collection.get id
-
-          clear_lazy
-          merge_attributes(data.attributes)
-          @old = data
-          self
-        end
-
-        def ready?
-          state_num == 2
-        end
-
-        def mac_addresses
-          network_adapters.map(&:mac_address)
-        end
-
-        def ip_addresses
-          network_adapters.map(&:ip_addresses).flatten
-        end
-
-        def public_ip_address
-          ip_addresses
-            .reject { |a| a =~ /^(169\.254|fe80)/ }
-            .first
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Servers < Fog::Hyperv::ComputerCollection
-        model Fog::Compute::Hyperv::Server
-
-        get_method :get_vm
-
-        def get(identity, filters = {})
-          guid = identity =~ /\w{8}-\w{4}-\w{4}-\w{4}-\w{12}/
-
-          search = {}
-          search[:id] = identity if guid
-          search[:name] = identity unless guid
-
-          super search.merge(filters)
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Switch < Fog::Hyperv::Model
-        identity :id
-
-        attribute :computer_name
-        # attribute :default_flow_minimum_bandwidth_absolute
-        # attribute :default_flow_minimum_bandwidth_weight
-        # attribute :is_deleted
-        attribute :name
-        attribute :net_adapter_interface_description
-        attribute :notes
-        attribute :switch_type, type: :enum, values: %i[Private Internal External]
-
-        def save
-          requires :name
-
-          data = \
-            if persisted?
-              service.set_vm_switch(
-                computer_name: old.computer_name,
-                name: old.name,
-                net_adapter_interface_description: old.net_adapter_interface_description,
-                switch_type: !old.net_adapter_interface_description && old.switch_type,
-                passthru: true,
-
-                default_flow_minimum_bandwidth_absolute: changed!(default_flow_minimum_bandwidth_absolute),
-                default_flow_minimum_bandwidth_weight: changed!(default_flow_minimum_bandwidth_weight),
-                notes: changed!(notes),
-
-                _return_fields: self.class.attributes,
-                _json_depth: 1
-              )
-            else
-              service.new_vm_switch(
-                computer_name: computer_name,
-                name: name,
-                net_adapter_interface_description: net_adapter_interface_description,
-                notes: notes,
-                switch_type: !net_adapter_interface_description && switch_type,
-
-                _return_fields: self.class.attributes,
-                _json_depth: 1
-              )
-            end
-
-          merge_attributes(data)
-          @old = dup
-          self
-        end
-
-        def reload
-          data = collection.get(
-            name,
-            computer_name: computer_name
-          )
-          merge_attributes(data.attributes)
-          @old = data
-          self
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Switches < Fog::Hyperv::ComputerCollection
-        model Fog::Compute::Hyperv::Switch
-
-        get_method :get_vm_switch
-
-        def get(name, filters = {})
-          super filters.merge(name: name)
-        end
-      end
-    end
-  end
-end