vagrant-hypervnet 0.1.1

data/lib/vagrant-hypervnet/cap/linux/pre_configure_networks.rb

@@ -0,0 +1,31 @@
+require "yaml"
+
+module VagrantPlugins
+  module HyperVNet
+    module Cap
+      module Linux
+        class PreConfigureNetworks
+          extend Vagrant::Util::GuestInspection::Linux    
+
+          def self.pre_configure_networks(machine)
+            if netplan?(machine.communicate)
+              yaml = ""
+              machine.communicate.sudo("netplan get 'ethernets'") do |type, data|
+                yaml << data if type == :stdout
+              end            
+              ethernets = YAML.load(yaml)
+              ethernets_to_fix = ethernets.select {|k,v| (v["dhcp4"] || v["dhcp6"]) && !v["critical"]}
+              if !ethernets_to_fix.empty?
+                ethernets_to_fix.each do |k,v|
+                  machine.communicate.sudo("netplan set 'ethernets.#{k}.critical=true'")                   
+                end
+                machine.communicate.sudo("netplan apply &")
+                machine.communicate.reset!                      
+              end                       
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/cap/vyos/post_configure_networks.rb

@@ -0,0 +1,45 @@
+require "yaml"
+
+module VagrantPlugins
+  module HyperVNet
+    module Cap
+      module Vyos
+        class PostConfigureNetworks  
+          
+          @@logger = Log4r::Logger.new("vagrant::hypervnet::guest::vyos::post_configure_networks")   
+
+          def self.post_configure_networks(machine)
+            nic_mac_addresses = machine.guest.capability(:nic_mac_addresses)
+            machine.communicate.tap do |comm|
+              commands = "#!/bin/vbash\n"
+              commands << "if [ \"$(id -g -n)\" != 'vyattacfg' ] ; then\n"
+              commands << "  exec sg vyattacfg -c \"/bin/vbash $(readlink -f $0) $@\"\n"
+              commands << "fi\n"
+              commands << "source /opt/vyatta/etc/functions/script-template\n"
+              commands << "configure\n"
+
+              nic_mac_addresses.each do |nic|
+                commands << "set interfaces ethernet #{nic[:name]} hw-id '#{nic[:mac_address]}' \n"
+              end
+  
+              commands << "commit\n"
+              commands << "save\n"
+              commands << "exit\n"
+
+              @@logger.debug("Commands: \n#{commands}")
+
+              temp = Tempfile.new("vagrant")
+              temp.binmode
+              temp.write(commands)
+              temp.close
+  
+              comm.upload(temp.path, "/tmp/vagrant-configure-network")
+              comm.execute("bash /tmp/vagrant-configure-network")
+              comm.execute("rm -f /tmp/vagrant-configure-network")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/cap/windows/rsync.rb

@@ -0,0 +1,60 @@
+require 'net/http'
+require 'uri'
+
+module VagrantPlugins
+  module HyperVNet
+    module Cap
+      module Windows
+        class RSync
+
+          def self.rsync_installed(machine)
+            machine.communicate.test("rsync -V")
+          end
+
+          def self.rsync_install(machine)
+            if machine.config.hypervnet.install_rsync
+              machine.ui.detail(I18n.t("vagrant_hypervnet.rsync.install")) 
+
+              msys2_base_url = "https://repo.msys2.org/distrib/x86_64/"
+              path_registry_key = "Registry::HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\Session Manager\\Environment"
+              msys2_url = Net::HTTP.get(URI.parse(msys2_base_url)).scan(/msys2-x86_64-\d+\.exe/)
+                  .sort.map{|url| URI.join(msys2_base_url, url)}.last.to_s
+
+              cmds = []
+              cmds += [
+                "Invoke-WebRequest -Uri '#{msys2_url}' -OutFile C:\\msys2.exe",
+                "C:\\msys2.exe install --root 'C:\\MSYS2' --confirm-command",
+                "C:\\msys2\\usr\\bin\\pacman -S rsync --noconfirm",
+                "remove-item 'C:\\msys2.exe'"
+              ]
+              cmd = "$path = (Get-ItemProperty -Path '#{path_registry_key}' -Name path).path; "
+              cmd << "$path = \"$path;C:\\MSYS2\\usr\\bin\"; "
+              cmd << "Set-ItemProperty -Path '#{path_registry_key}' -Name path -Value $path"
+              cmds << cmd
+
+              machine.communicate.tap do |comm|
+                cmds.each do |cmd|
+                  comm.execute(cmd, shell: :powershell)
+                end
+              end
+
+              if machine.guest.capability?(:sshd_reload)
+                machine.guest.capability(:sshd_reload)
+              end            
+            end
+          end
+
+          def self.rsync_scrub_guestpath( machine, opts )
+            if opts[:guestpath] =~ /^([a-zA-Z]):/
+              opts[:guestpath].gsub( /^([a-zA-Z]):/, '/c/\1' )
+            elsif opts[:guestpath] !~ /^[\/\\][a-zA-Z][\/\\]/
+              "/c/#{opts[:guestpath]}"
+            else
+              opts[:guestpath] 
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/cap/windows/sshd.rb

@@ -0,0 +1,151 @@
+
+require 'vagrant/util/keypair'
+
+module VagrantPlugins
+  module HyperVNet
+    module Cap
+      module Windows
+        class Sshd
+
+          def self.sshd_installed(machine)
+            machine.communicate.test("Get-Service -Name sshd")
+          end
+
+          def self.sshd_install(machine)
+            machine.ui.detail(I18n.t("vagrant_hypervnet.ssh.install")) 
+
+            machine.communicate.sudo("Get-WindowsCapability -Online | ? Name -like 'OpenSSH.Server*' | Add-WindowsCapability -Online",
+              shell: :powershell, elevated: true)
+              
+            if machine.config.ssh.insert_key              
+              insert = false
+              ssh_info = machine.ssh_info
+              if !ssh_info.nil?
+                insert = ssh_info[:password] && ssh_info[:private_key_path].empty?
+                ssh_info[:private_key_path].each do |pk|
+                  if insecure_key?(pk)
+                    insert = true
+                    machine.ui.detail("\n"+I18n.t("vagrant_hypervnet.ssh.inserting_insecure_detected"))
+                    break
+                  end
+                end
+              end
+
+              if insert
+                _pub, priv, openssh = Vagrant::Util::Keypair.create  
+                machine.ui.detail("\n"+I18n.t("vagrant_hypervnet.ssh.inserting_random_key"))
+                insert_public_key(machine, openssh)
+      
+                # Write out the private key in the data dir so that the
+                # machine automatically picks it up.
+                machine.data_dir.join("private_key").open("w+") do |f|
+                  f.write(priv)
+                end
+
+                # Adjust private key file permissions if host provides capability
+                if machine.env.host.capability?(:set_ssh_key_permissions)
+                  machine.env.host.capability(:set_ssh_key_permissions, machine.data_dir.join("private_key"))
+                end
+              
+                # Remove the old key if it exists
+                machine.ui.detail(I18n.t("vagrant_hypervnet.ssh.inserting_remove_key"))
+                remove_public_key(machine, Vagrant.source_root.join("keys", "vagrant.pub").read.chomp)
+      
+                machine.ui.detail(I18n.t("vagrant_hypervnet.ssh.inserted_key")) 
+              end
+            end
+            
+            cmds = []
+            cmds += [
+              'Start-Service -Name sshd',
+              'Set-Service -Name sshd -StartupType "Automatic"'
+            ]
+
+            machine.communicate.tap do |comm|
+              cmds.each do |cmd|
+                comm.execute(cmd, shell: :powershell)
+              end
+            end
+
+          end
+
+          def self.sshd_reload(machine)
+            machine.ui.detail(I18n.t("vagrant_hypervnet.ssh.reload")) 
+            machine.communicate.execute('Restart-Service -Name sshd', shell: :powershell)
+          end
+
+          def self.insecure_key?(path)
+            return false if !path
+            return false if !File.file?(path)
+            source_path = Vagrant.source_root.join("keys", "vagrant")
+            return File.read(path).chomp == source_path.read.chomp
+          end
+
+          def self.insert_public_key(machine, contents)
+            contents = contents.strip
+            winssh_modify_authorized_keys machine do |keys|
+              if !keys.include?(contents)
+                keys << contents
+              end
+            end
+          end
+  
+          def self.remove_public_key(machine, contents)
+            winssh_modify_authorized_keys machine do |keys|
+              keys.delete(contents)
+            end
+          end
+  
+          def self.winssh_modify_authorized_keys(machine)
+            comm = machine.communicate
+            directories = fetch_guest_paths(comm)
+            data_dir = directories[:data]
+            temp_dir = directories[:temp]
+  
+            remote_ssh_dir = "#{data_dir}\\ssh"
+            comm.execute("New-Item -Path '#{remote_ssh_dir}' -ItemType directory -Force", shell: "powershell")
+            remote_upload_path = "#{temp_dir}\\vagrant-insert-pubkey-#{Time.now.to_i}"
+            remote_authkeys_path = "#{remote_ssh_dir}\\administrators_authorized_keys"            
+  
+            keys_file = Tempfile.new("vagrant-windows-insert-public-key")
+            keys_file.close
+            # Check if an authorized_keys file already exists
+            result = comm.execute("dir \"#{remote_authkeys_path}\"", shell: "cmd", error_check: false)
+            if result == 0
+              comm.download(remote_authkeys_path, keys_file.path)
+              keys = File.read(keys_file.path).split(/[\r\n]+/)
+            else
+              keys = []
+            end
+            yield keys
+            File.write(keys_file.path, keys.join("\r\n") + "\r\n")
+            comm.upload(keys_file.path, remote_upload_path)
+            keys_file.delete
+            comm.execute(<<-EOC.gsub(/^\s*/, ""), shell: "powershell")
+              Set-Acl "#{remote_upload_path}" (Get-Acl "#{remote_authkeys_path}")
+              Move-Item -Force "#{remote_upload_path}" "#{remote_authkeys_path}"
+            EOC
+          end
+  
+          # Fetch user's temporary and data directory paths from the Windows guest
+          #
+          # @param [Communicator]
+          # @return [Hash] {:temp, :data}
+          def self.fetch_guest_paths(communicator)
+            output = ""
+            communicator.execute("Write-Output $env:TEMP\nWrite-Output $env:ProgramData", shell: "powershell") do |type, data|
+              if type == :stdout
+                output << data
+              end
+            end
+            temp_dir, data_dir = output.strip.split(/[\r\n]+/)
+            if temp_dir.nil? || data_dir.nil?
+              raise Errors::PublicKeyDirectoryFailure
+            end
+            {temp: temp_dir, data: data_dir}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/cap.rb

@@ -0,0 +1,15 @@
+require_relative 'driver'
+
+module VagrantPlugins
+  module HyperVNet
+    module Cap
+      # Reads the network interface card MAC addresses and returns them.
+      #
+      # @return [Hash<String, String>] Adapter => MAC address
+      def self.nic_mac_addresses(machine)
+        driver = Driver.new(machine.id)
+        driver.read_vm_mac_addresses
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/config.rb

@@ -0,0 +1,36 @@
+require "vagrant"
+
+module VagrantPlugins
+  module HyperVNet
+    class Config < Vagrant.plugin("2", :config)
+
+      attr_reader :network_adapters
+
+      attr_accessor :install_ssh_server
+      attr_accessor :install_rsync
+
+      def initialize        
+        @network_adapters = []
+        @install_ssh_server = UNSET_VALUE
+        @install_rsync = UNSET_VALUE
+  
+        network_adapter(:nat)
+      end
+
+      def network_adapter(type, **opts)
+        @network_adapters <<  [type, opts]
+      end
+
+      def finalize!
+        @install_ssh_server = true if @install_ssh_server == UNSET_VALUE
+        @install_rsync = true if @install_rsync == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        {"Hyper-V network" => errors}
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/driver.rb

@@ -0,0 +1,197 @@
+require "json"
+require "vagrant/util/powershell"
+
+require_relative "errors"
+
+module VagrantPlugins
+  module HyperVNet   
+    class Driver
+      ERROR_REGEXP  = /===Begin-Error===(.+?)===End-Error===/m
+      OUTPUT_REGEXP = /===Begin-Output===(.+?)===End-Output===/m
+
+      # @return [String] VM Id
+      attr_reader :vmId
+
+      def initialize(id)
+        @vmId = id
+        @logger = Log4r::Logger.new("vagrant::hypervnet::driver")
+      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])
+
+          @logger.info("Error in #{path}: #{data["error"]}")
+          # We have some error data.
+          raise Errors::PowerShellError,
+            script: path,
+            stderr: data["error"]
+        end
+
+        if r.exit_code != 0
+          @logger.info("Error in #{path}: #{r.stderr}")
+          raise Errors::PowerShellError,
+            script: path,
+            stderr: r.stderr
+        end
+
+        # Nothing
+        return nil if !output_match
+        return JSON.parse(output_match[1])
+      end
+
+      def find_switch_by_name(name)
+        data = execute(:get_switch_by_name, Name: name)
+        if data && data.kind_of?(Array)
+          data = data[0]
+        end
+
+        if data
+          switch = {}
+          switch[:name] = data["Name"]          
+          switch[:type] = data["SwitchType"]
+        end
+
+        switch
+      end
+
+      def find_switch_by_address(ip_address, prefix_length)        
+        data = execute(:get_switch_by_address, DestinationPrefix: "#{ip_address}/#{prefix_length}")
+        if data && data.kind_of?(Array)
+          data = data[0]
+        end
+
+        if data
+          switch = {}
+          switch[:name] = data["Name"]          
+          switch[:type] = data["SwitchType"]
+        end
+
+        switch
+      end
+
+      def read_vm_mac_addresses
+        adapters = {}
+
+        data = execute(:get_vm_adapters, VmId: @vmId)
+        if data
+          if data.kind_of?(Hash)
+            data = [] << data
+          end
+          
+          data.each.with_index(1) do |value, index|
+            adapters[index] = value["MacAddress"]
+          end
+        end
+
+        adapters
+      end
+
+      def read_vm_network_adapters
+        adapters = []
+
+        data = execute(:get_vm_adapters, VmId: @vmId)
+        if data
+          if data.kind_of?(Hash)
+            data = [] << data
+          end   
+          data.each do |value|
+            adapter = {}
+            adapter[:id] = value["Id"]
+            adapter[:name] = value["Name"]
+            adapter[:switch] = value["SwitchName"]
+            adapter[:mac_address] = value["MacAddress"]
+            adapters << adapter
+          end
+        end        
+        adapters
+      end
+
+      def create_switch(type, name, ip_address = nil, prefix_length = nil)
+        case type
+        when :internal
+          data = execute(:new_switch, Name: name, SwitchType: "Internal", IPAddress: ip_address, PrefixLength: prefix_length)
+        when :private
+          data = execute(:new_switch, Name: name, SwitchType: "Private")
+        end
+
+        if data
+          switch = {}
+          switch[:name] = data["Name"]          
+          switch[:type] = data["SwitchType"]
+        end
+
+        switch
+      end
+
+      def add_vm_adapter(switch)
+        data = execute(:add_vm_adapter, VmId: @vmId, SwitchName: switch)
+
+        adapter = {}
+        adapter[:id] = data["Id"]
+        adapter[:name] = data["Name"]
+        adapter[:switch] = data["SwitchName"]
+        adapter[:mac_address] = data["MacAddress"]
+   
+        adapter        
+      end
+
+      def remove_vm_adapter(id)
+        execute(:remove_vm_adapter, VmId: @vmId, Id: id)        
+      end
+
+      def connect_vm_adapter(id, switch)
+        execute(:connect_vm_adapter, VmId: @vmId, Id: id, SwitchName: switch)        
+      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 || value.to_s.empty?
+          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/lib/vagrant-hypervnet/errors.rb

@@ -0,0 +1,34 @@
+module VagrantPlugins
+  module HyperVNet
+    module Errors
+      # A convenient superclass for all our errors.
+      class HyperVNetError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_hypervnet.errors")
+      end
+
+      class BridgeUndefinedInPublicNetwork < HyperVNetError
+        error_key(:bridge_undefined_in_public_network)
+      end
+
+      class IpUndefinedInPrivateNetwork < HyperVNetError
+        error_key(:ip_undefined_in_private_network)
+      end
+
+      class PowerShellError < HyperVNetError
+        error_key(:powershell_error)
+      end
+
+      class NetworkAddressInvalid < HyperVNetError
+        error_key(:network_address_invalid)
+      end
+
+      class NetworkNotFound < HyperVNetError
+        error_key(:network_not_found)
+      end
+
+      class NetworkTypeNotSupported < HyperVNetError
+        error_key(:network_type_not_supported)
+      end  
+    end
+  end
+end

data/lib/vagrant-hypervnet/scripts/add_vm_adapter.ps1

@@ -0,0 +1,15 @@
+#Requires -Modules VagrantMessages
+
+param (
+    [parameter (Mandatory=$true)]
+    [string]$VmId,
+    [parameter (Mandatory=$true)]
+    [string]$SwitchName 
+
+)
+
+$vm = Get-VM -Id $VmId
+$adapter = Add-VMNetworkAdapter -PassThru -VM $vm -SwitchName $SwitchName |
+    Select-Object -Property "Name", "Id", "SwitchName", "MacAddress"
+
+Write-OutputMessage $(ConvertTo-JSON $adapter)

data/lib/vagrant-hypervnet/scripts/connect_vm_adapter.ps1

@@ -0,0 +1,12 @@
+param (
+    [parameter (Mandatory=$true)]
+    [string]$VmId,
+    [parameter (Mandatory=$true)]
+    [string]$Id,
+    [parameter (Mandatory=$true)]
+    [string]$SwitchName 
+
+)
+
+$vm = Get-VM -Id $VmId
+Get-VMNetworkAdapter -VM $vm | Where-Object -Property Id -EQ -Value $Id | Connect-VMNetworkAdapter -SwitchName $SwitchName

data/lib/vagrant-hypervnet/scripts/get_switch_by_address.ps1

@@ -0,0 +1,22 @@
+#Requires -Modules VagrantMessages
+
+param (
+    [parameter (Mandatory=$true)]
+    [string]$DestinationPrefix
+ )
+
+$switches = @()
+
+foreach($route in  Get-NetRoute | Where-Object -Property DestinationPrefix -EQ -Value $DestinationPrefix) {
+    foreach($adapter in Get-NetAdapter -InterfaceIndex $route.ifIndex) {
+        foreach($vmAdapter in Get-VMNetworkAdapter -ManagementOS | Where-Object -Property DeviceId -EQ -Value $adapter.DeviceId) {
+            foreach($switch in Get-VMSwitch -Name $vmAdapter.SwitchName |
+                Select-Object -Property Name,
+                    @{Name='SwitchType';Expression={"$($_.SwitchType)"}},
+                    @{Name='NetAdapter';Expression={$switch_adapter[$_.Name]}}) {
+                      $switches += $switch
+                    }
+        }
+    }
+}
+Write-OutputMessage $(ConvertTo-JSON $switches)

data/lib/vagrant-hypervnet/scripts/get_switch_by_name.ps1

@@ -0,0 +1,17 @@
+#Requires -Modules VagrantMessages
+
+param (
+    [parameter (Mandatory=$true)]
+    [string]$Name
+ )
+
+ $switches = @()
+
+ foreach($switch in Get-VMSwitch | Where-Object -Property Name -EQ -Value  $Name |
+    Select-Object -Property Name,
+        @{Name='SwitchType';Expression={"$($_.SwitchType)"}},
+        @{Name='NetAdapter';Expression={$switch_adapter[$_.Name]}}) {
+            $switches += $switch
+        }
+
+Write-OutputMessage $(ConvertTo-JSON $switches)

data/lib/vagrant-hypervnet/scripts/get_vm_adapters.ps1

@@ -0,0 +1,11 @@
+#Requires -Modules VagrantMessages
+
+param (
+    [parameter (Mandatory=$true)]
+    [string]$VmId
+)
+$vm = Get-VM -Id $VmId
+$adapters = Get-VMNetworkAdapter -VM $vm |
+    Select-Object -Property "Name", "Id", "SwitchName", "MacAddress"
+
+Write-OutputMessage $(ConvertTo-JSON $adapters)

data/lib/vagrant-hypervnet/scripts/new_switch.ps1

@@ -0,0 +1,26 @@
+#Requires -Modules VagrantMessages
+
+param (
+    [parameter (Mandatory=$true)]
+    [string]$Name,
+    [parameter (Mandatory=$true)]
+    [string]$SwitchType,
+    [parameter (Mandatory=$false)]
+    [string]$IPAddress,
+    [parameter (Mandatory=$false)]
+    [string]$PrefixLength
+
+ )
+
+ $switch = New-VMSwitch -Name $Name -SwitchType $SwitchType
+
+ if($IPAddress) {
+    $vmAdapter = Get-VMNetworkAdapter -ManagementOS -SwitchName $switch.Name
+    $adapter = Get-NetAdapter | Where-Object -Property DeviceId -EQ -Value $vmAdapter.DeviceId
+    New-NetIPAddress -IPAddress $IPAddress -PrefixLength $PrefixLength -InterfaceIndex $adapter.ifIndex
+ }
+   
+Write-OutputMessage $($switch | Select-Object -Property Name,
+   @{Name='SwitchType';Expression={"$($_.SwitchType)"}},
+   @{Name='NetAdapter';Expression={$switch_adapter[$_.Name]}} |
+   ConvertTo-JSON)