fog-hyperv 0.0.9 → 0.1.1

data/lib/fog/hyperv/fog_extensions/associations/collection.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Fog::Hyperv::Associations
+  class Collection < Fog::Associations::Default
+    private
+
+    def create_setter; end
+
+    def create_getter; end
+  end
+end

data/lib/fog/hyperv/fog_extensions/attributes/datetime.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Fog::Attributes
+  # Fog attribute type for handling DateTime values from PowerShell
+  class Hypervdatetime < Fog::Attributes::Default
+    private
+
+    # rubocop:disable Style/DocumentDynamicEvalDefinition
+
+    def create_setter
+      # Possible input values are;
+      # /Date(123456789)/ - time since unix epoch in milliseconds
+      # "2026-01-02T10:11:12Z" - DateTime in long-form parsable format
+      model.class_eval <<-SETTER, __FILE__, __LINE__ + 1
+        def #{name}=(new_#{name})
+          new_#{name} = new_#{name}.scan(/Date\\((\\d+)\\)/).flatten.first&.to_i if new_#{name}.include?('Date(')
+
+          if new_#{name}.respond_to?(:to_i)
+            attributes[:#{name}] = Fog::Time.at(new_#{name}.to_i / 1000.0)
+          else
+            attributes[:#{name}] = Fog::Time.parse(new_#{name}.to_s)
+          end
+        end
+      SETTER
+    end
+    # rubocop:enable Style/DocumentDynamicEvalDefinition
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Fog::Attributes
+  # Fog attribute type for handling enums from PowelShell,
+  # where the value might be a number or string depending on the context
+  class Hypervenum < 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 %w[Array Hash].include?(values.class.to_s)
+
+      super
+    end
+
+    private
+
+    # rubocop:disable Style/DocumentDynamicEvalDefinition -- Reporting false positive
+
+    def ensure_value_getter
+      return if model.private_method_defined?(:"#{name}_values")
+
+      model.class_eval <<-VALUE_GETTER, __FILE__, __LINE__ + 1
+        # private
+        # def state_values
+        #   { Unknown: 1, Running: 2 }.freeze
+        # end
+
+        private
+        def #{name}_values
+          #{values}.freeze
+        end
+      VALUE_GETTER
+    end
+
+    def create_setter
+      ensure_value_getter
+
+      # Add a setter that always stores a symbol value
+      model.class_eval <<-SETTER, __FILE__, __LINE__ + 1
+        # def state=(new_value)
+        #   _values = state_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[:state] = _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[:state] = _values.key(new_value)
+        #     end
+        #   elsif new_value.nil?
+        #     attributes[:state] = 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[:state] = new_value
+        #   end
+        # end
+
+        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
+      SETTER
+    end
+
+    def create_getter
+      ensure_value_getter
+
+      # Add a getter for <enum>_num to get the numeric value
+      model.class_eval <<-GETTER_NUM, __FILE__, __LINE__ + 1
+        # def state_num
+        #   _values = state_values
+        #   _value = attributes[:state]
+        #
+        #   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
+
+
+        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
+      GETTER_NUM
+
+      # Add the default getter for the symbol value
+      super
+    end
+    # rubocop:enable Style/DocumentDynamicEvalDefinition
+  end
+end

data/lib/fog/hyperv/fog_extensions/attributes/enumarray.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Fog::Attributes
+  # Fog attribute type for handling arrays of enums from PowerShell,
+  # where each value might be returned as a number or string depending on the context
+  class Hypervenumarray < 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 %w[Array Hash].include?(values.class.to_s)
+
+      super
+    end
+
+    private
+
+    # rubocop:disable Style/DocumentDynamicEvalDefinition -- Reporting false positive
+
+    def ensure_value_getter
+      return if model.private_method_defined?(:"#{name}_values")
+
+      model.class_eval <<-VALUE_GETTER, __FILE__, __LINE__ + 1
+        # private
+        # def state_values
+        #   { Unknown: 1, Running: 2 }.freeze
+        # end
+
+        private
+        def #{name}_values
+          #{values}.freeze
+        end
+      VALUE_GETTER
+    end
+
+    def create_setter
+      ensure_value_getter
+
+      # Add a setter that always stores a symbol value
+      model.class_eval <<-SETTER, __FILE__, __LINE__ + 1
+        # def state=(new_values)
+        #   _values = state_values
+        #   attributes[:state] = []
+        #   new_values.each do |new_value|
+        #     next unless new_value
+        #     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[:state] << _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[:state] << _values.key(new_value)
+        #       end
+        #     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[:state] << new_value
+        #     end
+        #   end
+        # end
+
+        def #{name}=(new_values)
+          _values = #{name}_values
+          new_values = [new_values].flatten unless new_values.is_a? Array
+          attributes[:#{name}] = []
+          new_values.each do |new_value|
+            next unless new_value
+
+            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
+            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
+        end
+      SETTER
+    end
+
+    def create_getter
+      ensure_value_getter
+
+      # Add a getter for <enum>_num to get the numeric value
+      model.class_eval <<-GETTER_NUM, __FILE__, __LINE__ + 1
+        # def state_num
+        #   _values = state_values
+        #   _value = attributes[:state]
+        #
+        #   return nil if _value.nil?
+        #   _value.map do |v|
+        #     if v.is_a?(Numeric)
+        #       v
+        #     else
+        #       if _values.is_a?(Hash)
+        #         _values.send(:[], v)
+        #       else
+        #         _values.index(v)
+        #       end
+        #     end
+        #   end
+        # end
+
+
+        def #{name}_num
+          _values = #{name}_values
+          _value = attributes[:#{name}]
+
+          return nil if _value.nil?
+          _value.map do |v|
+            if v.is_a?(Numeric)
+              v
+            else
+              if _values.is_a?(Hash)
+                _values.send(:[], v)
+              else
+                _values.index(v)
+              end
+            end
+          end
+        end
+      GETTER_NUM
+
+      # Add the default getter for the symbol value
+      super
+    end
+    # rubocop:enable Style/DocumentDynamicEvalDefinition
+  end
+end

data/lib/fog/hyperv/fog_extensions/attributes/timespan.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fog::Attributes
+  # Fog attribute type for handling TimeSpan values from PowerShell
+  class Hypervtimespan < Fog::Attributes::Default
+    private
+
+    # rubocop:disable Style/DocumentDynamicEvalDefinition
+
+    def create_setter
+      # Possible input values are;
+      # 00:00:00 - string-converted TimeSpan
+      # {hours: 0, minutes: 0... total_seconds: 0} - hash containing the TimeSpan data
+      model.class_eval <<-SETTER, __FILE__, __LINE__ + 1
+        def #{name}=(new_#{name})
+          if new_#{name}.is_a?(Hash)
+            attributes[:#{name}] = new_#{name}[:total_seconds]
+          else
+            h, m, s = new_#{name}.split(':').map(&:to_f)
+            attributes[:#{name}] = h * 3600 + m * 60 + s
+          end
+        end
+      SETTER
+    end
+    # rubocop:enable Style/DocumentDynamicEvalDefinition
+  end
+end

data/lib/fog/hyperv/model.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Fog::Hyperv
+  module ModelExtends
+    # Attach a collection of sub-models
+    # @param name [Symbol] the attribute name to store the collection under
+    # @param collection_name [Symbol] the name of the collection on the service
+    # @param options [Hash] the options to create the collection attachment with
+    # @see Fog::Hyperv::Associations::Collection
+    def collection(name, collection_name = nil, options = {}) # rubocop:disable Style/OptionHash -- upstream design
+      collection_name ||= name
+      Fog::Hyperv::Associations::Collection.new(self, name, collection_name, options)
+
+      case to_s
+      when 'Fog::Hyperv::Compute::Server'
+        define_method name do
+          associations[name] ||= service.send(collection_name, vm: self, computer_name: computer_name, vm_id: id)
+        end
+      when 'Fog::Hyperv::Compute::Host'
+        define_method name do
+          associations[name] ||= service.send(collection_name, computer: self, computer_name: computer_name)
+        end
+      else
+        raise "Unknown class #{self}"
+      end
+
+      define_method :"#{name}=" do |data|
+        assoc = associations[name] || send(name)
+        assoc.clear
+        assoc.instance_variable_set :@loaded, true
+        [data].flatten.each do |obj|
+          obj = assoc.new obj if obj.is_a?(Hash)
+          assoc << obj
+        end
+        assoc
+      end
+    end
+  end
+
+  module ModelIncludes
+    # Has the model been modified
+    # @return [Boolean] have any attributes changed since the model was retrieved
+    def dirty?
+      dirty.any?
+    end
+
+    # Get all dirty attributes
+    # @return [Array<Symbol>] all the attributes that have changed since the model was retrieved
+    def dirty
+      potential = attributes.slice(*self.class.attributes)
+      return potential unless old
+
+      potential.reject { |k, v| old.attributes[k] == v }.keys
+    end
+
+    # Get the VM this model is attached to
+    # @return [Fog::Hyperv::Compute::Server,nil] the VM this model is attached to, if any
+    def vm
+      return @vm if @vm
+      return unless respond_to?(:vm_id) && vm_id
+
+      @vm ||= service.servers.get vm_id
+    end
+
+    # Get the Computer this model is attached to
+    # @return [Fog::Hyperv::Compute::Host,nil] the Computer this model is attached to, if any
+    def computer
+      return @computer if @computer
+      return @computer ||= service.hosts.get(computer_name) if respond_to?(:computer_name) && computer_name
+
+      @computer ||= vm&.computer
+    end
+
+    # Get the Cluster this model is part of
+    # @return [Fog::Hyperv::Compute::Cluster,nil] the Cluster this model is part of, if any
+    def cluster
+      return @cluster if @cluster
+      return unless respond_to?(:cluster_name) && cluster_name
+
+      @cluster ||= service.clusters.get cluster_name
+    end
+
+    private
+
+    def logger
+      service.logger
+    end
+
+    # Has any of the listed attributes been modified
+    # @param attrs [Symbol] the attributes to check for modification
+    # @param all [Boolean] check if all listed attributes have changed, instead of any
+    # @return [Boolean] are any/all of the listed attributes modified
+    def changed?(*attrs, all: false)
+      return false unless old
+
+      changed = dirty
+      if all
+        attrs.all? { |attr| changed.include? attr }
+      else
+        attrs.any? { |attr| changed.include? attr }
+      end
+    end
+
+    # Return the modified value of the given attribute - if any
+    # @return [Object,nil] the modified value of the attribute, or nil if it's unmodified
+    def changed!(attr)
+      changed?(attr) ? attributes[attr] : nil
+    end
+
+    # Return the old values of the model - i.e. what's stored in Hyper-V
+    # @return [Object,nil] the old copy of the model, or nil if there's no older version available
+    def old
+      @old ||= (persisted? ? dup.reload : nil)
+    end
+  end
+
+  # A slightly specialized Fog::Model which includes shared Hyper-V functionality
+  class Model < Fog::Model
+    extend Fog::Hyperv::ModelExtends
+    include Fog::Hyperv::ModelIncludes
+
+    def initialize(attributes = {})
+      @vm = attributes.delete :vm
+      self.attributes[:vm] = @vm if self.class.attributes.include? :vm
+      @computer = attributes.delete :computer
+      self.attributes[:computer] = @computer if self.class.attributes.include? :computer
+      @cluster = attributes.delete :cluster
+      self.attributes[:cluster] = @cluster if self.class.attributes.include? :cluster
+
+      super
+
+      @old = dup if persisted?
+    end
+
+    def merge_attributes(attributes = {})
+      super
+
+      @old = dup
+      self
+    end
+  end
+end

data/lib/fog/hyperv/utils/powershell.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Fog::Hyperv::Utils::Powershell
+  # Build a Powershell option map from a set of keyword arguments
+  # @param _optmap_name [String] the name of the option map to generate
+  # @param _ps_version [Integer] the major version of PowerShell to generate the option map for
+  # @param _from_json [Boolean] should the option map be built from JSON data
+  # @param options [Hash] the options to convert into a PowerShell option map
+  def self.build_optmap(_optmap_name: 'FogArgs', _ps_version: 5, _from_json: true, **_options)
+    ps_opts = Fog::Hyperv.camelize(_options)
+    if _from_json
+      if _ps_version >= 6
+        ["$#{_optmap_name} = ConvertFrom-Json -AsHashtable '#{Fog::JSON.encode ps_opts}'"]
+      else
+        [
+          [
+            "$FogJsonObject = '#{Fog::JSON.encode ps_opts}'",
+            '$FogJsonParameters = ConvertFrom-Json -InputObject $FogJsonObject',
+            "$#{_optmap_name} = @{}",
+            "$FogJsonParameters.psobject.properties | Foreach { $#{_optmap_name}[$_.Name] = $_.Value }"
+          ].join('; ')
+        ]
+      end
+    else
+      args = ps_opts.map do |k, v|
+        "'#{k}'=#{Fog::Hyperv.shell_quote(v, always: true)}"
+      end
+
+      ["$#{_optmap_name} = @{#{args.join ';'}}"]
+    end
+  end
+
+  # Build a Powershell cmdlet call
+  # @param cmdlet [String] the PowerShell cmdlet to call
+  # @param args [Hash] the argument to call the cmdlet with
+  # @param _ps_version [Integer] the major version of PowerShell the call is being made for
+  #
+  # @example Running a simple cmdlet
+  #   build_call 'Get-VM', { name: 'example VM' }, _ps_version: 7
+  #   => "$Fogwozmqayrgsyd = ConvertFrom-Json -AsHashtable '{"Name": "example VM"}\nGet-VM @Fogwozmqayrgsyd"
+  def self.build_call(cmdlet, args = {}, _ps_version: 5)
+    return [cmdlet.gsub('@Args', '')].flatten if args.empty?
+
+    id = (cmdlet.hash ^ args.hash).abs.to_s(36)
+    optmap = "Fog#{id}"
+
+    commands = []
+    commands += build_optmap(_optmap_name: optmap, _ps_version: _ps_version, **args)
+    commands << if cmdlet.include? '@Args'
+                  cmdlet.gsub('@Args', "@#{optmap}")
+                else
+                  "#{cmdlet} @#{optmap}"
+                end
+    commands
+  end
+
+  # Convert Ruby data to PowerShell equivalents
+  # @param data [Object] the Ruby data to convert
+  # @param always [Boolean] should the data be included even if the equivalent would be a no-op
+  def self.shell_quote(data, always: false)
+    case data
+    when String
+      if !data.start_with?('$') && (data =~ /(^$)|\s/ || always)
+        data.gsub('`', '``')
+            .gsub(/\0/, '`0')
+            .gsub("\n", '`n')
+            .gsub("\r", '`r')
+            .inspect
+            .gsub('\"', '`"')
+            .gsub('\\\\', '\\')
+      else
+        data
+      end
+    when Hash
+      raise 'Hashes need to be run through build_optmap'
+    when Array
+      "@(#{data.map { |e| shell_quoted(e, always: true) }.join(', ')})"
+    when FalseClass
+      '$false'
+    when TrueClass
+      '$true'
+    when nil
+      '$null'
+    else
+      shell_quoted data.to_s
+    end
+  end
+end