vagrant-vmm 1.0.0

data/lib/vagrant-vmm/action.rb

@@ -0,0 +1,225 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module VMM
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_VMM.message_not_created")
+              next
+            end
+
+            b2.use action_halt
+            b2.use action_start
+          end
+        end
+      end
+
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :not_created do |env1, b1|
+            if env1[:result]
+              b1.use Message, I18n.t("vagrant_VMM.message_not_created")
+              next
+            end
+
+            b1.use Call, DestroyConfirm do |env2, b2|
+              if !env2[:result]
+                b2.use MessageWillNotDestroy
+                next
+              end
+
+              b2.use ConfigValidate
+              b2.use StopInstance
+              b2.use DeleteVM
+            end
+          end
+        end
+      end
+
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_VMM.message_not_created")
+              next
+            end
+
+            b2.use Call, GracefulHalt, :off, :running do |env2, b3|
+              if !env2[:result]
+                b3.use StopInstance
+              end
+            end
+          end
+        end
+      end
+
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_VMM.message_not_created")
+              next
+            end
+
+            b2.use Call, IsState, :running do |env1, b3|
+              if !env1[:result]
+                b3.use Message, I18n.t("vagrant_VMM.message_not_running")
+                next
+              end
+
+
+              b3.use Provision
+              b3.use SyncedFolders
+              b3.use WaitForIPAddress
+              b3.use WaitForCommunicator, [:running]
+            end
+          end
+        end
+      end
+
+      def self.action_resume
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBox
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b1|
+            if env[:result]
+              b1.use Message, I18n.t("vagrant_VMM.message_not_created")
+              next
+            end
+
+            b1.use ResumeVM
+            b1.use WaitForIPAddress
+            b1.use WaitForCommunicator, [:running]
+          end
+        end
+      end
+
+      def self.action_start
+        Vagrant::Action::Builder.new.tap do |b|
+          #
+          b.use Call, IsState, :running do |env1, b1|
+            if env1[:result]
+              b1.use Message, I18n.t("vagrant_VMM.message_already_running")
+              next
+            end
+
+            b1.use Call, IsState, :poweroff do |env2, b2|
+              # if not started
+              if env2[:result]
+                b2.use StartInstance
+                next
+              end
+
+              b2.use Call, IsState, :paused do |env3, b3|
+                # if machine was paused
+                if env3[:result]
+                  b3.use action_resume
+                  next
+                end
+              end
+            end
+          end
+          #
+        end
+      end
+
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env1, b1|
+            if env1[:result]
+              b1.use Import
+            end
+          end
+          b.use action_start
+        end
+      end
+
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ReadState
+        end
+      end
+
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_VMM.message_not_created")
+              next
+            end
+
+            b2.use Call, IsState, :running do |env1, b3|
+              if !env1[:result]
+                b3.use Message, I18n.t("vagrant_VMM.message_not_running")
+                next
+              end
+
+              b3.use SSHExec
+            end
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_VMM.message_not_created")
+              next
+            end
+
+            b2.use Call, IsState, :running do |env1, b3|
+              if !env1[:result]
+                b3.use Message, I18n.t("vagrant_VMM.message_not_running")
+                next
+              end
+
+              b3.use SSHRun
+            end
+          end
+        end
+      end
+
+      def self.action_suspend
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use Message, I18n.t("vagrant_VMM.message_not_created")
+              next
+            end
+
+            b2.use SuspendVM
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :DeleteVM, action_root.join("delete_vm")
+      autoload :Import, action_root.join("import")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :ResumeVM, action_root.join("resume_vm")
+      autoload :StartInstance, action_root.join('start_instance')
+      autoload :StopInstance, action_root.join('stop_instance')
+      autoload :SuspendVM, action_root.join("suspend_vm")
+      autoload :WaitForIPAddress, action_root.join("wait_for_ip_address")
+      autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
+    end
+  end
+end

data/lib/vagrant-vmm/cap/public_address.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module VMM
+    module Cap
+      module PublicAddress
+        def self.public_address(machine)
+          return nil if machine.state.id != :running
+
+          ssh_info = machine.ssh_info
+          return nil if !ssh_info
+          ssh_info[:host]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmm/config.rb

@@ -0,0 +1,44 @@
+require "vagrant"
+
+module VagrantPlugins
+  module VMM
+    class Config < Vagrant.plugin("2", :config)
+      # The timeout to wait for an IP address when booting the machine,
+      # in seconds.
+      #
+      # @return [Integer]
+      attr_accessor :ip_address_timeout
+      # @return [String]
+      attr_accessor :proxy_server_address
+      # @return [String]
+      attr_accessor :vmm_server_address
+      # @return [String]
+      attr_accessor :vm_template_name
+      # @return [String]
+      attr_accessor :vm_host_group_name
+      # @return [String]
+      attr_accessor :vm_address
+
+      def initialize
+        @ip_address_timeout = UNSET_VALUE
+        @proxy_server_address = UNSET_VALUE
+        @vmm_server_address = UNSET_VALUE
+        @vm_template_name   = UNSET_VALUE
+        @vm_host_group_name = UNSET_VALUE
+        @vm_address = UNSET_VALUE
+      end
+
+      def finalize!
+        if @ip_address_timeout == UNSET_VALUE
+          @ip_address_timeout = 60
+        end
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        { "VMM" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-vmm/driver.rb

@@ -0,0 +1,124 @@
+require "json"
+
+require "vagrant/util/powershell"
+
+require_relative "plugin"
+
+module VagrantPlugins
+  module VMM
+    class Driver
+      ERROR_REGEXP  = /===Begin-Error===(.+?)===End-Error===/m
+      OUTPUT_REGEXP = /===Begin-Output===(.+?)===End-Output===/m
+
+      attr_reader :vm_id
+      attr_reader :machine
+
+      def initialize(machine)
+        @machine = machine
+        @vm_id = machine.id
+        @logger = Log4r::Logger.new("vagrant::provider::vmm")
+      end
+
+      def execute(path, options, print_output = false)
+        r = execute_powershell(path, options) { |io_name, data|
+          if print_output && ( io_name == :stderr || io_name == :stdout )
+            if !OUTPUT_REGEXP.match(data) && !ERROR_REGEXP.match(data)
+              if io_name == :stdout
+                machine.ui.output(data)
+              end
+              if io_name == :stderr
+                machine.ui.error(data)
+              end
+            end
+          end
+        }
+        if r.exit_code != 0
+          raise Errors::PowerShellError,
+            script: path,
+            stderr: r.stderr
+        end
+
+        # We only want unix-style line endings within Vagrant
+        r.stdout.gsub!("\r\n", "\n")
+        r.stderr.gsub!("\r\n", "\n")
+
+        error_match  = ERROR_REGEXP.match(r.stdout)
+        output_match = OUTPUT_REGEXP.match(r.stdout)
+
+        if error_match
+          data = JSON.parse(error_match[1])
+
+          # We have some error data.
+          raise Errors::PowerShellError,
+            script: path,
+            stderr: data["error"]
+        end
+
+        # Nothing
+        return nil if !output_match
+        return JSON.parse(output_match[1])
+      end
+
+      def get_current_state(options)
+        options['vm_id'] = vm_id
+        execute('get_vm_status.ps1', options)
+      end
+
+       def delete_vm(options)
+         options['vm_id'] = vm_id
+         execute('delete_vm.ps1', options)
+       end
+
+       def read_guest_ip(options)
+         options['vm_id'] = vm_id
+         execute('get_network_config.ps1', options, true)
+       end
+
+       def resume(options)
+         options['vm_id'] = vm_id
+         execute('resume_vm.ps1', options)
+       end
+
+       def start(options)
+         options['vm_id'] = vm_id
+         execute('start_vm.ps1', options)
+       end
+
+       def stop(options)
+         options['vm_id'] = vm_id
+         execute('stop_vm.ps1', options)
+       end
+
+       def suspend(options)
+         options['vm_id'] = vm_id
+         execute("suspend_vm.ps1", options)
+       end
+
+       def import(options)
+         execute('import_vm.ps1', options)
+       end
+
+       def sync_folders(options)
+         execute('sync_folders.ps1', options, true)
+       end
+
+      protected
+
+      def execute_powershell(path, options, &block)
+        lib_path = Pathname.new(File.expand_path("../scripts", __FILE__))
+        path = lib_path.join(path).to_s.gsub("/", "\\")
+        options = options || {}
+        ps_options = []
+        options.each do |key, value|
+          ps_options << "-#{key}"
+          ps_options << "'#{value}'"
+        end
+
+        # Always have a stop error action for failures
+        ps_options << "-ErrorAction" << "Stop"
+        opts = { notify: [:stdout, :stderr, :stdin] }
+        Vagrant::Util::PowerShell.execute(path, *ps_options, **opts, &block)
+      end
+    end
+  end
+end

data/lib/vagrant-vmm/errors.rb

@@ -0,0 +1,42 @@
+module VagrantPlugins
+  module VMM
+    module Errors
+      # A convenient superclass for all our errors.
+      class VMMError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_VMM.errors")
+      end
+
+      class AdminRequired < VMMError
+        error_key(:admin_required)
+      end
+
+      class BoxInvalid < VMMError
+        error_key(:box_invalid)
+      end
+
+      class IPAddrTimeout < VMMError
+        error_key(:ip_addr_timeout)
+      end
+
+      class NoSwitches < VMMError
+        error_key(:no_switches)
+      end
+
+      class PowerShellFeaturesDisabled < VMMError
+        error_key(:powershell_features_disabled)
+      end
+
+      class PowerShellError < VMMError
+        error_key(:powershell_error)
+      end
+
+      class PowerShellRequired < VMMError
+        error_key(:powershell_required)
+      end
+
+      class WindowsRequired < VMMError
+        error_key(:windows_required)
+      end
+    end
+  end
+end

data/lib/vagrant-vmm/plugin.rb

@@ -0,0 +1,46 @@
+module VagrantPlugins
+  module VMM
+    autoload :Action, File.expand_path("../action", __FILE__)
+    autoload :Errors, File.expand_path("../errors", __FILE__)
+
+    class Plugin < Vagrant.plugin("2")
+      name "VMM provider"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in Virtual Machine Manager.
+      DESC
+
+      provider(:vmm, box_optional: true, priority: 4) do
+        require_relative "provider"
+        init!
+        Provider
+      end
+
+      config(:vmm, :provider) do
+        require_relative "config"
+        init!
+        Config
+      end
+
+      provider_capability("VMM", "public_address") do
+        require_relative "cap/public_address"
+        Cap::PublicAddress
+      end
+
+      synced_folder(:vmm) do
+        require_relative 'synced_folder'
+        SyncedFolder
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path(
+          "locales/en.yml", VMM.source_root)
+        I18n.reload!
+        @_init = true
+      end
+    end
+  end
+end

data/lib/vagrant-vmm/provider.rb

@@ -0,0 +1,103 @@
+require "log4r"
+
+require_relative "driver"
+require_relative "plugin"
+
+require "vagrant/util/platform"
+require "vagrant/util/powershell"
+
+module VagrantPlugins
+  module VMM
+    class Provider < Vagrant.plugin("2", :provider)
+      attr_reader :driver
+
+      def self.usable?(raise_error=false)
+        if !Vagrant::Util::Platform.windows?
+          raise Errors::WindowsRequired
+          return false
+        end
+
+        if !Vagrant::Util::Platform.windows_admin?
+          raise Errors::AdminRequired
+        end
+
+        if !Vagrant::Util::PowerShell.available?
+          raise Errors::PowerShellRequired
+          return false
+        end
+
+        true
+      end
+
+      def initialize(machine)
+        @machine = machine
+        @state_id = nil
+        # This method will load in our driver, so we call it now to
+        # initialize it.
+        machine_id_changed
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def machine_id_changed
+        @driver = Driver.new(@machine)
+      end
+
+      def current_state
+        @state_id
+      end
+
+      def reset_state
+        @state_id = nil
+      end
+
+      def state
+        @state_id = :not_created if !@machine.id
+
+        if !@state_id || @state_id == :not_created
+          env = @machine.action(:read_state)
+          @state_id = env[:machine_state_id]
+        end
+
+        # Get the short and long description
+        short = @state_id.to_s
+        long  = ""
+
+        # If we're not created, then specify the special ID flag
+        if @state_id == :not_created
+          @state_id = Vagrant::MachineState::NOT_CREATED_ID
+        end
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(@state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "VMM (#{id})"
+      end
+
+      def ssh_info
+        # We can only SSH into a running machine
+        return nil if state.id != :running
+        address = @machine.provider_config.vm_address || @machine.config.winrm.host
+        if !address
+          #TODO: call wait_for_ip_address
+          return nil
+        end
+
+        {
+          host: address,
+          port: 22,
+        }
+      end
+    end
+  end
+end

data/lib/vagrant-vmm/scripts/delete_vm.ps1

@@ -0,0 +1,32 @@
+Param(
+  [Parameter(Mandatory=$true)]
+  [string]$vm_id,
+  [Parameter(Mandatory=$true)]
+  [string]$vmm_server_address,
+  [string]$proxy_server_address=$null
+)
+
+
+# Include the following modules
+$Dir = Split-Path $script:MyInvocation.MyCommand.Path
+. ([System.IO.Path]::Combine($Dir, "utils\write_messages.ps1"))
+. ([System.IO.Path]::Combine($Dir, "utils\vmm_executor.ps1"))
+
+
+$script_block = {
+  # external vars
+  $vm_id  = $using:vm_id
+
+  # Get VM
+  $vm = Get-SCVirtualMachine -ID $vm_id -ErrorAction Ignore
+  if ( $vm )
+  {
+    if ( $vm.status -eq 'Running' )
+    {
+      Stop-VM $vm
+    }
+    Remove-VM $vm
+  }
+}
+
+execute $script_block $vmm_server_address $proxy_server_address