fog-hyperv 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f4fc7f6bb6e4beb182866dc8c274d15c25dbbdd
+  data.tar.gz: da491628457575effecb17779afa392f0d02276b
+SHA512:
+  metadata.gz: 9bcc6fa50ef5d9d3ab0eef2fdb56937090186df326016c93e36d6a606defb257d52f3e66df9ded5512eddcebd996cf118fd84fb50437ea084dde3ec91b1270c7
+  data.tar.gz: 003df173d2ab645056e6eeac5feea8b6cc987fabd1b80d65867684f395f84f36799e645da1b76c8286c7065510cdaae6b5c6aba99c7d45721544e72656deceeb

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/

data/.travis.yml

@@ -0,0 +1,11 @@
+---
+before_install: gem install bundler
+language: ruby
+notifications:
+  email: false
+rvm:
+  - 2.0.0
+  - 2.1.9
+  - 2.2.6
+  - 2.4.0
+sudo: false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fog-hyperv.gemspec
+gemspec

data/README.md

@@ -0,0 +1,53 @@
+# Fog Hyper-V
+
+[![Build Status](https://travis-ci.org/ace13/fog-hyperv.svg?branch=master)](https://travis-ci.org/ace13/fog-hyperv)
+
+Manage your Hyper-V instance with the help of the Fog cloud service abstractions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fog-hyperv'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fog-hyperv
+
+## Usage
+
+To remotely manage your Hyper-V instance;
+
+```ruby
+require 'fog/hyperv'
+
+compute = Fog::Compute.new(
+  provider: :hyperv,
+  hyperv_host: 'hyperv.example.com',
+  hyperv_username: 'domain\\user',
+  hyperv_password: 'password'
+)
+
+compute.servers.all
+#=> [<Fog::Compute::Hyperv::Server
+#=>   id='',
+#=>   name='example',
+#=>   computer_name='HYPERV',
+#=>   dynamic_memory_enabled=false,
+#=>   ...
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests. You can also run `bundle exec irb` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ace13/fog-hyperv.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/fog-hyperv.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fog/hyperv/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fog-hyperv'
+  spec.version       = Fog::Hyperv::VERSION
+  spec.authors       = ['Alexander Olofsson']
+  spec.email         = ['alexander.olofsson@liu.se']
+
+  spec.summary       = 'Module for the `fog` gem to support Microsoft Hyper-V.'
+  spec.description   = 'This library wraps Hyper-V in the `fog` concepts.'
+  spec.homepage      = 'https://github.com/ace13/fog-hyperv'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^test\/})
+
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'fog-core', '~> 1.44'
+  spec.add_runtime_dependency 'fog-json', '~> 1.0'
+  spec.add_runtime_dependency 'winrm', '~> 2.2'
+
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+end

data/lib/fog/bin/hyperv.rb

@@ -0,0 +1,28 @@
+class Hyperv < Fog::Bin
+  class << self
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Hyperv
+      else
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |h, k|
+        h[k] = case key
+               when :compute
+                 Fog::Compute.new(provider: 'Hyperv')
+               else
+                 raise ArgumentError, "Unrecognized service: #{key.inspect}"
+               end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Hyperv.services
+    end
+  end
+end

data/lib/fog/collection.rb

@@ -0,0 +1,114 @@
+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 search_attributes
+        attributes.dup.merge(
+          _return_fields: model.attributes - model.lazy_attributes,
+          _json_depth: 1
+        )
+      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 = self.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(search_attributes.merge(options))
+      end
+
+      def create(attributes = {})
+        object = new(attributes)
+        object.save
+        object
+      end
+
+      private
+
+      def method
+        self.class.get_method
+      end
+    end
+
+    class ComputerCollection < Fog::Hyperv::Collection
+      def self.requires_computer
+        requires? << :computer
+      end
+
+      attr_accessor :computer
+
+      def search_attributes
+        attrs = super
+        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 search_attributes
+        attrs = super
+        if vm
+          attrs[:computer_name] ||= vm.computer_name
+          attrs[match] = vm.send(match)
+        end
+        attrs
+      end
+
+      def create(attributes = {})
+        object = new(attributes)
+        # 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.save
+        object
+      end
+
+      def inspect
+        # To avoid recursing on VM
+        to_s
+      end
+
+      private
+
+      def logger
+        service.logger
+      end
+
+      def match
+        self.class.match_on || :vm_name
+      end
+    end
+  end
+end

data/lib/fog/hyperv.rb

@@ -0,0 +1,123 @@
+require 'fog/core'
+
+module Fog
+  module Attributes
+    autoload :Enum, File.expand_path('../hyperv/fog_extensions/enum.rb', __FILE__)
+  end
+
+  module Compute
+    autoload :Hyperv, File.expand_path('../hyperv/compute', __FILE__)
+  end
+
+  module Hyperv
+    extend Fog::Provider
+
+    module Errors
+      class ServiceError < Fog::Errors::Error; end
+      class VersionError < ServiceError
+        attr_reader :version, :required_version, :function
+
+        def initialize(required_version, version, function)
+          @function = function
+          @required_version = required_version
+          @version = version
+
+          super "#{function} requires at least Hyper-V v#{required_version}, you have v#{version}"
+        end
+      end
+
+      class PSError < ServiceError
+        attr_reader :stdout, :stderr, :exitcode, :info, :message
+
+        def initialize(output, info)
+          @stdout = output.stdout
+          @stderr = output.stderr
+          @exitcode = output.exitcode
+          @info = info
+          @message = @stderr.split("\n").first
+          super @message
+        end
+
+        def to_s
+          ret = [super]
+          ret << info unless info.nil? || info.empty?
+          ret.join "\n"
+        end
+      end
+    end
+
+    autoload :Collection, File.expand_path('../collection', __FILE__)
+    autoload :Model, File.expand_path('../model', __FILE__)
+    autoload :ModelExtends, File.expand_path('../model', __FILE__)
+    autoload :ModelIncludes, File.expand_path('../model', __FILE__)
+    autoload :VMCollection, File.expand_path('../collection', __FILE__)
+
+    service(:compute, 'Compute')
+
+    def self.shell_quoted(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(/\\\\/, '\\')
+        else
+          data
+        end
+      when Array
+        '@(' + data.map { |e| shell_quoted(e, true) }.join(', ') + ')'
+      when FalseClass
+        '$false'
+      when TrueClass
+        '$true'
+      else
+        shell_quoted data.to_s
+      end
+    end
+
+    def self.camelize(data)
+      case data
+      when Array
+        data.collect { |d| camelize(d) }
+      when Hash
+        data.each_with_object({}) do |(k, v), hash|
+          value = v
+          value = camelize(v) if v.is_a?(Hash) || (v.is_a?(Array) && v.all? { |h| h.is_a?(Hash) })
+          hash[camelize(k)] = value
+        end
+      when Symbol
+        camelize(data.to_s).to_sym
+      when String
+        data.split('_').collect(&:capitalize).join
+      else
+        data
+      end
+    end
+
+    def self.uncamelize(data)
+      case data
+      when Array
+        data.collect { |d| uncamelize(d) }
+      when Hash
+        data.each_with_object({}) do |(k, v), hash|
+          value = v
+          value = uncamelize(v) if v.is_a?(Hash) || (v.is_a?(Array) && v.all? { |h| h.is_a?(Hash) })
+          hash[uncamelize(k)] = value
+        end
+      when Symbol
+        uncamelize(data.to_s).to_sym
+      when String
+        data.to_s
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase.to_sym
+      else
+        data
+      end
+    end
+  end
+end

data/lib/fog/hyperv/compute.rb

@@ -0,0 +1,327 @@
+module Fog
+  module Compute
+    class Hyperv < Fog::Service
+      STATUS_ENUM_VALUES = [
+        :Unknown,              # 0
+        :Other,                # 1
+        :Ok,                   # 2
+        :Degraded,             # 3
+        :Stressed,             # 4
+        :PredictiveFailure,    # 5
+        :Error,                # 6
+        :NonRecoverableError,  # 7
+        :Starting,             # 8
+        :Stopping,             # 9
+        :Stopped,              # 10
+        :InService,            # 11
+        :NoContact,            # 12
+        :LostCommunication,    # 13
+        :Aborted,              # 14
+        :Dormant,              # 15
+        :SupportingEntity,     # 16
+        :Completed,            # 17
+        :PowerMode             # 18
+        # :ProtocolVersion     # 32775
+      ].freeze
+
+      requires :hyperv_username, :hyperv_password
+      recognizes :hyperv_endpoint, :hyperv_host,
+                 :hyperv_transport,
+                 :hyperv_debug
+      secrets :hyperv_password, :connection
+
+      model_path 'fog/hyperv/models/compute'
+      model :bios
+      model :cluster
+      collection :clusters
+      model :com_port
+      model :dvd_drive
+      collection :dvd_drives
+      model :firmware
+      model :floppy_drive
+      collection :floppy_drives
+      model :hard_drive
+      collection :hard_drives
+      model :host
+      collection :hosts
+      model :network_adapter
+      collection :network_adapters
+      model :server
+      collection :servers
+      model :switch
+      collection :switches
+      model :vhd
+      collection :vhds
+
+      request_path 'fog/hyperv/requests/compute'
+      request :add_vm_hard_disk_drive
+      request :add_vm_network_adapter
+      request :connect_vm_network_adapter
+      request :disconnect_vm_network_adapter
+      request :get_cluster
+      request :get_cluster_node
+      request :get_vhd
+      request :get_vm
+      request :get_vm_bios
+      request :get_vm_dvd_drive
+      request :get_vm_firmware
+      request :get_vm_floppy_disk_drive
+      request :get_vm_group
+      request :get_vm_hard_disk_drive
+      request :get_vm_host
+      request :get_vm_host_cluster
+      request :get_vm_network_adapter
+      request :get_vm_switch
+      request :new_vhd
+      request :new_vm
+      request :new_vm_switch
+      request :remove_item
+      request :remove_vm
+      request :remove_vm_hard_disk_drive
+      request :remove_vm_network_adapter
+      request :restart_vm
+      request :set_vm
+      request :set_vm_bios
+      request :set_vm_dvd_drive
+      request :set_vm_hard_disk_drive
+      request :set_vm_firmware
+      request :set_vm_network_adapter
+      request :set_vm_switch
+      request :start_vm
+      request :stop_vm
+
+      class Shared
+        def version
+          '0.0'
+        end
+
+        protected
+
+        def requires(opts, *args)
+          missing = args - opts.keys
+          return if missing.none?
+
+          method = caller[0][/`.*'/][1..-2]
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for #{method}")
+          elsif missing.any?
+            raise(ArgumentError, "#{missing[0...-1].join(', ')}, and #{missing[-1]} are required for #{method}")
+          end
+        end
+
+        def requires_one(opts, *args)
+          missing = args - opts.keys
+          return if missing.length < args.length
+
+          method = caller[0][/`.*'/][1..-2]
+          raise(ArgumentError, "#{missing[0...-1].join(', ')}, or #{missing[-1]} are required for #{method}")
+        end
+
+        def requires_version(required_version)
+          method = caller[0][/`.*'/][1..-2].split('_')
+          method = method[0].capitalize + "-" + Fog::Hyperv.camelize(method[1..-1].join('_'))
+
+          raise Fog::Hyperv::Errors::VersionError.new(required_version, version, method) \
+            unless Gem::Version.new(version) >= Gem::Version.new(required_version)
+        end
+
+      end
+
+      class Real < Shared
+        attr_reader :logger
+
+        def initialize(options = {})
+          # require 'ostruct'
+          require 'fog/json'
+          require 'logging'
+
+          @hyperv_endpoint  = options[:hyperv_endpoint]
+          @hyperv_endpoint  = "http://#{options[:hyperv_host]}:5985/wsman" if !@hyperv_endpoint && options[:hyperv_host]
+          @hyperv_username  = options[:hyperv_username]
+          @hyperv_password  = options[:hyperv_password]
+          @hyperv_transport = options[:hyperv_transport] || :negotiate
+          @logger = Logging.logger['hyper-v']
+          if options[:hyperv_debug]
+            logger.level = :debug 
+            logger.add_appenders Logging.appenders.stdout
+          end
+
+          connect
+        end
+
+        def local?
+          false # @hyperv_endpoint.nil?
+        end
+
+        def valid?
+          if local?
+            run_shell('Get-VMHost', _return_fields: :name) && true
+          else
+            run_wql('SELECT Name FROM Msvm_ComputerSystem WHERE Caption = "Hosting Computer System"') && true
+          end
+        rescue Fog::Hyperv::Errors::ServiceError
+          false
+        end
+
+        def version
+          @version ||= run_wql('SELECT Version FROM Win32_OperatingSystem', _namespace: 'root/cimv2/*')[:xml_fragment].first[:version] rescue \
+            run_shell("$VMMS = if ([environment]::Is64BitProcess) { \"$($env:SystemRoot)\\System32\\vmms.exe\" } else { \"$($env:SystemRoot)\\Sysnative\\vmms.exe\" }\n(Get-Item $VMMS).VersionInfo.ProductVersion", _skip_json: true).stdout.strip
+        end
+
+        private
+
+        def hash_to_optmap(options = {})
+          args = options.reject { |k, v| v.nil? || v.is_a?(FalseClass) || k.to_s.start_with?('_') }.map do |k, v|
+            "'#{k}'=#{Fog::Hyperv.shell_quoted(v, true)}"
+          end
+          "@{#{args.join ';'}}"
+        end
+
+        def run_shell_with_vm(command, vm_options, options = {})
+          # $VM = Get-VM @vm_options
+          # $Result = <command> @options
+          # $Result | select <return_fields> | ConvertTo-Json
+        end
+
+        def run_wql(query, options = {})
+          skip_camelize = options.delete :_skip_camelize
+          namespace = options.delete(:_namespace) || 'root/virtualization/v2/*'
+
+          options = Fog::Hyperv.camelize(options) unless skip_camelize
+          args = options.reject { |k, v| v.nil? || v.is_a?(FalseClass) || k.to_s.start_with?('_') }.map do |k, v|
+            "#{k} = #{(v.is_a?(String) || v.to_s =~ /\s/) && v.inspect || v}"
+          end
+
+          query = "#{query}#{" WHERE #{args.join ' AND '}" unless args.none?}"
+          data = \
+            if local?
+              # TODO
+            else
+              logger.debug "WQL; #{namespace} >>> #{query}"
+              @connection.run_wql(query, namespace)
+            end
+
+          logger.debug "WQL; <<< #{data}"
+          data
+        end
+
+        def run_shell(command, options = {})
+          return_fields = options.delete :_return_fields
+          return_fields = "| select #{Fog::Hyperv.camelize([return_fields].flatten).join ','}" if return_fields
+          suffix = options.delete :_suffix
+          json_depth = options.delete :_json_depth
+          skip_json = options.delete :_skip_json
+          skip_camelize = options.delete :_skip_camelize
+          skip_uncamelize = options.delete :_skip_uncamelize
+          options = Fog::Hyperv.camelize(options) unless skip_camelize
+
+          # commandline = "$Args = #{hash_to_optmap options}\n$Ret = #{command} @Args#{"\n$Ret #{return_fields} | ConvertTo-Json -Compress #{"-Depth #{json_depth}" if json_depth}" unless skip_json}"
+          # puts " > #{commandline.split("\n").join "\n > "}" if @hyperv_debug
+          args = options.reject { |k, v| v.nil? || v.is_a?(FalseClass) || k.to_s.start_with?('_') || (v.is_a?(String) && v.empty?) }.map do |k, v|
+            "-#{k} #{Fog::Hyperv.shell_quoted v unless v.is_a?(TrueClass)}"
+          end
+          command_args = "#{command} #{args.join ' ' unless args.empty?}"
+          commandline = "#{command_args} #{suffix} #{return_fields} #{"| ConvertTo-Json -Compress #{"-Depth #{json_depth}" if json_depth}" unless skip_json}"
+          logger.debug "PS; >>> #{commandline}"
+
+          out = nil # OpenStruct.new stdout: '',
+          #                          stderr: '',
+          #                          exitcode: -1
+
+          if local?
+            commanddata = [
+              'powershell',
+              '-NoLogo',
+              '-NoProfile',
+              '-NonInteractive',
+              commandline
+            ]
+            begin
+              out.stdout, out.stderr, out.exitcode = Open3.capture3(*commanddata)
+              out.exitcode = out.exitcode.exitstatus
+            rescue StandardError => ex
+              out.stderr = ex.inspect
+              out.exitcode = -1
+            end
+          else
+            @connection.shell(:powershell) do |shell|
+              out = shell.run(commandline)
+            end
+          end
+
+          # TODO: Map error codes in some manner?
+          raise Fog::Hyperv::Errors::ServiceError, "Failed to execute #{commandline}" unless out
+          raise Fog::Hyperv::Errors::PSError.new(out, "When executing #{command_args}") unless out.exitcode.zero?
+
+          logger.debug "PS; <<< OUT=[#{out.stdout.inspect}] ERR=[#{out.stderr.inspect}] EXIT=[#{out.exitcode}]"
+
+          if skip_json
+            out
+          else
+            return nil if out.stdout.empty?
+            json = Fog::JSON.decode(out.stdout)
+            json = Fog::Hyperv.uncamelize(json) unless skip_uncamelize
+            json
+          end
+        end
+
+        def connect
+          # return require 'open3' if local?
+
+          require 'winrm'
+          @connection = WinRM::Connection.new(
+            endpoint:  @hyperv_endpoint,
+            user:      @hyperv_username,
+            password:  @hyperv_password,
+            transport: @hyperv_transport
+          )
+          Logging.logger['WinRM::HTTP::HttpNegotiate'].level = :error
+          @connection.logger.level = :error
+        end
+      end
+
+      class Mock < Shared
+        def initialize(_options = {})
+          require 'fog/json'
+        end
+
+        def method_missing(method, *args)
+          if requests.find { |_, k| k == method }
+            handle_mock_response((args.first || {}).merge(_method: method))
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          requests.find { |_, k| k == method } || super
+        end
+
+        def self.method_defined?(method)
+          Fog::Compute::Hyperv.requests.find { |_, k| k == method } || super
+        end
+
+        private
+
+        def handle_mock_response(args = {})
+          method =   args.delete :_method
+          method ||= caller[0][/`.*'/][1..-2]
+          method ||= caller[1][/`.*'/][1..-2]
+
+          path = File.join File.dirname(__FILE__), 'requests', 'compute', 'mock_files', "#{method}.json"
+          Fog::Mock.not_implemented unless File.exist? path
+          raise Fog::Errors::MockNotImplemented, 'Not implementing skipping of json' if args[:_skip_json]
+          raise Fog::Errors::MockNotImplemented, 'Not implementing skipping of uncamelize' if args[:_skip_uncamelize]
+
+          ret = Fog::JSON.decode(open(path).read)
+          ret = Fog::Hyperv.uncamelize(ret)
+
+          ret = ret.map do |obj|
+            obj.select { |k, _| args[:_return_fields].include? k }
+          end if args[:_return_fields]
+          ret
+        end
+      end
+    end
+  end
+end