vagrant-hypervnet 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f024899cc74a4e7385cd03355e8bef3b435890225cff8b0a6148d25b52a86f9
+  data.tar.gz: 1e00433fbdc4d9c3a134eb154c185b186cf8c1188816dd38f80d7af8db92adb7
+SHA512:
+  metadata.gz: 57d673018b5faef0970e51671bd53033908c914e5af64d526ff2c41115552686988067d905b347c005ffc1edd9794e70f77be3865784c952e6be517412c7d7d4
+  data.tar.gz: e58247102736397f56cc419b56d3df1940f2f6704c2c7c81cdbb6211b533c98ce9c5710ec2e30818a1798b06bc5b0e0c71e8cc6cc2a67be1d26bbb5d1a54eed6

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in vagrant-hypervnet.gemspec
+#gemspec
+
+#gem "debug", ">= 1.0.0"
+
+group :development do
+  gem "vagrant", git: "https://github.com/hashicorp/vagrant.git", tag: 'v2.3.4'
+end
+
+group :plugins do
+  gem "vagrant-hypervnet", path: "."
+end

data/README.md

@@ -0,0 +1,54 @@
+# vagrant-hypervnet
+
+*vagrant-hypervnet* is a [Vagrant](http://vagrantup.com) plugin which extends Hyper-V provider implementing networks creation and
+configuration.
+
+[![Gem Version](https://badge.fury.io/rb/vagrant-hypervnet.svg)](https://badge.fury.io/rb/vagrant-hypervnet)
+[![Downloads](http://ruby-gem-downloads-badge.herokuapp.com/vagrant-hypervnet?type=total&style=flat)](https://rubygems.org/gems/vagrant-hypervnet)
+
+## Features
+
+* Create Hyper-V switches. 
+* Add an host IP address for each private network
+* Add a and configure a guest network adapter for each configured public or private network 
+* Optionally install and configure SSH server in windows guests.
+* Optionally install and configure rsync ([MSYS2](https://www.msys2.org/)) in windows guests.
+
+## Installation
+
+```
+$ vagrant plugin install vagrant-hypervnet
+```
+
+## Configuration
+
+```ruby
+Vagrant.configure("2") do |config|
+  
+  # install OpenSSH Server (Windows Capability) and insert vagrant ssh key on windows guests 
+  config.hypervnet.install_ssh_server = true
+  
+  # install MSYS2 and rsync on windows guests
+  config.hypervnet.install_rsync = true
+end
+```
+
+### Config options
+
+* `install_ssh_server` (Boolean, default: `true`): install OpenSSH Server (Windows Capability) and insert vagrant ssh key on windows guests.
+* `install_rsync` (Boolean, default: `true`): install MSYS2 and rsync on windows guests.
+
+## Usage
+
+```
+$ vagrant init
+$ vagrant up --provider=hyperv
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+#require "bundler/gem_tasks"
+#task default: %i[]
+
+require "rubygems"
+require "bundler/setup"
+Bundler::GemHelper.install_tasks

data/Vagrantfile

@@ -0,0 +1,104 @@
+vms = []
+
+windows = {}
+windows["box"] = "StefanScherer/windows_2019"
+windows["hostname"] = "test-windows"
+windows["network"] = []
+windowsNet1 = {}
+windowsNet1["ip"] = "10.42.201.101"
+windowsNet1["netmask"] = "255.255.255.0"
+windows["network"].push(windowsNet1)
+windowsNet2 = {}
+windowsNet2["ip"] = "10.42.202.101"
+windowsNet2["netmask"] = "255.255.255.0"
+windows["network"].push(windowsNet2)
+windowsNet3 = {}
+windowsNet3["ip"] = "10.42.203.101"
+windowsNet3["netmask"] = "255.255.255.0"
+windows["network"].push(windowsNet3)
+windows["synced_folder"] = []
+windowsSyncFolder1 = {}
+windowsSyncFolder1["src"] = "."
+windowsSyncFolder1["dst"] = "/c/vagrant"
+windowsSyncFolder1["exclude"] = ".git/"
+windows["synced_folder"].push(windowsSyncFolder1)
+vms.push(windows)
+
+ubuntu = {}
+ubuntu["box"] = "generic/ubuntu2004"
+ubuntu["hostname"] = "test-ubuntu"
+ubuntu["network"] = []
+ubuntuNet1 = {}
+ubuntuNet1["ip"] = "10.42.201.102"
+ubuntuNet1["netmask"] = "255.255.255.0"
+ubuntu["network"].push(ubuntuNet1)
+ubuntuNet2 = {}
+ubuntuNet2["ip"] = "10.42.202.102"
+ubuntuNet2["netmask"] = "255.255.255.0"
+ubuntu["network"].push(ubuntuNet2)
+ubuntuNet3 = {}
+ubuntuNet3["ip"] = "10.42.203.102"
+ubuntuNet3["netmask"] = "255.255.255.0"
+ubuntu["network"].push(ubuntuNet3)
+ubuntu["synced_folder"] = []
+ubuntuSyncFolder1 = {}
+ubuntuSyncFolder1["src"] = "."
+ubuntuSyncFolder1["dst"] = "/vagrant"
+ubuntuSyncFolder1["exclude"] = ".git/"
+ubuntu["synced_folder"].push(ubuntuSyncFolder1)
+vms.push(ubuntu)
+
+centos = {}
+centos["box"] = "generic/centos7"
+centos["hostname"] = "test-centos"
+centos["network"] = []
+centosNet1 = {}
+centosNet1["ip"] = "10.42.201.103"
+centosNet1["netmask"] = "255.255.255.0"
+centos["network"].push(centosNet1)
+centosNet2 = {}
+centosNet2["ip"] = "10.42.202.103"
+centosNet2["netmask"] = "255.255.255.0"
+centos["network"].push(centosNet2)
+centosNet3 = {}
+centosNet3["ip"] = "10.42.203.103"
+centosNet3["netmask"] = "255.255.255.0"
+centos["network"].push(centosNet3)
+centos["synced_folder"] = []
+centosSyncFolder1 = {}
+centosSyncFolder1["src"] = "."
+centosSyncFolder1["dst"] = "/vagrant"
+centosSyncFolder1["exclude"] = ".git/"
+centos["synced_folder"].push(centosSyncFolder1)
+vms.push(centos)
+
+Vagrant.configure("2") do |config|
+  vms.each do |node|
+    config.vm.define node["hostname"] do |node_config|    
+      node_config.vm.box = node["box"]
+      node_config.vm.hostname = node["hostname"] 
+
+      node["network"].each do |network|
+        node_config.vm.network :private_network, ip: network["ip"], netmask: network["netmask"]
+      end
+
+      node["synced_folder"].each do |folder|
+        node_config.vm.synced_folder folder["src"], folder["dst"], type: "rsync", rsync__exclude: folder["exclude"]
+      end
+
+      node_config.vm.provider "hyperv" do |p|
+        p.linked_clone = true
+        p.vmname = node["hostname"]
+        p.cpus = 2
+        p.maxmemory = 4096
+        p.vm_integration_services = {
+          guest_service_interface: true,
+          time_synchronization: true,
+          shutdown: true,
+          heartbeat: true,
+          vss: true
+        }
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/action/disable_builtin_network_configure.rb

@@ -0,0 +1,39 @@
+require "log4r"
+
+module VagrantPlugins
+  module HyperVNet    
+    module Action
+      class DisableBuiltinNetworkConfigure
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::hypervnet::disable_builtin_network_configure")
+        end
+
+        def call(env)
+          @logger.info("Disabling built-in Hyper-V provider network configure...")       
+          
+          
+          env[:machine].config.vm.networks.each do |type, options|
+            if options.key?(:bridge)
+              bridge = options.delete(:bridge)
+              options[:hyperv__bridge] = bridge
+            end
+          end
+
+          sentinel = env[:machine].data_dir.join("action_configure")
+          
+          # Create the sentinel
+          if !sentinel.file?
+            sentinel.open("w") do |f|
+                f.write(Time.now.to_i.to_s)
+            end
+          end
+
+          # Continue the middleware chain.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/action/network.rb

@@ -0,0 +1,328 @@
+require "ipaddr"
+require "log4r"
+
+require "vagrant/util/scoped_hash_override"
+
+require_relative "../driver"
+require_relative "../errors"
+
+module VagrantPlugins
+  module HyperVNet    
+    module Action
+      class Network
+
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::hypervnet::network")
+        end
+
+        def call(env)
+          @env = env
+          @driver = Driver.new(env[:machine].id)
+
+          network_adapters_config = env[:machine].config.hypervnet.network_adapters.dup
+
+          @logger.info("Determining network adapters required for high-level configuration...")          
+          env[:machine].config.vm.networks.each do |type, options|
+            next if type != :private_network && type != :public_network
+
+            options = scoped_hash_override(options, :hyperv)            
+
+            if !options.key?(:type) && options.key?(:ip)
+              begin
+                addr = IPAddr.new(options[:ip])
+                options[:type] = if addr.ipv4?
+                                   :static
+                                 else
+                                   :static6
+                                 end
+              rescue IPAddr::Error => err
+                raise Errors::NetworkAddressInvalid,
+                      address: options[:ip], mask: options[:netmask],
+                      error: err.message
+              end
+            end
+            
+            data = nil
+            if type == :private_network
+              if options[:private]
+                data = [:private, options]
+              else
+                data = [:internal, options]
+              end
+            elsif type == :public_network
+              data = [:external, options]
+            end
+            
+            @logger.info(" -- Slot #{network_adapters_config.length}: #{data[0]}")
+            network_adapters_config << data
+          end
+
+          @logger.info("Determining adapters and compiling network configuration...")
+          adapters = []
+          networks = []
+          network_adapters_config.each.with_index(0) do |data, index|
+            type    = data[0]
+            options = data[1]
+
+            @logger.info("Network #{index}. Type: #{type}.")
+
+            config = send("#{type}_config", options)
+            @logger.debug("Normalized configuration: #{config.inspect}")
+
+            adapter = send("#{type}_adapter", config)
+            adapters << adapter
+            @logger.debug("Adapter configuration: #{adapter.inspect}")
+
+            network = send("#{type}_network_config", config)
+            network[:auto_config] = config[:auto_config]
+            networks << network
+          end
+
+          if !adapters.empty?
+            @logger.info("Enabling adapters...")
+            env[:ui].output(I18n.t("vagrant_hypervnet.network.preparing"))
+            adapters.each.with_index(0) do |adapter, index|
+              @logger.info(adapter.inspect)
+              env[:ui].detail(I18n.t(
+                "vagrant_hypervnet.network_adapter",
+                adapter: index.to_s,
+                type: adapter[:type].to_s,
+                switch: adapter[:switch].to_s
+              ))
+            end
+            
+            enable_adapters(adapters)
+          end          
+
+          @app.call(env)
+
+          if !adapters.empty? && !networks.empty?
+
+            guest_adapters = {}
+            if env[:machine].guest.capability?(:nic_mac_addresses)
+              nic_mac_addresses = env[:machine].guest.capability(:nic_mac_addresses)
+              @logger.info("Guest NIC MAC-addresses: #{nic_mac_addresses.inspect}")
+              nic_mac_addresses.each.with_index(0) do |iface, index|
+                mac_address = iface[:mac_address].upcase.delete(':')
+                guest_adapters[mac_address] = index
+              end
+              @logger.info("Guest Adapters map: #{guest_adapters.inspect}")
+            end
+
+            assign_interface_numbers(networks, adapters, guest_adapters)
+
+            networks_to_configure = networks.select { |n| n[:auto_config] }
+            if !networks_to_configure.empty?
+              env[:ui].info I18n.t("vagrant_hypervnet.network.configuring")
+
+              networks_to_configure.each.with_index(0) do |network, index|
+                @logger.info(network.inspect)
+                env[:ui].detail(I18n.t(
+                  "vagrant_hypervnet.network_config",
+                  network: index.to_s,
+                  interface: network[:interface].to_s,
+                  type: network[:type].to_s,
+                  ip: network[:ip].to_s,
+                  netmask: network[:netmask].to_s
+                ))
+              end
+              if env[:machine].guest.capability?(:pre_configure_networks)
+                env[:machine].guest.capability(:pre_configure_networks)
+              end
+              env[:machine].guest.capability(:configure_networks, networks_to_configure)
+              if env[:machine].guest.capability?(:post_configure_networks)
+                env[:machine].guest.capability(:post_configure_networks)
+              end              
+            end
+          end                    
+        end
+
+        def external_config(options)
+          return {
+            auto_config:                     true,
+            bridge:                          nil,
+            netmask:                         "255.255.255.0",
+            type:                            :static
+          }.merge(options || {})
+        end
+
+        def external_adapter(config)
+          if config[:bridge]
+            @logger.debug("Searching for bridge #{config[:bridge]}")
+
+            switch = @driver.find_switch_by_name(config[:bridge])
+            if switch
+              @logger.info("Bridging adapter to #{switch[:name]}")
+
+              return {
+                type:        :external,
+                switch:      switch[:name],
+              }
+            else
+              raise Errors::NetworkNotFound, name: config[:bridge]
+            end
+          else
+            raise Errors::BridgeUndefinedInPublicNetwork
+          end
+        end
+
+        def external_network_config(config)
+          return {
+            type:       config[:type],
+            ip:         config[:ip],
+            netmask:    config[:netmask]
+          }
+        end
+
+        def internal_config(options)
+          return {
+            auto_config:                     true,
+            bridge:                          nil,
+            netmask:                         "255.255.255.0",
+            type:                            :static,
+          }.merge(options || {})
+        end
+
+        def internal_adapter(config)
+          if config[:type].to_sym != :static
+            raise Errors::NetworkTypeNotSupported, type: config[:type]
+          elsif !config[:ip]
+            raise Errors::IpUndefinedInPrivateNetwork
+          end
+
+          switch = nil
+          netaddr = IPAddr.new(config[:ip]).mask(config[:netmask])            
+          if config[:bridge]
+            @logger.debug("Searching for switch #{config[:bridge]}")
+            switch = @driver.find_switch_by_name(config[:bridge])            
+          else
+            @logger.info("Searching for matching switch: #{netaddr.to_s}")
+            switch = @driver.find_switch_by_address(netaddr.to_s, netaddr.prefix)
+          end
+
+          if !switch
+            @logger.info("Switch not found. Creating if we can.")
+            if !config[:bridge]
+              config[:bridge] = netaddr.to_s
+            end
+
+            # Create a new switch
+            switch = @driver.create_switch(:internal, config[:bridge], netaddr.succ.to_s, netaddr.prefix)
+            @logger.info("Created switch: #{switch[:name]}")
+          end
+
+          return {
+            switch:      switch[:name],
+            type:        :internal
+          }
+        end
+
+        def internal_network_config(config)
+          return {
+            type:       config[:type],
+            ip:         config[:ip],
+            netmask:    config[:netmask]
+          }
+        end
+
+        def private_config(options)
+          return {
+            auto_config:                     true,
+            bridge:                          options[:private],
+            netmask:                         "255.255.255.0",
+            type:                            :static,
+          }.merge(options || {})
+        end
+
+        def private_adapter(config)
+          switch = nil
+          if config[:bridge]
+            @logger.debug("Searching for switch #{config[:bridge]}")
+            switch = @driver.find_switch_by_name(config[:bridge])
+         end
+
+          if !switch
+            @logger.info("Switch not found. Creating if we can.")
+
+            # Create a new switch
+            switch = @driver.create_switch(:private, config[:bridge])
+            @logger.info("Created switch: #{switch[:name]}")
+          end
+
+          return {
+            type:        :private,
+            switch:      switch[:name],
+          }
+        end
+
+        def private_network_config(config)
+          return {
+            type: config[:type],
+            ip: config[:ip],
+            netmask: config[:netmask]
+          }
+        end
+
+        def nat_config(options)
+          return options.merge(
+            auto_config: false
+          )
+        end
+
+        def nat_adapter(config)
+          return {
+            type:    :nat,
+            switch:  "Default Switch"
+          }
+        end
+
+        def nat_network_config(config)
+          return {}
+        end
+
+        #-----------------------------------------------------------------
+        # Misc. helpers
+        #-----------------------------------------------------------------     
+            
+        def enable_adapters(adapters)
+          vm_adapters = @driver.read_vm_network_adapters
+          adapters.each.with_index(0) do |adapter, index|   
+            if index < vm_adapters.length
+              vm_adapter = vm_adapters[index]
+              @logger.info("Connecting adapter #{vm_adapter.inspect} to switch #{adapter[:switch]}")
+              @driver.connect_vm_adapter(vm_adapter[:id], adapter[:switch])
+            else
+              vm_adapter = @driver.add_vm_adapter(adapter[:switch])              
+              @logger.info("Created adapter: #{vm_adapter.inspect}")
+            end
+          end
+
+          if vm_adapters.length > adapters.length
+            for index in adapters.length .. vm_adapters.length-1 
+              vm_adapter = vm_adapters[index]
+              @logger.info("Removing adapter: #{vm_adapter.inspect}")
+              @driver.remove_vm_adapter(vm_adapter[:id])
+            end
+          end
+        end
+
+        def assign_interface_numbers(networks, adapters, guest_adapters)
+          vm_adapters = @driver.read_vm_network_adapters
+          vm_adapters.each.with_index(0) do |vm_adapter, index|
+            if guest_adapters && guest_adapters.key?(vm_adapter[:mac_address])
+              @logger.info("Found guest adapter #{vm_adapter[:mac_address]}")
+              networks[index][:interface] = guest_adapters[vm_adapter[:mac_address]]
+            else
+              @logger.info("Guest adapter #{vm_adapter[:mac_address]} not found")
+              networks[index][:interface] = index
+            end
+            @logger.info("Mapping vm adapter #{index} to guest adapter #{networks[index][:interface]}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/action/ssh_server.rb

@@ -0,0 +1,28 @@
+require "log4r"
+
+module VagrantPlugins
+  module HyperVNet    
+    module Action
+      class SshServer
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::hypervnet::ssh_server")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          if(machine.config.hypervnet.install_ssh_server)
+            if machine.guest.capability?(:sshd_installed) && !machine.guest.capability(:sshd_installed)
+                @logger.info("Installing OpenSSH server...")          
+                machine.guest.capability(:sshd_install)
+            end
+          end
+
+          # Continue the middleware chain.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hypervnet/action.rb

@@ -0,0 +1,31 @@
+require_relative 'action/disable_builtin_network_configure'
+require_relative 'action/network'
+require_relative 'action/ssh_server'
+
+module VagrantPlugins
+  module HyperVNet
+    module Action
+      include Vagrant::Action::Builtin
+
+      def self.disable_builtin_network_configure
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use DisableBuiltinNetworkConfigure
+        end
+      end
+
+      def self.network
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Network
+        end
+      end
+
+      def self.ssh_server
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use SshServer
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require "yaml"
+
+module VagrantPlugins
+  module HyperVNet
+    module Cap
+      module Linux
+        class NicMacAddresses
+
+            POSSIBLE_ETHERNET_PREFIXES = ["eth".freeze, "en".freeze].freeze
+
+            @@logger = Log4r::Logger.new("vagrant::hypervnet::guest::linux::nic_mac_addresses")    
+
+          def self.nic_mac_addresses(machine)
+            s = ""
+            machine.communicate.execute("ip -o link | grep -v LOOPBACK | awk '{print $2 \"|\" $17}' | sed 's/://'") do |type, data|
+              s << data if type == :stdout
+            end
+
+            ifaces = s.split("\n").map { |line|
+                parts = line.split("|")
+                iface = {}
+                iface[:name] = parts[0]                
+                iface[:mac_address] = parts[1]
+                iface[:parts] = iface[:name].scan(/(.+?)(\d+)?/).flatten.map do |name_part|
+                    if name_part.to_i.to_s == name_part
+                        name_part.to_i
+                    else
+                        name_part
+                    end
+                end 
+                iface 
+            }
+
+            @@logger.debug("Unsorted list: #{ifaces.inspect}")
+
+            ifaces = ifaces.uniq.sort do |lhs, rhs|
+                result = 0
+                slice_length = [rhs[:parts].size, lhs[:parts].size].min
+                slice_length.times do |idx|
+                if(lhs[:parts][idx].is_a?(rhs[:parts][idx].class))
+                    result = lhs[:parts][idx] <=> rhs[:parts][idx]
+                elsif(lhs[:parts][idx].is_a?(String))
+                    result = 1
+                else
+                    result = -1
+                end
+                break if result != 0
+                end
+                result
+            end
+            @@logger.debug("Sorted list: #{ifaces.inspect}")
+
+            ifaces.each do |iface|
+                iface.delete(:parts)
+            end
+
+            resorted_ifaces = []
+            resorted_ifaces += ifaces.find_all do |iface|
+                POSSIBLE_ETHERNET_PREFIXES.any?{|prefix| iface[:name].start_with?(prefix)} &&
+                iface[:name].match(/^[a-zA-Z0-9]+$/)
+            end
+            resorted_ifaces += ifaces - resorted_ifaces
+            ifaces = resorted_ifaces
+            @@logger.debug("Ethernet preferred sorted list: #{ifaces.inspect}")
+            ifaces
+          end
+        end
+      end
+    end
+  end
+end