vagrant-unbundled 2.2.4.0 → 2.2.5.0

data/plugins/providers/docker/action/destroy_network.rb

@@ -0,0 +1,50 @@
+require 'log4r'
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class DestroyNetwork
+
+        @@lock = Mutex.new
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant::plugins::docker::network')
+        end
+
+        def call(env)
+          # If we are using a host VM, then don't worry about it
+          machine = env[:machine]
+          if machine.provider.host_vm?
+            @logger.debug("Not setting up networks because docker host_vm is in use")
+            return @app.call(env)
+          end
+
+          @@lock.synchronize do
+            machine.env.lock("docker-network-destroy", retry: true) do
+              machine.config.vm.networks.each do |type, options|
+                next if type != :private_network && type != :public_network
+
+                vagrant_networks = machine.provider.driver.list_network_names.find_all do |n|
+                  n.start_with?("vagrant_network")
+                end
+
+                vagrant_networks.each do |network_name|
+                  if machine.provider.driver.existing_named_network?(network_name) &&
+                      !machine.provider.driver.network_used?(network_name)
+                    env[:ui].info(I18n.t("docker_provider.network_destroy", network_name: network_name))
+                    machine.provider.driver.rm_network(network_name)
+                  else
+                    @logger.debug("Network #{network_name} not found or in use")
+                  end
+                end
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action/prepare_networks.rb

@@ -0,0 +1,355 @@
+require 'ipaddr'
+require 'log4r'
+
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module DockerProvider
+    module Action
+      class PrepareNetworks
+
+        include Vagrant::Util::ScopedHashOverride
+
+        @@lock = Mutex.new
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant::plugins::docker::preparenetworks')
+        end
+
+        # Generate CLI arguments for creating the docker network.
+        #
+        # @param [Hash] options Options from the network config
+        # @returns[Array<String>] Network create arguments
+        def generate_create_cli_arguments(options)
+          options.map do |key, value|
+            # If value is false, option is not set
+            next if value.to_s == "false"
+            # If value is true, consider feature flag with no value
+            opt = value.to_s == "true" ? [] : [value]
+            opt.unshift("--#{key.to_s.tr("_", "-")}")
+          end.flatten.compact
+        end
+
+        # @return [Array<Socket::Ifaddr>] interface list
+        def list_interfaces
+          Socket.getifaddrs.find_all do |i|
+            i.addr.ip? && !i.addr.ipv4_loopback? &&
+              !i.addr.ipv6_loopback? && !i.addr.ipv6_linklocal?
+          end
+        end
+
+        # Validates that a network name exists. If it does not
+        # exist, an exception is raised.
+        #
+        # @param [String] network_name Name of existing network
+        # @param [Hash] env Local call env
+        # @return [Boolean]
+        def validate_network_name!(network_name, env)
+          if !env[:machine].provider.driver.existing_named_network?(network_name)
+            raise Errors::NetworkNameUndefined,
+              network_name: network_name
+          end
+          true
+        end
+
+        # Validates that the provided options are compatible with a
+        # pre-existing network. Raises exceptions on invalid configurations
+        #
+        # @param [String] network_name Name of the network
+        # @param [Hash] root_options Root networking options
+        # @param [Hash] network_options Docker scoped networking options
+        # @param [Driver] driver Docker driver
+        # @return [Boolean]
+        def validate_network_configuration!(network_name, root_options, network_options, driver)
+          if root_options[:ip] &&
+              driver.network_containing_address(root_options[:ip]) != network_name
+            raise Errors::NetworkAddressInvalid,
+              address: root_options[:ip],
+              network_name: network_name
+          end
+          if network_options[:subnet] &&
+              driver.network_containing_address(network_options[:subnet]) != network_name
+            raise Errors::NetworkSubnetInvalid,
+              subnet: network_options[:subnet],
+              network_name: network_name
+          end
+          true
+        end
+
+        # Generate configuration for private network
+        #
+        # @param [Hash] root_options Root networking options
+        # @param [Hash] net_options Docker scoped networking options
+        # @param [Hash] env Local call env
+        # @return [String, Hash] Network name and updated network_options
+        def process_private_network(root_options, network_options, env)
+          if root_options[:name] && validate_network_name!(root_options[:name], env)
+            network_name = root_options[:name]
+          end
+
+          if root_options[:type].to_s == "dhcp"
+            if !root_options[:ip] && !root_options[:subnet]
+              network_name = "vagrant_network" if !network_name
+              return [network_name, network_options]
+            end
+            if root_options[:subnet]
+              addr = IPAddr.new(root_options[:subnet])
+              root_options[:netmask] = addr.prefix
+            end
+          end
+
+          if root_options[:ip]
+            addr = IPAddr.new(root_options[:ip])
+          elsif addr.nil?
+            raise Errors::NetworkIPAddressRequired
+          end
+
+          # If address is ipv6, enable ipv6 support
+          network_options[:ipv6] = addr.ipv6?
+
+          # If no mask is provided, attempt to locate any existing
+          # network which contains the assigned IP address
+          if !root_options[:netmask] && !network_name
+            network_name = env[:machine].provider.driver.
+              network_containing_address(root_options[:ip])
+            # When no existing network is found, we are creating
+            # a new network. Since no mask was provided, default
+            # to /24 for ipv4 and /64 for ipv6
+            if !network_name
+              root_options[:netmask] = addr.ipv4? ? 24 : 64
+            end
+          end
+
+          # With no network name, process options to find or determine
+          # name for new network
+          if !network_name
+            if !root_options[:subnet]
+              # Only generate a subnet if not given one
+              subnet = IPAddr.new("#{addr}/#{root_options[:netmask]}")
+              network = "#{subnet}/#{root_options[:netmask]}"
+            else
+              network = root_options[:subnet]
+            end
+
+            network_options[:subnet] = network
+            existing_network = env[:machine].provider.driver.
+              network_defined?(network)
+
+            if !existing_network
+              network_name = "vagrant_network_#{network}"
+            else
+              if !existing_network.to_s.start_with?("vagrant_network")
+                env[:ui].warn(I18n.t("docker_provider.subnet_exists",
+                  network_name: existing_network,
+                  subnet: network))
+              end
+              network_name = existing_network
+            end
+          end
+
+          [network_name, network_options]
+        end
+
+        # Generate configuration for public network
+        #
+        # @param [Hash] root_options Root networking options
+        # @param [Hash] net_options Docker scoped networking options
+        # @param [Hash] env Local call env
+        # @return [String, Hash] Network name and updated network_options
+        def process_public_network(root_options, net_options, env)
+          if root_options[:name] && validate_network_name!(root_options[:name], env)
+            network_name = root_options[:name]
+          end
+          if !network_name
+            valid_interfaces = list_interfaces
+            if valid_interfaces.empty?
+              raise Errors::NetworkNoInterfaces
+            elsif valid_interfaces.size == 1
+              bridge_interface = valid_interfaces.first
+            elsif i = valid_interfaces.detect{|i| Array(root_options[:bridge]).include?(i.name) }
+              bridge_interface = i
+            end
+            if !bridge_interface
+              env[:ui].info(I18n.t("vagrant.actions.vm.bridged_networking.available"),
+                prefix: false)
+              valid_interfaces.each_with_index do |int, i|
+                env[:ui].info("#{i + 1}) #{int.name}", prefix: false)
+              end
+              env[:ui].info(I18n.t(
+                "vagrant.actions.vm.bridged_networking.choice_help") + "\n",
+                prefix: false
+              )
+            end
+            while !bridge_interface
+              choice = env[:ui].ask(
+                I18n.t("vagrant.actions.vm.bridged_networking.select_interface") + " ",
+                prefix: false)
+              bridge_interface = valid_interfaces[choice.to_i - 1]
+            end
+            base_opts = Vagrant::Util::HashWithIndifferentAccess.new
+            base_opts[:opt] = "parent=#{bridge_interface.name}"
+            subnet = IPAddr.new(bridge_interface.addr.ip_address <<
+              "/" << bridge_interface.netmask.ip_unpack.first)
+            base_opts[:subnet] = "#{subnet}/#{subnet.prefix}"
+            subnet_addr = IPAddr.new(base_opts[:subnet])
+            base_opts[:driver] = "macvlan"
+            base_opts[:gateway] = subnet_addr.succ.to_s
+            base_opts[:ipv6] = subnet_addr.ipv6?
+            network_options = base_opts.merge(net_options)
+
+            # Check if network already exists for this subnet
+            network_name = env[:machine].provider.driver.
+              network_containing_address(network_options[:gateway])
+            if !network_name
+              network_name = "vagrant_network_public_#{bridge_interface.name}"
+            end
+
+            # If the network doesn't already exist, gather available address range
+            # within subnet which docker can provide addressing
+            if !env[:machine].provider.driver.existing_named_network?(network_name)
+              if !net_options[:gateway]
+                network_options[:gateway] = request_public_gateway(
+                  network_options, bridge_interface.name, env)
+              end
+              network_options[:ip_range] = request_public_iprange(
+                network_options, bridge_interface.name, env)
+            end
+          end
+          [network_name, network_options]
+        end
+
+        # Request the gateway address for the public network
+        #
+        # @param [Hash] network_options Docker scoped networking options
+        # @param [String] interface The bridge interface used
+        # @param [Hash] env Local call env
+        # @return [String] Gateway address
+        def request_public_gateway(network_options, interface, env)
+          subnet = IPAddr.new(network_options[:subnet])
+          gateway = nil
+          while !gateway
+            gateway = env[:ui].ask(I18n.t(
+              "docker_provider.network_bridge_gateway_request",
+              interface: interface,
+              default_gateway: network_options[:gateway]) + " ",
+              prefix: false
+            ).strip
+            if gateway.empty?
+              gateway = network_options[:gateway]
+            end
+            begin
+              gateway = IPAddr.new(gateway)
+              if !subnet.include?(gateway)
+                env[:ui].warn(I18n.t("docker_provider.network_bridge_gateway_outofbounds",
+                  gateway: gateway,
+                  subnet: network_options[:subnet]) + "\n", prefix: false)
+              end
+            rescue IPAddr::InvalidAddressError
+              env[:ui].warn(I18n.t("docker_provider.network_bridge_gateway_invalid",
+                gateway: gateway) + "\n", prefix: false)
+              gateway = nil
+            end
+          end
+          gateway.to_s
+        end
+
+        # Request the IP range allowed for use by docker when creating a new
+        # public network
+        #
+        # @param [Hash] network_options Docker scoped networking options
+        # @param [String] interface The bridge interface used
+        # @param [Hash] env Local call env
+        # @return [String] Address range
+        def request_public_iprange(network_options, interface, env)
+          return network_options[:ip_range] if network_options[:ip_range]
+          subnet = IPAddr.new(network_options[:subnet])
+          env[:ui].info(I18n.t(
+            "docker_provider.network_bridge_iprange_info") + "\n",
+            prefix: false
+          )
+          range = nil
+          while !range
+            range = env[:ui].ask(I18n.t(
+              "docker_provider.network_bridge_iprange_request",
+              interface: interface,
+              default_range: network_options[:subnet]) + " ",
+              prefix: false
+            ).strip
+            if range.empty?
+              range = network_options[:subnet]
+            end
+            begin
+              range = IPAddr.new(range)
+              if !subnet.include?(range)
+                puts "we in here"
+                env[:ui].warn(I18n.t(
+                  "docker_provider.network_bridge_iprange_outofbounds",
+                  subnet: network_options[:subnet],
+                  range: "#{range}/#{range.prefix}"
+                ) + "\n", prefix: false)
+                range = nil
+              end
+            rescue IPAddr::InvalidAddressError
+              env[:ui].warn(I18n.t(
+                "docker_provider.network_bridge_iprange_invalid",
+                range: range) + "\n", prefix: false)
+              range = nil
+            end
+          end
+          "#{range}/#{range.prefix}"
+        end
+
+        # Execute the action
+        def call(env)
+          # If we are using a host VM, then don't worry about it
+          machine = env[:machine]
+          if machine.provider.host_vm?
+            @logger.debug("Not setting up networks because docker host_vm is in use")
+            return @app.call(env)
+          end
+
+          connections = {}
+          @@lock.synchronize do
+            machine.env.lock("docker-network-create", retry: true) do
+              env[:ui].info(I18n.t("docker_provider.network_create"))
+              machine.config.vm.networks.each_with_index do |net_info, net_idx|
+                type, options = net_info
+                network_options = scoped_hash_override(options, :docker_network)
+                network_options.delete_if{|k,_| options.key?(k)}
+
+                case type
+                when :public_network
+                  network_name, network_options = process_public_network(
+                    options, network_options, env)
+                when :private_network
+                  network_name, network_options = process_private_network(
+                    options, network_options, env)
+                else
+                  next # unsupported type so ignore
+                end
+
+                if !network_name
+                  raise Errors::NetworkInvalidOption, container: machine.name
+                end
+
+                if !machine.provider.driver.existing_named_network?(network_name)
+                  @logger.debug("Creating network #{network_name}")
+                  cli_opts = generate_create_cli_arguments(network_options)
+                  machine.provider.driver.create_network(network_name, cli_opts)
+                else
+                  @logger.debug("Network #{network_name} already created")
+                  validate_network_configuration!(network_name, options, network_options, machine.provider.driver)
+                end
+                connections[net_idx] = network_name
+              end
+            end
+          end
+
+          env[:docker_connects] = connections
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/docker/action.rb

@@ -161,6 +161,7 @@ module VagrantPlugins
                   b4.use action_halt
                   b4.use HostMachineSyncFoldersDisable
                   b4.use Destroy
+                  b4.use DestroyNetwork
                   b4.use DestroyBuildImage
                 else
                   b4.use Message,
@@ -243,6 +244,7 @@ module VagrantPlugins
             b2.use PrepareNFSValidIds
             b2.use SyncedFolderCleanup
             b2.use PrepareNFSSettings
+            b2.use PrepareNetworks
             b2.use Login
             b2.use Build
 
@@ -265,6 +267,7 @@ module VagrantPlugins
                 end
               end
 
+              b2.use ConnectNetworks
               b2.use Start
               b2.use WaitForRunning
 
@@ -292,9 +295,11 @@ module VagrantPlugins
       action_root = Pathname.new(File.expand_path("../action", __FILE__))
       autoload :Build, action_root.join("build")
       autoload :CompareSyncedFolders, action_root.join("compare_synced_folders")
+      autoload :ConnectNetworks, action_root.join("connect_networks")
       autoload :Create, action_root.join("create")
       autoload :Destroy, action_root.join("destroy")
       autoload :DestroyBuildImage, action_root.join("destroy_build_image")
+      autoload :DestroyNetwork, action_root.join("destroy_network")
       autoload :ForwardedPorts, action_root.join("forwarded_ports")
       autoload :HasSSH, action_root.join("has_ssh")
       autoload :HostMachine, action_root.join("host_machine")
@@ -308,12 +313,13 @@ module VagrantPlugins
       autoload :IsBuild, action_root.join("is_build")
       autoload :IsHostMachineCreated, action_root.join("is_host_machine_created")
       autoload :Login, action_root.join("login")
-      autoload :Pull, action_root.join("pull")
-      autoload :PrepareSSH, action_root.join("prepare_ssh")
-      autoload :Stop, action_root.join("stop")
+      autoload :PrepareNetworks, action_root.join("prepare_networks")
       autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
       autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")
+      autoload :PrepareSSH, action_root.join("prepare_ssh")
+      autoload :Pull, action_root.join("pull")
       autoload :Start, action_root.join("start")
+      autoload :Stop, action_root.join("stop")
       autoload :WaitForRunning, action_root.join("wait_for_running")
     end
   end

data/plugins/providers/docker/driver/compose.rb

@@ -102,7 +102,19 @@ module VagrantPlugins
               # will be fixed someday and the gsub below can be removed.
               host.gsub!(/^[^A-Za-z]+/, "")
             end
-            host = @machine.env.cwd.join(host).to_s
+            # if host path is a volume key, don't expand it.
+            # if both exist (a path and a key) show warning and move on
+            # otherwise assume it's a realative path and expand the host path
+            compose_config = get_composition
+            if compose_config["volumes"] && compose_config["volumes"].keys.include?(host)
+              if File.directory?(@machine.env.cwd.join(host).to_s)
+                @machine.env.ui.warn(I18n.t("docker_provider.volume_path_not_expanded",
+                                           host: host))
+              end
+            else
+              @logger.debug("Path expanding #{host} to current Vagrant working dir instead of docker-compose config file directory")
+              host = @machine.env.cwd.join(host).to_s
+            end
             "#{host}:#{guest}"
           end
           cmd     = Array(params.fetch(:cmd))

data/plugins/providers/docker/driver.rb

@@ -152,21 +152,25 @@ module VagrantPlugins
       def rmi(id)
         execute('docker', 'rmi', id)
         return true
-      rescue Exception => e
+      rescue => e
         return false if e.to_s.include?("is using it")
         raise if !e.to_s.include?("No such image")
       end
 
+      # Inspect the provided container
+      #
+      # @param [String] cid ID or name of container
+      # @return [Hash]
       def inspect_container(cid)
-        # DISCUSS: Is there a chance that this json will change after the container
-        #          has been brought up?
-        @data ||= JSON.parse(execute('docker', 'inspect', cid)).first
+        JSON.parse(execute('docker', 'inspect', cid)).first
       end
 
+      # @return [Array<String>] list of all container IDs
       def all_containers
         execute('docker', 'ps', '-a', '-q', '--no-trunc').to_s.split
       end
 
+      # @return [String] IP address of the docker bridge
       def docker_bridge_ip
         output = execute('/sbin/ip', '-4', 'addr', 'show', 'scope', 'global', 'docker0')
         if output =~ /^\s+inet ([0-9.]+)\/[0-9]+\s+/
@@ -177,9 +181,149 @@ module VagrantPlugins
         end
       end
 
+      # @param [String] network - name of network to connect conatiner to
+      # @param [String] cid - container id
+      # @param [Array]  opts - An array of flags used for listing networks
+      def connect_network(network, cid, opts=nil)
+        command = ['docker', 'network', 'connect', network, cid].push(*opts)
+        output = execute(*command)
+        output
+      end
+
+      # @param [String] network - name of network to create
+      # @param [Array]  opts - An array of flags used for listing networks
+      def create_network(network, opts=nil)
+        command = ['docker', 'network', 'create', network].push(*opts)
+        output = execute(*command)
+        output
+      end
+
+      # @param [String] network - name of network to disconnect container from
+      # @param [String] cid - container id
+      def disconnect_network(network, cid)
+        command = ['docker', 'network', 'disconnect', network, cid, "--force"]
+        output = execute(*command)
+        output
+      end
+
+      # @param [Array]  networks - list of networks to inspect
+      # @param [Array]  opts - An array of flags used for listing networks
+      def inspect_network(network, opts=nil)
+        command = ['docker', 'network', 'inspect'] + Array(network)
+        command = command.push(*opts)
+        output = execute(*command)
+        begin
+          JSON.load(output)
+        rescue JSON::ParserError
+          @logger.warn("Failed to parse network inspection of network: #{network}")
+          @logger.debug("Failed network output content: `#{output.inspect}`")
+          nil
+        end
+      end
+
+      # @param [String] opts - Flags used for listing networks
+      def list_network(*opts)
+        command = ['docker', 'network', 'ls', *opts]
+        output = execute(*command)
+        output
+      end
+
+      # Will delete _all_ defined but unused networks in the docker engine. Even
+      # networks not created by Vagrant.
+      #
+      # @param [Array] opts - An array of flags used for listing networks
+      def prune_network(opts=nil)
+        command = ['docker', 'network', 'prune', '--force'].push(*opts)
+        output = execute(*command)
+        output
+      end
+
+      # Delete network(s)
+      #
+      # @param [String] network - name of network to remove
+      def rm_network(*network)
+        command = ['docker', 'network', 'rm', *network]
+        output = execute(*command)
+        output
+      end
+
+      # @param [Array] opts - An array of flags used for listing networks
       def execute(*cmd, **opts, &block)
         @executor.execute(*cmd, **opts, &block)
       end
+
+      # ######################
+      # Docker network helpers
+      # ######################
+
+      # Determines if a given network has been defined through vagrant with a given
+      # subnet string
+      #
+      # @param [String] subnet_string - Subnet to look for
+      # @return [String] network name - Name of network with requested subnet.`nil` if not found
+      def network_defined?(subnet_string)
+        all_networks = list_network_names
+
+        network_info = inspect_network(all_networks)
+        network_info.each do |network|
+          config = network["IPAM"]["Config"]
+          if (config.size > 0 &&
+            config.first["Subnet"] == subnet_string)
+            @logger.debug("Found existing network #{network["Name"]} already configured with #{subnet_string}")
+            return network["Name"]
+          end
+        end
+        return nil
+      end
+
+      # Locate network which contains given address
+      #
+      # @param [String] address IP address
+      # @return [String] network name
+      def network_containing_address(address)
+        names = list_network_names
+        networks = inspect_network(names)
+        return if !networks
+        networks.each do |net|
+          next if !net["IPAM"]
+          config = net["IPAM"]["Config"]
+          next if !config || config.size < 1
+          config.each do |opts|
+            subnet = IPAddr.new(opts["Subnet"])
+            if subnet.include?(address)
+              return net["Name"]
+            end
+          end
+        end
+        nil
+      end
+
+      # Looks to see if a docker network has already been defined
+      # with the given name
+      #
+      # @param [String] network_name - name of network to look for
+      # @return [Bool]
+      def existing_named_network?(network_name)
+        result = list_network_names
+        result.any?{|net_name| net_name == network_name}
+      end
+
+      # @return [Array<String>] list of all docker networks
+      def list_network_names
+        list_network("--format={{.Name}}").split("\n").map(&:strip)
+      end
+
+      # Returns true or false if network is in use or not.
+      # Nil if Vagrant fails to receive proper JSON from `docker network inspect`
+      #
+      # @param [String] network - name of network to look for
+      # @return [Bool,nil]
+      def network_used?(network)
+        result = inspect_network(network)
+        return nil if !result
+        return result.first["Containers"].size > 0
+      end
+
     end
   end
 end

data/plugins/providers/docker/errors.rb

@@ -45,6 +45,34 @@ module VagrantPlugins
         error_key(:docker_provider_nfs_without_privileged)
       end
 
+      class NetworkAddressInvalid < DockerError
+        error_key(:network_address_invalid)
+      end
+
+      class NetworkIPAddressRequired < DockerError
+        error_key(:network_address_required)
+      end
+
+      class NetworkSubnetInvalid < DockerError
+        error_key(:network_subnet_invalid)
+      end
+
+      class NetworkInvalidOption < DockerError
+        error_key(:network_invalid_option)
+      end
+
+      class NetworkNameMissing < DockerError
+        error_key(:network_name_missing)
+      end
+
+      class NetworkNameUndefined < DockerError
+        error_key(:network_name_undefined)
+      end
+
+      class NetworkNoInterfaces < DockerError
+        error_key(:network_no_interfaces)
+      end
+
       class PackageNotSupported < DockerError
         error_key(:package_not_supported)
       end