fog-hyperv 0.0.9 → 0.1.1

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

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

@@ -1,101 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Vhd < Fog::Hyperv::Model
-        identity :disk_identifier
-
-        attribute :attached
-        attribute :block_size
-        attribute :computer_name
-        attribute :disk
-        attribute :file_size
-        attribute :is_deleted
-        attribute :minimum_size
-        attribute :path, type: :string, default: 'New Disk'
-        attribute :pool_name
-        attribute :size, type: :integer, default: 343_597_383_68
-        attribute :vhd_format, type: :enum, values: [:Unknown, nil, :VHD, :VHDX, :VHDSet]
-        attribute :vhd_type, type: :enum, values: [:Unknown, nil, :Fixed, :Dynamic, :Differencing]
-        # TODO? VM Snapshots?
-        #
-
-        # def identity_name
-        #   :disk_identifier unless disk_identifier
-        #   :disk_number if disk
-        #   :path
-        # end
-
-        def real_path
-          requires :path, :computer_name
-
-          ret = path
-          ret += '.vhdx' unless ret.downcase.end_with? '.vhdx'
-          ret = host.virtual_hard_disk_path + '\\' + ret unless ret.downcase.start_with? host.virtual_hard_disk_path.downcase
-          ret
-        end
-
-        def unc_path
-          "\\\\#{computer_name || '.'}\\#{real_path.tr ':', '$'}"
-        end
-
-        def host
-          requires :computer_name
-
-          @host ||= begin
-            ret = parent
-            ret = service.hosts.get computer_name unless ret
-            ret = ret.parent unless ret.is_a?(Host)
-            ret
-          end
-        end
-
-        def save
-          requires :path, :computer_name, :size
-
-          data = \
-            if persisted?
-              # Can't change much of a VHD
-              attributes
-            else
-              service.new_vhd(
-                computer_name: computer_name,
-                path: real_path,
-
-                block_size_bytes: block_size,
-                size_bytes: size,
-
-                _return_fields: self.class.attributes,
-                _json_depth: 1
-              )
-            end
-
-          merge_attributes(data)
-          @old = dup
-          self
-        end
-
-        def reload
-          requires :computer_name
-          requires_one :path, :disk
-
-          data = service.get_vhd(
-            computer_name: computer_name,
-            path: path,
-            disk_number: disk
-          )
-          merge_attributes(data.attributes)
-          @old = data
-          self
-        end
-
-        def destroy
-          requires :path, :disk_identifier
-
-          service.remove_item(
-            path: unc_path
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Vhds < Fog::Hyperv::VMCollection
-        model Fog::Compute::Hyperv::Vhd
-        match_on :vm_id
-
-        get_method :get_vhd
-
-        def get(path, filters = {})
-          super search_attributes.merge(filters.merge(path: path))
-        end
-      end
-    end
-  end
-end

data/lib/fog/hyperv/requests/compute/add_vm_dvd_drive.rb

@@ -1,12 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Real
-        def add_vm_dvd_disk_drive(options = {})
-          requires options, :vm_name
-          run_shell('Add-VMDvdDrive', options)
-        end
-      end
-    end
-  end
-end

data/lib/fog/hyperv/requests/compute/add_vm_hard_disk_drive.rb

@@ -1,12 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Real
-        def add_vm_hard_disk_drive(options = {})
-          requires options, :vm_name
-          run_shell('Add-VMHardDiskDrive', options)
-        end
-      end
-    end
-  end
-end

data/lib/fog/hyperv/requests/compute/add_vm_network_adapter.rb

@@ -1,12 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Real
-        def add_vm_network_adapter(options = {})
-          requires_one options, :vm_name, :management_os
-          run_shell('Add-VMNetworkAdapter', options.merge(_always_include: [:is_legacy]))
-        end
-      end
-    end
-  end
-end

data/lib/fog/hyperv/requests/compute/connect_vm_network_adapter.rb

@@ -1,12 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Real
-        def connect_vm_network_adapter(options = {})
-          requires options, :vm_name, :switch_name
-          run_shell('Connect-VMNetworkAdapter', options.merge(_skip_json: true)).exitcode.zero?
-        end
-      end
-    end
-  end
-end

data/lib/fog/hyperv/requests/compute/disconnect_vm_network_adapter.rb

@@ -1,12 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Real
-        def disconnect_vm_network_adapter(options = {})
-          requires :vm_name
-          run_shell('Disconnect-VMNetworkAdapter', options.merge(_skip_json: true)).exitcode.zero?
-        end
-      end
-    end
-  end
-end

data/lib/fog/hyperv/requests/compute/get_cluster.rb

@@ -1,11 +0,0 @@
-module Fog
-  module Compute
-    class Hyperv
-      class Real
-        def get_cluster(options = {})
-          run_shell('Get-Cluster', options)
-        end
-      end
-    end
-  end
-end