vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/driver.rb

@@ -1,249 +0,0 @@
-require "json"
-
-require "vagrant/util/powershell"
-
-require_relative "plugin"
-
-module VagrantPlugins
-  module HyperV
-    class Driver
-      ERROR_REGEXP  = /===Begin-Error===(.+?)===End-Error===/m
-      OUTPUT_REGEXP = /===Begin-Output===(.+?)===End-Output===/m
-
-      # Name mapping for integration services for nicer keys
-      INTEGRATION_SERVICES_MAP = {
-        guest_service_interface: "Guest Service Interface",
-        heartbeat: "Heartbeat",
-        key_value_pair_exchange: "Key-Value Pair Exchange",
-        shutdown: "Shutdown",
-        time_synchronization: "Time Synchronization",
-        vss: "VSS",
-      }
-
-      # @return [String] VM ID
-      attr_reader :vm_id
-
-      def initialize(id)
-        @vm_id = id
-      end
-
-      # @return [Boolean] Supports VMCX
-      def has_vmcx_support?
-        !!execute(:has_vmcx_support)["result"]
-      end
-
-      # Execute a PowerShell command and process the results
-      #
-      # @param [String] path Path to PowerShell script
-      # @param [Hash] options Options to pass to command
-      #
-      # @return [Object, nil] If the command returned JSON content
-      #                       it will be parsed and returned, otherwise
-      #                       nil will be returned
-      def execute(path, options={})
-        if path.is_a?(Symbol)
-          path = "#{path}.ps1"
-        end
-        r = execute_powershell(path, options)
-
-        # 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
-
-        if r.exit_code != 0
-          raise Errors::PowerShellError,
-            script: path,
-            stderr: r.stderr
-        end
-
-        # Nothing
-        return nil if !output_match
-        return JSON.parse(output_match[1])
-      end
-
-      # Fetch current state of the VM
-      #
-      # @return [Hash<state, status>]
-      def get_current_state
-        execute(:get_vm_status, VmId: vm_id)
-      end
-
-      # Delete the VM
-      #
-      # @return [nil]
-      def delete_vm
-        execute(:delete_vm, VmId: vm_id)
-      end
-
-      # Export the VM to the given path
-      #
-      # @param [String] path Path for export
-      # @return [nil]
-      def export(path)
-        execute(:export_vm, VmId: vm_id, Path: path)
-      end
-
-      # Get the IP address of the VM
-      #
-      # @return [Hash<ip>]
-      def read_guest_ip
-        execute(:get_network_config, VmId: vm_id)
-      end
-
-      # Get the MAC address of the VM
-      #
-      # @return [Hash<mac>]
-      def read_mac_address
-        execute(:get_network_mac, VmId: vm_id)
-      end
-
-      # Resume the VM from suspension
-      #
-      # @return [nil]
-      def resume
-        execute(:resume_vm, VmId: vm_id)
-      end
-
-      # Start the VM
-      #
-      # @return [nil]
-      def start
-        execute(:start_vm, VmId: vm_id )
-      end
-
-      # Stop the VM
-      #
-      # @return [nil]
-      def stop
-        execute(:stop_vm, VmId: vm_id)
-      end
-
-      # Suspend the VM
-      #
-      # @return [nil]
-      def suspend
-        execute(:suspend_vm, VmId: vm_id)
-      end
-
-      # Import a new VM
-      #
-      # @param [Hash] options Configuration options
-      # @return [Hash<id>] New VM ID
-      def import(options)
-        execute(:import_vm, options)
-      end
-
-      # Set the VLAN ID
-      #
-      # @param [String] vlan_id VLAN ID
-      # @return [nil]
-      def net_set_vlan(vlan_id)
-        execute(:set_network_vlan, VmId: vm_id, VlanId: vlan_id)
-      end
-
-      # Set the VM adapter MAC address
-      #
-      # @param [String] mac_addr MAC address
-      # @return [nil]
-      def net_set_mac(mac_addr)
-        execute(:set_network_mac, VmId: vm_id, Mac: mac_addr)
-      end
-
-      # Create a new snapshot with the given name
-      #
-      # @param [String] snapshot_name Name of the new snapshot
-      # @return [nil]
-      def create_snapshot(snapshot_name)
-        execute(:create_snapshot, VmId: vm_id, SnapName: snapshot_name)
-      end
-
-      # Restore the given snapshot
-      #
-      # @param [String] snapshot_name Name of snapshot to restore
-      # @return [nil]
-      def restore_snapshot(snapshot_name)
-        execute(:restore_snapshot, VmId: vm_id,  SnapName: snapshot_name)
-      end
-
-      # Get list of current snapshots
-      #
-      # @return [Array<String>] snapshot names
-      def list_snapshots
-        snaps = execute(:list_snapshots, VmID: vm_id)
-        snaps.map { |s| s['Name'] }
-      end
-
-      # Delete snapshot with the given name
-      #
-      # @param [String] snapshot_name Name of snapshot to delete
-      # @return [nil]
-      def delete_snapshot(snapshot_name)
-        execute(:delete_snapshot, VmID: vm_id, SnapName: snapshot_name)
-      end
-
-      # Enable or disable VM integration services
-      #
-      # @param [Hash] config Integration services to enable or disable
-      # @return [nil]
-      # @note Keys in the config hash will be remapped if found in the
-      #       INTEGRATION_SERVICES_MAP. If they are not, the name will
-      #       be passed directly. This allows new integration services
-      #       to configurable even if Vagrant is not aware of them.
-      def set_vm_integration_services(config)
-        config.each_pair do |srv_name, srv_enable|
-          args = {VMID: vm_id, Name: INTEGRATION_SERVICES_MAP.fetch(srv_name.to_sym, srv_name).to_s}
-          args[:Enable] = true if srv_enable
-          execute(:set_vm_integration_services, args)
-        end
-      end
-
-      # Set the name of the VM
-      #
-      # @param [String] vmname Name of the VM
-      # @return [nil]
-      def set_name(vmname)
-        execute(:set_name, VMID: vm_id, VMName: vmname)
-      end
-
-      protected
-
-      def execute_powershell(path, options, &block)
-        lib_path = Pathname.new(File.expand_path("../scripts", __FILE__))
-        mod_path = Vagrant::Util::Platform.wsl_to_windows_path(lib_path.join("utils")).to_s.gsub("/", "\\")
-        path = Vagrant::Util::Platform.wsl_to_windows_path(lib_path.join(path)).to_s.gsub("/", "\\")
-        options = options || {}
-        ps_options = []
-        options.each do |key, value|
-          next if value == false
-          ps_options << "-#{key}"
-          # If the value is a TrueClass assume switch
-          next if value == true
-          ps_options << "'#{value}'"
-        end
-
-        # Always have a stop error action for failures
-        ps_options << "-ErrorAction" << "Stop"
-
-        # Include our module path so we can nicely load helper modules
-        opts = {
-          notify: [:stdout, :stderr, :stdin],
-          module_path: mod_path
-        }
-
-        Vagrant::Util::PowerShell.execute(path, *ps_options, **opts, &block)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/errors.rb

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

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/plugin.rb

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

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/provider.rb

@@ -1,101 +0,0 @@
-require "log4r"
-
-require_relative "driver"
-require_relative "plugin"
-
-require "vagrant/util/platform"
-require "vagrant/util/powershell"
-
-module VagrantPlugins
-  module HyperV
-    class Provider < Vagrant.plugin("2", :provider)
-      attr_reader :driver
-
-      def self.usable?(raise_error=false)
-        if !Vagrant::Util::Platform.windows? &&
-            !Vagrant::Util::Platform.wsl?
-          raise Errors::WindowsRequired
-        end
-
-        if !Vagrant::Util::Platform.windows_admin? &&
-           !Vagrant::Util::Platform.windows_hyperv_admin?
-            raise Errors::AdminRequired
-        end
-
-        if !Vagrant::Util::PowerShell.available?
-          raise Errors::PowerShellRequired
-        end
-
-        true
-      rescue Errors::HyperVError
-        raise if raise_error
-        return false
-      end
-
-      def initialize(machine)
-        @machine = machine
-
-        # 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.id)
-      end
-
-      def state
-        state_id = nil
-        state_id = :not_created if !@machine.id
-
-        if !state_id
-          # Run a custom action we define called "read_state" which does
-          # what it says. It puts the state in the `:machine_state_id`
-          # key in the environment.
-          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
-        "Hyper-V (#{id})"
-      end
-
-      def ssh_info
-        # We can only SSH into a running machine
-        return nil if state.id != :running
-
-        # Read the IP of the machine using Hyper-V APIs
-        network = @driver.read_guest_ip
-        return nil if !network["ip"]
-
-        {
-          host: network["ip"],
-          port: 22,
-        }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/scripts/check_hyperv.ps1

@@ -1,8 +0,0 @@
-#Requires -Modules VagrantMessages
-
-$check = $(-Not (-Not (Get-Command "Hyper-V\Get-VMSwitch" -ErrorAction SilentlyContinue)))
-$result = @{
-    result = $check
-}
-
-Write-OutputMessage $(ConvertTo-Json $result)

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/scripts/check_hyperv_access.ps1

@@ -1,14 +0,0 @@
-#Requires -Modules VagrantMessages, VagrantVM
-
-param(
-    [parameter (Mandatory=$true)]
-    [string] $Path
-)
-
-$check = Check-VagrantHyperVAccess -Path $Path
-$result = @{
-    root_dir = ($Path -split '\\')[0,2] -join '\';
-    result = $check
-}
-
-Write-OutputMessage $(ConvertTo-Json $result)

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/scripts/clone_vhd.ps1

@@ -1,18 +0,0 @@
-#Requires -Modules VagrantMessages
-
-param(
-    [Parameter(Mandatory=$true)]
-    [string]$Source,
-
-    [Parameter(Mandatory=$true)]
-    [string]$Destination
-)
-
-$ErrorActionPreference = "Stop"
-
-try {
-    Hyper-V\New-VHD -Path $Destination -ParentPath $Source
-} catch {
-    Write-ErrorMessage "Failed to clone drive: ${PSItem}"
-    exit 1
-}

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/scripts/configure_vm.ps1

@@ -1,95 +0,0 @@
-#Requires -Modules VagrantVM, VagrantMessages
-
-param(
-    [parameter (Mandatory=$true)]
-    [Guid] $VMID,
-    [parameter (Mandatory=$false)]
-    [string] $SwitchID=$null,
-    [parameter (Mandatory=$false)]
-    [string] $Memory=$null,
-    [parameter (Mandatory=$false)]
-    [string] $MaxMemory=$null,
-    [parameter (Mandatory=$false)]
-    [string] $Processors=$null,
-    [parameter (Mandatory=$false)]
-    [string] $AutoStartAction=$null,
-    [parameter (Mandatory=$false)]
-    [string] $AutoStopAction=$null,
-    [parameter (Mandatory=$false)]
-    [switch] $VirtualizationExtensions,
-    [parameter (Mandatory=$false)]
-    [switch] $EnableCheckpoints
-)
-
-$ErrorActionPreference = "Stop"
-
-try {
-    $VM = Hyper-V\Get-VM -Id $VMID
-} catch {
-    Write-ErrorMessage "Failed to locate VM: ${PSItem}"
-    exit 1
-}
-
-if($Processors) {
-    try {
-        Set-VagrantVMCPUS -VM $VM -CPUCount ($Processors -as [int])
-    } catch {
-        Write-ErrorMessage "Failed to configure CPUs: ${PSItem}"
-        exit 1
-    }
-}
-
-if($Memory -or $MaxMemory) {
-    try {
-        Set-VagrantVMMemory -VM $VM -Memory $Memory -MaxMemory $MaxMemory
-    } catch {
-        Write-ErrorMessage "Failed to configure memory: ${PSItem}"
-        exit 1
-    }
-}
-
-if($AutoStartAction -or $AutoStopAction) {
-    try {
-        Set-VagrantVMAutoActions -VM $VM -AutoStartAction $AutoStartAction -AutoStopAction $AutoStopAction
-    } catch {
-        Write-ErrorMessage "Failed to configure automatic actions: ${PSItem}"
-        exit 1
-    }
-}
-
-if($VirtualizationExtensions) {
-    $virtex = $true
-} else {
-    $virtex = $false
-}
-
-try {
-    Set-VagrantVMVirtExtensions -VM $VM -Enabled $virtex
-} catch {
-    Write-ErrorMessage "Failed to configure virtualization extensions: ${PSItem}"
-    exit 1
-}
-
-if($SwitchID) {
-    try {
-        $SwitchName = Get-VagrantVMSwitch -NameOrID $SwitchID
-        Set-VagrantVMSwitch -VM $VM -SwitchName $SwitchName
-    } catch {
-        Write-ErrorMessage "Failed to configure network adapter: ${PSItem}"
-    }
-}
-
-if($EnableCheckpoints) {
-    $checkpoints = "Standard"
-    $CheckpointAction = "enable"
-} else {
-    $checkpoints = "Disabled"
-    $CheckpointAction = "disable"
-}
-
-try {
-    Hyper-V\Set-VM -VM $VM -CheckpointType $checkpoints
-} catch {
-    Write-ErrorMessage "Failed to ${CheckpointAction} checkpoints on VM: ${PSItem}"
-    exit 1
-}

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/scripts/create_snapshot.ps1

@@ -1,17 +0,0 @@
-#Requires -Modules VagrantMessages
-
-param(
-    [Parameter(Mandatory=$true)]
-    [string]$VmId,
-    [string]$SnapName
-)
-
-$ErrorActionPreference = "Stop"
-
-try {
-    $VM = Hyper-V\Get-VM -Id $VmId
-    Hyper-V\Checkpoint-VM $VM -SnapshotName $SnapName
-} catch {
-    Write-ErrorMessage "Failed to create snapshot: ${PSItem}"
-    exit 1
-}

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/scripts/delete_snapshot.ps1

@@ -1,16 +0,0 @@
-#Requires -Modules VagrantMessages
-
-param(
-    [Parameter(Mandatory=$true)]
-    [string]$VmId,
-    [string]$SnapName
-)
-
-$ErrorActionPreference = "Stop"
-
-try {
-    $VM = Hyper-V\Get-VM -Id $VmId
-    Hyper-V\Remove-VMSnapshot $VM -Name $SnapName
-} catch {
-    Write-ErrorMessage "Failed to delete snapshot: ${PSItem}"
-}

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/scripts/delete_vm.ps1

@@ -1,16 +0,0 @@
-#Requires -Modules VagrantMessages
-
-param(
-    [Parameter(Mandatory=$true)]
-    [string]$VmId
-)
-
-$ErrorActionPreference = "Stop"
-
-try {
-    $VM = Hyper-V\Get-VM -Id $VmId
-    Hyper-V\Remove-VM $VM -Force
-} catch {
-    Write-ErrorMessage "Failed to delete VM: ${PSItem}"
-    exit 1
-}

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/hyperv/scripts/export_vm.ps1

@@ -1,29 +0,0 @@
-#Requires -Modules VagrantMessages
-
-param(
-    [Parameter(Mandatory=$true)]
-    [string]$VmId,
-    [Parameter(Mandatory=$true)]
-    [string]$Path
-)
-
-$ErrorActionPreference = "Stop"
-
-try {
-    $vm = Hyper-V\Get-VM -Id $VmId
-    $vm | Hyper-V\Export-VM -Path $Path
-} catch {
-    Write-ErrorMessage "Failed to export VM: ${PSItem}"
-    exit 1
-}
-
-# Prepare directory structure for box import
-try {
-    $name = $vm.Name
-    Move-Item $Path/$name/* $Path
-    Remove-Item -Path $Path/Snapshots -Force -Recurse
-    Remove-Item -Path $Path/$name -Force
-} catch {
-    Write-ErrorMessage "Failed to format exported box: ${PSItem}"
-    exit 1
-}