fog-hyperv 0.0.1

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,20 @@
+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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,142 @@
+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,
+                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)) && !dynamic_mac_address_enabled && 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
+          )
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,192 @@
+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 = {
+          1     => :Unknown,
+          2     => :Running,
+          3     => :Off,
+          4     => :Stopping,
+          6     => :Saved,
+          9     => :Paused,
+          10    => :Starting,
+          11    => :Reset,
+          32773 => :Saving,
+          32776 => :Pausing,
+          32777 => :Resuming,
+          32779 => :FastSaved,
+          32780 => :FastSaving,
+          32781 => :ForceShutdown,
+          32782 => :ForceReboot,
+          32783 => :RunningCritical,
+          32784 => :OffCritical,
+          32785 => :StoppingCritical,
+          32786 => :SavedCritical,
+          32787 => :PausedCritical,
+          32788 => :StartingCritical,
+          32789 => :ResetCritical,
+          32790 => :SavingCritical,
+          32791 => :PausingCritical,
+          32792 => :ResumingCritical,
+          32793 => :FastSavedCritical,
+          32794 => :FastSavingCritical
+        }.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 :state, type: :enum, values: VM_STATUS_ENUM_VALUES
+        attribute :status, type: :string
+        attribute :memory_assigned, type: :integer
+        attribute :memory_maximum, type: :integer, default: 171_798_691_84
+        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
+
+        %i(network_adapters dvd_drives floppy_drives hard_drives vhds).each do |attr|
+          define_method attr do
+            attributes[attr] ||= [] unless persisted?
+            attributes[attr] ||= service.send(attr, vm: self)
+          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 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
+
+        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
+          logger.debug "Saving server with; #{attributes}, #{options}"
+
+          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

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Hyperv
+      class Servers < Fog::Hyperv::Collection
+        attribute :cluster
+
+        model Fog::Compute::Hyperv::Server
+
+        get_method :get_vm
+
+        def search_attributes
+          attrs = super
+          attrs[:computer_name] = cluster.nodes.map { |n| n[:name] } if cluster
+          attrs.delete :cluster
+          attrs
+        end
+
+        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

@@ -0,0 +1,58 @@
+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: [ :Private, :Internal, :External ]
+
+        def save
+          requires :name
+
+          data = if persisted?
+                   service.set_vm_switch(
+                     computer_name: computer_name,
+                     default_flow_minimum_bandwidth_absolute: default_flow_minimum_bandwidth_absolute,
+                     default_flow_minimum_bandwidth_weight: default_flow_minimum_bandwidth_weight,
+                     name: name,
+                     net_adapter_interface_description: net_adapter_interface_description,
+                     notes: notes,
+                     switch_type: !net_adapter_interface_description && switch_type,
+                     passthru: true,
+                     _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)
+          self
+        end
+
+        def reload
+          data = collection.get(
+            name,
+            computer_name: computer_name
+          )
+          merge_attributes(data.attributes)
+          self
+        end
+      end
+    end
+  end
+end