vagrant-docker-networks-manager 0.1.0

data/lib/vagrant-docker-networks-manager/config.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require_relative "helpers"
+
+module VagrantDockerNetworksManager
+  class Config < Vagrant.plugin("2", :config)
+    attr_accessor :network_name, :network_subnet, :network_type, :network_gateway,
+                  :network_parent, :network_attachable, :enable_ipv6, :ip_range,
+                  :cleanup_on_destroy, :locale
+
+    def initialize
+      @network_name       = UNSET_VALUE
+      @network_subnet     = UNSET_VALUE
+      @network_type       = UNSET_VALUE
+      @network_gateway    = UNSET_VALUE
+      @network_parent     = UNSET_VALUE
+      @network_attachable = UNSET_VALUE
+      @enable_ipv6        = UNSET_VALUE
+      @ip_range           = UNSET_VALUE
+      @cleanup_on_destroy = UNSET_VALUE
+      @locale             = UNSET_VALUE
+    end
+
+    def finalize!
+      @network_name       = "network_lo1"       if @network_name       == UNSET_VALUE
+      @network_subnet     = "172.28.100.0/26"   if @network_subnet     == UNSET_VALUE
+      @network_type       = "bridge"            if @network_type       == UNSET_VALUE
+      @network_gateway    = "172.28.100.1"      if @network_gateway    == UNSET_VALUE
+      @network_parent     = nil                 if @network_parent     == UNSET_VALUE
+      @network_attachable = false               if @network_attachable == UNSET_VALUE
+      @enable_ipv6        = false               if @enable_ipv6        == UNSET_VALUE
+      @ip_range           = nil                 if @ip_range           == UNSET_VALUE
+      @cleanup_on_destroy = true                if @cleanup_on_destroy == UNSET_VALUE
+      @locale             = "en"                if @locale             == UNSET_VALUE
+    end
+
+    def validate(_machine)
+      VagrantDockerNetworksManager::UiHelpers.setup_i18n! rescue nil
+      errors = []
+
+      unless @network_name.is_a?(String) && !@network_name.strip.empty? && docker_name?(@network_name)
+        errors << ::I18n.t("errors.invalid_name")
+      end
+
+      unless ipv4_cidr_aligned?(@network_subnet)
+        errors << ::I18n.t("errors.invalid_subnet")
+      end
+
+      unless @network_type.is_a?(String) && %w[bridge macvlan].include?(@network_type)
+        errors << ::I18n.t("errors.invalid_type")
+      end
+
+      if present?(@network_gateway)
+        if !ipv4?(@network_gateway)
+          errors << ::I18n.t("errors.invalid_gateway")
+        elsif ipv4_cidr_aligned?(@network_subnet) && !gateway_host_addr?(@network_subnet, @network_gateway)
+          errors << ::I18n.t("errors.invalid_gateway")
+        end
+      end
+
+      if present?(@network_parent) && !@network_parent.is_a?(String)
+        errors << ::I18n.t("errors.invalid_parent")
+      end
+
+      if @network_type.to_s == "macvlan" && !present?(@network_parent)
+        errors << ::I18n.t("errors.invalid_parent")
+      end
+
+      unless [true, false].include?(@network_attachable)
+        errors << ::I18n.t("errors.invalid_attachable")
+      end
+
+      unless [true, false].include?(@enable_ipv6)
+        errors << ::I18n.t("errors.invalid_ipv6")
+      end
+
+      if present?(@ip_range)
+        if !ipv4_cidr?(@ip_range)
+          errors << ::I18n.t("errors.invalid_ip_range")
+        elsif ipv4_cidr_aligned?(@network_subnet) && !cidr_within_cidr?(@network_subnet, @ip_range)
+          errors << ::I18n.t("errors.invalid_ip_range")
+        end
+      end
+
+      unless [true, false].include?(@cleanup_on_destroy)
+        errors << ::I18n.t("errors.invalid_cleanup")
+      end
+
+      unless @locale.is_a?(String) && %w[fr en].include?(@locale.to_s[0,2].downcase)
+        errors << ::I18n.t("errors.invalid_locale")
+      end
+
+      { "vagrant-docker-networks-manager" => errors }
+    end
+
+    private
+
+    def present?(val)
+      !val.nil? && !(val.respond_to?(:empty?) && val.empty?)
+    end
+  
+    def ipv4?(str)
+      ip = IPAddr.new(str) rescue nil
+      ip&.ipv4? ? true : false
+    end
+
+    def ipv4_cidr?(str)
+      ip_str, mask_str = str.to_s.split("/", 2)
+      return false unless ip_str && mask_str&.match?(/^\d+$/)
+      m = mask_str.to_i
+      return false unless (0..32).include?(m)
+      ip = IPAddr.new(ip_str) rescue nil
+      ip&.ipv4? ? true : false
+    rescue
+      false
+    end
+
+    def ipv4_cidr_aligned?(str)
+      ip_str, mask_str = str.to_s.split("/", 2)
+      return false unless ip_str && mask_str&.match?(/^\d+$/)
+      m = mask_str.to_i
+      return false unless (0..32).include?(m)
+      ip = IPAddr.new(ip_str) rescue nil
+      return false unless ip&.ipv4?
+      ip.mask(m).to_s == ip_str
+    rescue
+      false
+    end
+
+    def gateway_host_addr?(cidr, gw)
+      net = IPAddr.new(cidr) rescue nil
+      ip  = IPAddr.new(gw)   rescue nil
+      return false unless net&.ipv4? && ip&.ipv4? && net.include?(ip)
+      mask = cidr.split("/")[1].to_i
+      network = IPAddr.new(net.to_range.first.to_s).mask(mask)
+      broadcast = IPAddr.new(net.to_range.last.to_s)
+      ip != network && ip != broadcast
+    rescue
+      false
+    end
+
+    def cidr_within_cidr?(outer, inner)
+      outer_ip, outer_mask = outer.to_s.split("/", 2)
+      inner_ip, inner_mask = inner.to_s.split("/", 2)
+      return false unless outer_ip && inner_ip && outer_mask&.match?(/^\d+$/) && inner_mask&.match?(/^\d+$/)
+
+      om = outer_mask.to_i
+      im = inner_mask.to_i
+      return false unless (0..32).include?(om) && (0..32).include?(im)
+      return false unless om <= im
+
+      outer_net = IPAddr.new(outer_ip).mask(om) rescue nil
+      inner_as_outer = IPAddr.new(inner_ip).mask(om) rescue nil
+      outer_net&.ipv4? && inner_as_outer&.ipv4? && (inner_as_outer.to_s == outer_net.to_s)
+    rescue
+      false
+    end
+
+    def docker_name?(s)
+      s.is_a?(String) && s.match?(/\A[a-zA-Z0-9][a-zA-Z0-9_.-]{0,126}\z/)
+    end
+  end
+end

data/lib/vagrant-docker-networks-manager/helpers.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "i18n"
+
+module VagrantDockerNetworksManager
+  module UiHelpers
+    class MissingTranslationError < StandardError; end
+    class UnsupportedLocaleError   < StandardError; end
+
+    SUPPORTED = [:en, :fr].freeze
+    OUR_NAMESPACES = %w[messages. errors. usage. help. prompts. log. emoji.].freeze
+
+    EMOJI = {
+      success:  "✅",
+      info:     "🔍",
+      ongoing:  "🔁",
+      warning:  "⚠️",
+      error:    "❌",
+      version:  "💾",
+      broom:    "🧹",
+      question: "❓"
+    }.freeze
+
+    module_function
+
+    def setup_i18n!
+      return if defined?(@i18n_setup) && @i18n_setup
+
+      ::I18n.enforce_available_locales = false
+
+      base  = File.expand_path("../../locales", __dir__)
+      paths = Dir[File.join(base, "*.yml")]
+      ::I18n.load_path |= paths
+      ::I18n.available_locales = SUPPORTED
+
+      default = ((ENV["VDNM_LANG"] || ENV["LANG"] || "en")[0, 2] rescue "en").to_sym
+      ::I18n.default_locale = SUPPORTED.include?(default) ? default : :en
+
+      ::I18n.backend.load_translations
+      @i18n_setup = true
+    end
+
+    def set_locale!(lang)
+      setup_i18n!
+      sym = lang.to_s[0, 2].downcase.to_sym
+      unless SUPPORTED.include?(sym)
+        raise UnsupportedLocaleError,
+              "#{EMOJI[:error]} Unsupported language: #{sym}. Available: #{SUPPORTED.join(", ")}"
+      end
+      ::I18n.locale = sym
+      ::I18n.backend.load_translations
+    end
+
+    def e(key, no_emoji: false)
+      return "" if no_emoji
+      EMOJI[key] || ""
+    end
+
+    def t(key, **opts)
+      setup_i18n!
+      ::I18n.t(key, **opts)
+    end
+
+    def t!(key, **opts)
+      setup_i18n!
+      k = key.to_s
+      if our_key?(k) && !::I18n.exists?(k, ::I18n.locale)
+        raise MissingTranslationError, "#{EMOJI[:error]} [#{::I18n.locale}] Missing translation for key: #{k}"
+      end
+      ::I18n.t(k, **opts)
+    end
+
+    def t_hash(key)
+      setup_i18n!
+      v = ::I18n.t(key, default: {})
+      v.is_a?(Hash) ? v : {}
+    end
+
+    def print_general_help
+      setup_i18n!
+      puts t("help.general_title")
+      t_hash("help.commands").each_value { |line| puts "  #{line}" }
+    end
+
+    def print_topic_help(topic)
+      setup_i18n!
+      topic = topic.to_s.downcase.strip
+      return print_general_help if topic.empty?
+      body = t("help.topic.#{topic}", default: nil)
+      body ? puts(body) : print_general_help
+    end
+
+    def our_key?(k)
+      OUR_NAMESPACES.any? { |ns| k.start_with?(ns) }
+    end
+  end
+end

data/lib/vagrant-docker-networks-manager/network_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module VagrantDockerNetworksManager
+  class NetworkBuilder
+    def initialize(config, machine_id: nil)
+      @config     = config
+      @machine_id = machine_id
+    end
+
+    def build_create_command_args
+      args = ["network", "create"]
+
+      args += ["--label", "com.vagrant.plugin=docker_networks_manager"]
+      args += ["--label", "com.vagrant.machine_id=#{@machine_id}"] if @machine_id
+      args += ["--driver", @config.network_type] if present?(@config.network_type)
+      args += ["--subnet",  @config.network_subnet]  if present?(@config.network_subnet)
+      args += ["--gateway", @config.network_gateway] if present?(@config.network_gateway)
+      args += ["--ip-range", @config.ip_range]       if present?(@config.ip_range)
+      args << "--ipv6"       if truthy?(@config.enable_ipv6)
+      args << "--attachable" if truthy?(@config.network_attachable)
+      if @config.network_type.to_s == "macvlan" && present?(@config.network_parent)
+        args += ["--opt", "parent=#{@config.network_parent}"]
+      end
+      args << @config.network_name.to_s
+      args
+    end
+
+    def build_create_command
+      build_create_command_args.shelljoin
+    end
+
+    private
+
+    def present?(val)
+      !val.nil? && !(val.respond_to?(:empty?) && val.empty?)
+    end
+
+    def truthy?(val)
+      val == true
+    end
+  end
+end

data/lib/vagrant-docker-networks-manager/plugin.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "vagrant"
+require "i18n"
+
+require_relative "version"
+require_relative "helpers"
+require_relative "command"
+require_relative "config"
+require_relative "network_builder"
+require_relative "action"
+
+module VagrantDockerNetworksManager
+  class Plugin < Vagrant.plugin("2")
+    name "docker_networks_manager"
+
+    config(:docker_network) do
+      VagrantDockerNetworksManager::Config
+    end
+
+    command "network" do
+      VagrantDockerNetworksManager::Command
+    end
+
+    action_hook(:create_docker_network,  :machine_action_up) do |hook|
+      hook.prepend(ActionUp)
+    end
+
+    action_hook(:cleanup_docker_network, :machine_action_destroy) do |hook|
+      hook.append(ActionDestroy)
+    end
+  end
+end

data/lib/vagrant-docker-networks-manager/util.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "open3"
+require "json"
+require "ipaddr"
+require "shellwords"
+
+module VagrantDockerNetworksManager
+  module Util
+    module_function
+
+    def sh!(*args)
+      if ENV["VDNM_VERBOSE"] == "1"
+        printable = ["docker", *args].map(&:to_s).shelljoin
+        $stderr.puts("[VDNM] #{printable}")
+        system("docker", *args)
+      else
+        system("docker", *args, out: File::NULL, err: :out)
+      end
+    end
+
+    def docker_available?
+      _out, _err, status = Open3.capture3("docker", "info")
+      status.success?
+    rescue
+      false
+    end
+
+    def docker_network_exists?(name)
+      out, _err, st = Open3.capture3("docker", "network", "ls", "--format", "{{.Name}}")
+      st.success? && out.split.include?(name)
+    end
+
+    def read_network_labels(name)
+      out, _err, st = Open3.capture3("docker", "network", "inspect", name, "--format", "{{json .Labels}}")
+      return {} unless st.success?
+      JSON.parse(out.to_s.strip) rescue {}
+    end
+
+    def inspect_networks_batched(ids_or_names)
+      result = {}
+      ids_or_names.each_slice(50) do |chunk|
+        out, _e, st = Open3.capture3("docker", "network", "inspect", *chunk)
+        next unless st.success?
+        JSON.parse(out).each do |net|
+          subs = (net.dig("IPAM","Config") || []).map { |c| c["Subnet"] }.compact
+          cons = (net["Containers"] || {}).size
+          key  = net["Id"] || net["Name"]
+          result[key] = { subnets: subs, containers_count: cons }
+          result[net["Name"]] ||= result[key]
+        end
+      end
+      result
+    rescue
+      {}
+    end
+
+    def list_plugin_networks
+      out, _err, st = Open3.capture3(
+        "docker", "network", "ls",
+        "--filter", "label=com.vagrant.plugin=docker_networks_manager",
+        "--format", "{{.ID}}\t{{.Name}}\t{{.Driver}}\t{{.Scope}}"
+      )
+      return [] unless st.success?
+
+      rows = out.lines.map do |line|
+        id, name, driver, scope = line.strip.split("\t", 4)
+        { id: id, name: name, driver: driver, scope: scope }
+      end
+
+      details = inspect_networks_batched(rows.map { |r| r[:name] })
+      rows.each do |r|
+        subs = details.dig(r[:name], :subnets) || []
+        r[:subnets] = subs.empty? ? "-" : subs.join(", ")
+      end
+
+      rows
+    rescue
+      []
+    end
+
+    def list_plugin_networks_detailed
+      out, _err, st = Open3.capture3(
+        "docker", "network", "ls",
+        "--filter", "label=com.vagrant.plugin=docker_networks_manager",
+        "--format", "{{.ID}}\t{{.Name}}\t{{.Driver}}\t{{.Scope}}"
+      )
+      return [] unless st.success?
+
+      rows = out.lines.map { |line|
+        id, name, driver, scope = line.strip.split("\t", 4)
+        { id: id, name: name, driver: driver, scope: scope }
+      }
+
+      details = inspect_networks_batched(rows.map { |r| r[:name] })
+      rows.each do |r|
+        r[:subnets]    = details.dig(r[:name], :subnets) || []
+        r[:containers] = details.dig(r[:name], :containers_count) || 0
+      end
+      rows
+    end
+
+    def valid_subnet?(cidr)
+      ip_str, mask_str = cidr.to_s.split("/", 2)
+      return false unless ip_str && mask_str && mask_str =~ /^\d+$/ && (0..32).include?(mask_str.to_i)
+      ip = IPAddr.new(ip_str) rescue nil
+      return false unless ip && ip.ipv4?
+      (ip.mask(mask_str.to_i).to_s == ip_str)
+    rescue
+      false
+    end
+
+    def normalize_cidr(cidr)
+      ip_str, mask_str = cidr.to_s.split("/", 2)
+      return nil unless ip_str && mask_str && mask_str =~ /^\d+$/ && (0..32).include?(mask_str.to_i)
+      ip = IPAddr.new(ip_str) rescue nil
+      return nil unless ip&.ipv4?
+      "#{ip.mask(mask_str.to_i)}/#{mask_str.to_i}"
+    rescue
+      nil
+    end
+
+    def cidr_overlap?(a, b)
+      ip_a, mask_a = a.to_s.split("/", 2); ip_b, mask_b = b.to_s.split("/", 2)
+      return false unless mask_a && mask_b
+      na = IPAddr.new(ip_a).mask(mask_a.to_i)
+      nb = IPAddr.new(ip_b).mask(mask_b.to_i)
+      na.include?(IPAddr.new(ip_b)) || nb.include?(IPAddr.new(ip_a))
+    rescue
+      false
+    end
+
+    def each_docker_cidr(ignore_network: nil)
+      out, _e, st = Open3.capture3("docker", "network", "ls", "-q")
+      return [] unless st.success?
+      out.split.each_slice(50).flat_map do |chunk|
+        o, _e2, st2 = Open3.capture3("docker", "network", "inspect", *chunk)
+        next [] unless st2.success?
+        JSON.parse(o).filter_map do |net|
+          next if ignore_network && net["Name"] == ignore_network
+          (net.dig("IPAM","Config") || []).map { |cfg| normalize_cidr(cfg["Subnet"]) }.compact
+        end.flatten
+      end
+    end
+
+    def docker_subnet_conflicts?(target_cidr, ignore_network: nil)
+      t_norm = normalize_cidr(target_cidr)
+      return false unless t_norm
+      each_docker_cidr(ignore_network: ignore_network).any? { |c| cidr_overlap?(t_norm, c) }
+    end
+  end
+end

data/lib/vagrant-docker-networks-manager/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module VagrantDockerNetworksManager
+  VERSION = begin
+    path = File.expand_path("VERSION", __dir__)
+    File.exist?(path) ? File.read(path).strip : "0.1.0"
+  rescue
+    "0.1.0"
+  end
+end

data/lib/vagrant-docker-networks-manager.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "vagrant-docker-networks-manager/version"
+require_relative "vagrant-docker-networks-manager/plugin"

data/locales/en.yml

@@ -0,0 +1,142 @@
+en:
+  emoji:
+    success:  "✅"
+    info:     "🔍"
+    ongoing:  "🔁"
+    warning:  "⚠️"
+    error:    "❌"
+    version:  "💾"
+    broom:    "🧹"
+    question: "❓"
+  messages:
+    network_exists_adopted: "Docker network '%{name}' already exists (adopted by this project)."
+    network_exists: "Docker network '%{name}' already exists."
+    create_failed: "Failed to create network with: %{cmd}."
+    remove_network: "Removing Docker network '%{name}'."
+    nothing_to_do: "Nothing to do (no network created by this 'up')."
+    not_owned: "Network '%{name}' is not marked by this plugin, ignoring."
+    no_networks: "No networks managed by the plugin."
+    networks_header: "Docker networks managed by the plugin:"
+    prune_none: "No network to remove."
+    confirm_continue: "%{prompt} Continue? [y/N]"
+  usage:
+    init:    "Usage: vagrant network init <name> <subnet>"
+    destroy: "Usage: vagrant network destroy <name> [--with-containers]"
+    reload:  "Usage: vagrant network reload <name>"
+    info:    "Usage: vagrant network info <name>"
+    list:    "Usage: vagrant network list"
+    prune:   "Usage: vagrant network prune"
+    rename:  "Usage: vagrant network rename <old> <new> [subnet]"
+  errors:
+    docker_unavailable: "Docker is unavailable. Make sure it is installed and running."
+    unknown_command: "Unknown command. Try: vagrant network help."
+    network_exists: "Network already exists."
+    network_not_found: "Network not found."
+    invalid_subnet: "Invalid subnet."
+    subnet_in_use: "Subnet already in use or overlapping."
+    cancelled: "Cancelled by user."
+    inspect_failed: "docker network inspect failed."
+    create_failed: "Failed to create network."
+    remove_failed: "Failed to remove network."
+    target_exists: "Target network already exists."
+    partial_failure: "Partial failure."
+    invalid_name: "Invalid network name. Must be 1-127 characters, start with a letter or digit, and contain only letters, digits, underscores (_), periods (.), or hyphens (-)."
+    invalid_type: "network_type must be 'bridge' or 'macvlan'."
+    invalid_gateway: "network_gateway must be an IPv4 string."
+    invalid_parent: "network_parent must be a String (host interface)."
+    invalid_attachable: "network_attachable must be boolean."
+    invalid_ipv6: "enable_ipv6 must be boolean."
+    invalid_ip_range: "ip_range must be an IPv4/CIDR string."
+    invalid_cleanup: "cleanup_on_destroy must be boolean."
+    invalid_locale: "locale must be 'fr' or 'en'."
+  prompts:
+    delete_network: "This will delete network '%{name}'."
+    delete_network_only: "This will delete network '%{name}' (containers will be left untouched)."
+    delete_network_with_containers: "This will delete network '%{name}' and remove %{count} attached container(s)."
+    reload_network: "This will delete and recreate '%{name}'."
+    rename_network: "Rename '%{old}' → '%{new}'?"
+    rename_same_subnet: "Rename '%{old}' → '%{new}'?"
+    reload_same: "Reload the network '%{name}' with the same subnet and reconnect its containers."
+    prune: "Delete %{count} unused network(s)?"
+  log:
+    create_network: "Create network '%{name}' (subnet: %{subnet})."
+    remove_network: "Remove network '%{name}'."
+    remove_container: "Remove container '%{name}'."
+    disconnect_container: "Disconnect container '%{name}'."
+    subnet_changed: "Subnet changed — containers not auto-reconnected."
+    info_header: "Info for '%{name}':"
+    version_line: "v%{version}."
+    ok: "OK."
+  docker_provider:
+    network_create: "Creating network…"
+    creating: "Creating Docker container…"
+    created: "Container created."
+    network_connect: "Connecting container to network…"
+    messages:
+      starting: "Starting container…"
+  help:
+    general_title: "Usage: vagrant network <command> [args] [options]"
+    commands:
+      init:    "network init <name> <subnet>"
+      destroy: "network destroy <name>"
+      reload:  "network reload <name>"
+      info:    "network info <name>"
+      list:    "network list"
+      prune:   "network prune"
+      rename:  "network rename <old> <new> [<subnet>]"
+      version: "network version"
+    topic:
+      init: |
+        🔧 Help: vagrant network init
+          Usage:
+            vagrant network init <name> <subnet>
+          Description:
+            Creates a bridge Docker network with IPv4/CIDR, validates format and conflicts.
+          Examples:
+            vagrant network init mynet 172.28.100.0/26
+      destroy: |
+        🗑️  Help: vagrant network destroy
+          Usage:
+            vagrant network destroy <name> [--with-containers] [--yes]
+          Description:
+            Deletes the Docker network. By default, containers are only disconnected.
+            With --with-containers, attached containers are also removed (docker rm -f).
+      reload: |
+        🔁 Help: vagrant network reload
+          Usage:
+            vagrant network reload <name> [--yes]
+          Description:
+            Recreates the network with same subnets and tries to reconnect containers.
+            Returns partial failure if some containers fail to reconnect.
+      rename: |
+        ✏️  Help: vagrant network rename
+          Usage:
+            vagrant network rename <old> <new> [<subnet>] [--yes]
+          Description:
+            If subnet changes or name is same, old network is removed/recreated.
+            Fails if removing the old network is not possible.
+      prune: |
+        🧹 Help: vagrant network prune
+          Usage:
+            vagrant network prune [--yes]
+          Description:
+            Removes plugin-managed networks without attached containers.
+      list: |
+        📋 Help: vagrant network list
+          Usage:
+            vagrant network list [--json]
+          Description:
+            Lists plugin-managed networks with driver/scope and subnets.
+      version: |
+        💾 Help: vagrant network version
+          Usage:
+            vagrant network version [--json]
+          Description:
+            Prints the plugin version. With --json, prints a normalized JSON payload.
+      info: |
+        🔍 Help: vagrant network info
+          Usage:
+            vagrant network info <name> [--json]
+          Description:
+            Shows details for a Docker network: driver, subnet(s), and connected containers.
+            With --json, prints a normalized JSON payload.