vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,176 +0,0 @@
-require "json"
-require "log4r"
-
-require_relative "./driver/compose"
-
-module VagrantPlugins
-  module DockerProvider
-    class Driver
-      # The executor is responsible for actually executing Docker commands.
-      # This is set by the provider, but defaults to local execution.
-      attr_accessor :executor
-
-      def initialize
-        @logger   = Log4r::Logger.new("vagrant::docker::driver")
-        @executor = Executor::Local.new
-      end
-
-      def build(dir, **opts, &block)
-        args   = Array(opts[:extra_args])
-        args   << dir
-        result = execute('docker', 'build', *args, &block)
-        matches = result.scan(/Successfully built (.+)$/i)
-        if matches.empty?
-          # This will cause a stack trace in Vagrant, but it is a bug
-          # if this happens anyways.
-          raise "UNKNOWN OUTPUT: #{result}"
-        end
-
-        # Return the last match, and the capture of it
-        matches[-1][0]
-      end
-
-      def create(params, **opts, &block)
-        image   = params.fetch(:image)
-        links   = params.fetch(:links)
-        ports   = Array(params[:ports])
-        volumes = Array(params[:volumes])
-        name    = params.fetch(:name)
-        cmd     = Array(params.fetch(:cmd))
-        env     = params.fetch(:env)
-        expose  = Array(params[:expose])
-
-        run_cmd = %W(docker run --name #{name})
-        run_cmd << "-d" if params[:detach]
-        run_cmd += env.map { |k,v| ['-e', "#{k}=#{v}"] }
-        run_cmd += expose.map { |p| ['--expose', "#{p}"] }
-        run_cmd += links.map { |k, v| ['--link', "#{k}:#{v}"] }
-        run_cmd += ports.map { |p| ['-p', p.to_s] }
-        run_cmd += volumes.map { |v|
-          v = v.to_s
-          if v.include?(":") && @executor.windows?
-            host, guest = v.split(":", 2)
-            host = Vagrant::Util::Platform.windows_path(host)
-            # NOTE: Docker does not support UNC style paths (which also
-            # means that there's no long path support). Hopefully this
-            # will be fixed someday and the gsub below can be removed.
-            host.gsub!(/^[^A-Za-z]+/, "")
-            v = [host, guest].join(":")
-          end
-          ['-v', v.to_s]
-        }
-        run_cmd += %W(--privileged) if params[:privileged]
-        run_cmd += %W(-h #{params[:hostname]}) if params[:hostname]
-        run_cmd << "-t" if params[:pty]
-        run_cmd << "--rm=true" if params[:rm]
-        run_cmd += params[:extra_args] if params[:extra_args]
-        run_cmd += [image, cmd]
-
-        execute(*run_cmd.flatten, **opts, &block).chomp.lines.last
-      end
-
-      def state(cid)
-        case
-        when running?(cid)
-          :running
-        when created?(cid)
-          :stopped
-        else
-          :not_created
-        end
-      end
-
-      def created?(cid)
-        result = execute('docker', 'ps', '-a', '-q', '--no-trunc').to_s
-        result =~ /^#{Regexp.escape cid}$/
-      end
-
-      def image?(id)
-        result = execute('docker', 'images', '-q').to_s
-        result =~ /^#{Regexp.escape(id)}$/
-      end
-
-      def running?(cid)
-        result = execute('docker', 'ps', '-q', '--no-trunc')
-        result =~ /^#{Regexp.escape cid}$/m
-      end
-
-      def privileged?(cid)
-        inspect_container(cid)['HostConfig']['Privileged']
-      end
-
-      def login(email, username, password, server)
-        cmd = %W(docker login)
-        cmd += ["-e", email] if email != ""
-        cmd += ["-u", username] if username != ""
-        cmd += ["-p", password] if password != ""
-        cmd << server if server && server != ""
-
-        execute(*cmd.flatten)
-      end
-
-      def logout(server)
-        cmd = %W(docker logout)
-        cmd << server if server && server != ""
-        execute(*cmd.flatten)
-      end
-
-      def pull(image)
-        execute('docker', 'pull', image)
-      end
-
-      def start(cid)
-        if !running?(cid)
-          execute('docker', 'start', cid)
-          # This resets the cached information we have around, allowing `vagrant reload`s
-          # to work properly
-          @data = nil
-        end
-      end
-
-      def stop(cid, timeout)
-        if running?(cid)
-          execute('docker', 'stop', '-t', timeout.to_s, cid)
-        end
-      end
-
-      def rm(cid)
-        if created?(cid)
-          execute('docker', 'rm', '-f', '-v', cid)
-        end
-      end
-
-      def rmi(id)
-        execute('docker', 'rmi', id)
-        return true
-      rescue Exception => e
-        return false if e.to_s.include?("is using it")
-        raise if !e.to_s.include?("No such image")
-      end
-
-      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
-      end
-
-      def all_containers
-        execute('docker', 'ps', '-a', '-q', '--no-trunc').to_s.split
-      end
-
-      def docker_bridge_ip
-        output = execute('/sbin/ip', '-4', 'addr', 'show', 'scope', 'global', 'docker0')
-        if output =~ /^\s+inet ([0-9.]+)\/[0-9]+\s+/
-          return $1.to_s
-        else
-          # TODO: Raise an user friendly message
-          raise 'Unable to fetch docker bridge IP!'
-        end
-      end
-
-      def execute(*cmd, **opts, &block)
-        @executor.execute(*cmd, **opts, &block)
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Errors
-      class DockerError < Vagrant::Errors::VagrantError
-        error_namespace("docker_provider.errors")
-      end
-
-      class CommunicatorNonDocker < DockerError
-        error_key(:communicator_non_docker)
-      end
-
-      class ComposeLockTimeoutError < DockerError
-        error_key(:compose_lock_timeout)
-      end
-
-      class ContainerNotRunningError < DockerError
-        error_key(:not_running)
-      end
-
-      class ContainerNotCreatedError < DockerError
-        error_key(:not_created)
-      end
-
-      class DockerComposeNotInstalledError < DockerError
-        error_key(:docker_compose_not_installed)
-      end
-
-      class ExecuteError < DockerError
-        error_key(:execute_error)
-      end
-
-      class ExecCommandRequired < DockerError
-        error_key(:exec_command_required)
-      end
-
-      class HostVMCommunicatorNotReady < DockerError
-        error_key(:host_vm_communicator_not_ready)
-      end
-
-      class ImageNotConfiguredError < DockerError
-        error_key(:docker_provider_image_not_configured)
-      end
-
-      class NfsWithoutPrivilegedError < DockerError
-        error_key(:docker_provider_nfs_without_privileged)
-      end
-
-      class PackageNotSupported < DockerError
-        error_key(:package_not_supported)
-      end
-
-      class StateNotRunning < DockerError
-        error_key(:state_not_running)
-      end
-
-      class StateStopped < DockerError
-        error_key(:state_stopped)
-      end
-
-      class SuspendNotSupported < DockerError
-        error_key(:suspend_not_supported)
-      end
-
-      class SyncedFolderNonDocker < DockerError
-        error_key(:synced_folder_non_docker)
-      end
-
-      class VagrantfileNotFound < DockerError
-        error_key(:vagrantfile_not_found)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/executor/local.rb

@@ -1,39 +0,0 @@
-require "vagrant/util/busy"
-require "vagrant/util/subprocess"
-
-module VagrantPlugins
-  module DockerProvider
-    module Executor
-      # The Local executor executes a Docker client that is running
-      # locally.
-      class Local
-        def execute(*cmd, **opts, &block)
-          # Append in the options for subprocess
-          cmd << { notify: [:stdout, :stderr] }
-
-          interrupted  = false
-          int_callback = ->{ interrupted = true }
-          result = ::Vagrant::Util::Busy.busy(int_callback) do
-            ::Vagrant::Util::Subprocess.execute(*cmd, &block)
-          end
-
-          result.stderr.gsub!("\r\n", "\n")
-          result.stdout.gsub!("\r\n", "\n")
-
-          if result.exit_code != 0 && !interrupted
-            raise Errors::ExecuteError,
-              command: cmd.inspect,
-              stderr: result.stderr,
-              stdout: result.stdout
-          end
-
-          result.stdout
-        end
-
-        def windows?
-          ::Vagrant::Util::Platform.windows? || ::Vagrant::Util::Platform.wsl?
-        end
-      end
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-require "vagrant/util/shell_quote"
-
-module VagrantPlugins
-  module DockerProvider
-    module Executor
-      # The Vagrant executor runs Docker over SSH against the given
-      # Vagrant-managed machine.
-      class Vagrant
-        def initialize(host_machine)
-          @host_machine = host_machine
-        end
-
-        def execute(*cmd, **opts, &block)
-          quote = '"'
-          cmd   = cmd.map do |a|
-            "#{quote}#{::Vagrant::Util::ShellQuote.escape(a, quote)}#{quote}"
-          end.join(" ")
-
-          # If we want stdin, we just run in a full subprocess
-          return ssh_run(cmd) if opts[:stdin]
-
-          # Add a start fence so we know when to start reading output.
-          # We have to do this because boot2docker outputs a login shell
-          # boot2docker version that we get otherwise and messes up output.
-          start_fence = "========== VAGRANT DOCKER BEGIN =========="
-          ssh_cmd     = "echo -n \"#{start_fence}\"; #{cmd}"
-
-          stderr = ""
-          stdout = ""
-          fenced = false
-          comm   = @host_machine.communicate
-          code   = comm.execute(ssh_cmd, error_check: false) do |type, data|
-            next if ![:stdout, :stderr].include?(type)
-            stderr << data if type == :stderr
-            stdout << data if type == :stdout
-
-            if !fenced
-              index = stdout.index(start_fence)
-              if index
-                fenced = true
-
-                index += start_fence.length
-                stdout = stdout[index..-1]
-                stdout.chomp!
-
-                # We're now fenced, send all the data through
-                if block
-                  block.call(:stdout, stdout) if stdout != ""
-                  block.call(:stderr, stderr) if stderr != ""
-                end
-              end
-            else
-              # If we're already fenced, just send the data through.
-              block.call(type, data) if block && fenced
-            end
-          end
-
-          if code != 0
-            raise Errors::ExecuteError,
-              command: cmd,
-              stderr: stderr.chomp,
-              stdout: stdout.chomp
-          end
-
-          stdout.chomp
-        end
-
-        def windows?
-          false
-        end
-
-        protected
-
-        def ssh_run(cmd)
-          @host_machine.action(
-            :ssh_run,
-            ssh_run_command: cmd,
-          )
-
-          ""
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    autoload :Action, File.expand_path("../action", __FILE__)
-    autoload :Driver, File.expand_path("../driver", __FILE__)
-    autoload :Errors, File.expand_path("../errors", __FILE__)
-
-    module Executor
-      autoload :Local, File.expand_path("../executor/local", __FILE__)
-      autoload :Vagrant, File.expand_path("../executor/vagrant", __FILE__)
-    end
-
-    class Plugin < Vagrant.plugin("2")
-      name "docker-provider"
-      description <<-EOF
-      The Docker provider allows Vagrant to manage and control
-      Docker containers.
-      EOF
-
-      provider(:docker, box_optional: true, parallel: true, defaultable: false) do
-        require_relative 'provider'
-        init!
-        Provider
-      end
-
-      command("docker-exec", primary: false) do
-        require_relative "command/exec"
-        init!
-        Command::Exec
-      end
-
-      command("docker-logs", primary: false) do
-        require_relative "command/logs"
-        init!
-        Command::Logs
-      end
-
-      command("docker-run", primary: false) do
-        require_relative "command/run"
-        init!
-        Command::Run
-      end
-
-      communicator(:docker_hostvm) do
-        require_relative "communicator"
-        init!
-        Communicator
-      end
-
-      config(:docker, :provider) do
-        require_relative 'config'
-        init!
-        Config
-      end
-
-      synced_folder(:docker) do
-        require File.expand_path("../synced_folder", __FILE__)
-        SyncedFolder
-      end
-
-      provider_capability("docker", "public_address") do
-        require_relative "cap/public_address"
-        Cap::PublicAddress
-      end
-
-      provider_capability("docker", "proxy_machine") do
-        require_relative "cap/proxy_machine"
-        Cap::ProxyMachine
-      end
-
-      protected
-
-      def self.init!
-        return if defined?(@_init)
-        I18n.load_path << File.expand_path(
-          "templates/locales/providers_docker.yml", Vagrant.source_root)
-        I18n.reload!
-        @_init = true
-      end
-    end
-  end
-end

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

@@ -1,205 +0,0 @@
-require "digest/md5"
-require "fileutils"
-require "thread"
-
-require "log4r"
-
-require "vagrant/util/silence_warnings"
-
-module VagrantPlugins
-  module DockerProvider
-    class Provider < Vagrant.plugin("2", :provider)
-      @@host_vm_mutex = Mutex.new
-
-      def initialize(machine)
-        @logger  = Log4r::Logger.new("vagrant::provider::docker")
-        @machine = machine
-
-        if host_vm?
-          # We need to use a special communicator that proxies our
-          # SSH requests over our host VM to the container itself.
-          @machine.config.vm.communicator = :docker_hostvm
-        end
-      end
-
-      # @see Vagrant::Plugin::V2::Provider#action
-      def action(name)
-        action_method = "action_#{name}"
-        return Action.send(action_method) if Action.respond_to?(action_method)
-        nil
-      end
-
-      # Returns the driver instance for this provider.
-      def driver
-        if !@driver
-          if @machine.provider_config.compose
-            @driver = Driver::Compose.new(@machine)
-          else
-            @driver = Driver.new
-          end
-        end
-        if host_vm?
-          @driver.executor = Executor::Vagrant.new(host_vm)
-        end
-
-        @driver
-      end
-
-      # This returns the {Vagrant::Machine} that is our host machine.
-      # It does not perform any action on the machine or verify it is
-      # running.
-      #
-      # @return [Vagrant::Machine]
-      def host_vm
-        return @host_vm if @host_vm
-
-        vf_path           = @machine.provider_config.vagrant_vagrantfile
-        host_machine_name = @machine.provider_config.vagrant_machine || :default
-        if !vf_path
-          # We don't have a Vagrantfile path set, so we're going to use
-          # the default but we need to copy it into the data dir so that
-          # we don't write into our installation dir (we can't).
-          default_path = File.expand_path("../hostmachine/Vagrantfile", __FILE__)
-          vf_path      = @machine.env.data_dir.join("docker-host", "Vagrantfile")
-          begin
-            @machine.env.lock("docker-provider-hostvm") do
-              vf_path.dirname.mkpath
-              FileUtils.cp(default_path, vf_path)
-            end
-          rescue Vagrant::Errors::EnvironmentLockedError
-            # Lock contention, just retry
-            retry
-          end
-
-          # Set the machine name since we hardcode that for the default
-          host_machine_name = :default
-        end
-
-        # Expand it so that the home directories and so on get processed
-        # properly.
-        vf_path = File.expand_path(vf_path, @machine.env.root_path)
-
-        vf_file = File.basename(vf_path)
-        vf_path = File.dirname(vf_path)
-
-        # Create the env to manage this machine
-        @host_vm = Vagrant::Util::SilenceWarnings.silence! do
-          host_env = Vagrant::Environment.new(
-            cwd: vf_path,
-            home_path: @machine.env.home_path,
-            ui_class: @machine.env.ui_class,
-            vagrantfile_name: vf_file,
-          )
-
-          # If there is no root path, then the Vagrantfile wasn't found
-          # and it is an error...
-          raise Errors::VagrantfileNotFound if !host_env.root_path
-
-          host_env.machine(
-            host_machine_name,
-            host_env.default_provider(
-              exclude: [:docker],
-              force_default: false,
-            ))
-        end
-
-        @host_vm
-      end
-
-      # This acquires a lock on the host VM.
-      def host_vm_lock
-        hash = Digest::MD5.hexdigest(host_vm.data_dir.to_s)
-
-        # We do a process-level mutex on the outside, since we can
-        # wait for that a short amount of time. Then, we do a process lock
-        # on the inside, which will raise an exception if locked.
-        host_vm_mutex.synchronize do
-          @machine.env.lock(hash) do
-            return yield
-          end
-        end
-      end
-
-      # This is a process-local mutex that can be used by parallel
-      # providers to lock the host VM access.
-      def host_vm_mutex
-        @@host_vm_mutex
-      end
-
-      # This says whether or not Docker will be running within a VM
-      # rather than directly on our system. Docker needs to run in a VM
-      # when we're not on Linux, or not on a Linux that supports Docker.
-      def host_vm?
-        @machine.provider_config.force_host_vm
-      end
-
-      # Returns the SSH info for accessing the Container.
-      def ssh_info
-        # If the container isn't running, we can't SSH into it
-        return nil if state.id != :running
-
-        port_name = "#{@machine.config.ssh.guest_port}/tcp"
-        network   = driver.inspect_container(@machine.id)['NetworkSettings']
-
-        if network["Ports"][port_name].respond_to?(:first)
-          port_info = network["Ports"][port_name].first
-        else
-          ip = network["IPAddress"]
-          port = @machine.config.ssh.guest_port
-          if !ip.to_s.empty?
-            port_info = {
-              "HostIp" => ip,
-              "HostPort" => port
-            }
-          end
-        end
-
-        # If we were not able to identify the container's IP, we return nil
-        # here and we let Vagrant core deal with it ;)
-        return nil if port_info.nil? || port_info.empty?
-
-        {
-          host: port_info['HostIp'],
-          port: port_info['HostPort']
-        }
-      end
-
-      def state
-        state_id = nil
-        state_id = :not_created if !@machine.id
-
-        begin
-          state_id = :host_state_unknown if !state_id && \
-            host_vm? && !host_vm.communicate.ready?
-        rescue Errors::VagrantfileNotFound
-          state_id = :host_state_unknown
-        end
-
-        state_id = :not_created if !state_id && \
-          (!@machine.id || !driver.created?(@machine.id))
-        state_id = driver.state(@machine.id) if @machine.id && !state_id
-        state_id = :unknown if !state_id
-
-        # This is a special pseudo-state so that we don't set the
-        # NOT_CREATED_ID while we're setting up the machine. This avoids
-        # clearing the data dir.
-        state_id = :preparing if @machine.id == "preparing"
-
-        short = state_id.to_s.gsub("_", " ")
-        long  = I18n.t("docker_provider.status.#{state_id}")
-
-        # If we're not created, then specify the special ID flag
-        if state_id == :not_created
-          state_id = Vagrant::MachineState::NOT_CREATED_ID
-        end
-
-        Vagrant::MachineState.new(state_id, short, long)
-      end
-
-      def to_s
-        id = @machine.id ? @machine.id : "new container"
-        "Docker (#{id})"
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
-      def usable?(machine, raise_error=false)
-        # These synced folders only work if the provider is Docker
-        if machine.provider_name != :docker
-          if raise_error
-            raise Errors::SyncedFolderNonDocker,
-              provider: machine.provider_name.to_s
-          end
-
-          return false
-        end
-
-        true
-      end
-
-      def prepare(machine, folders, _opts)
-        folders.each do |id, data|
-          next if data[:ignore]
-
-          host_path  = data[:hostpath]
-          guest_path = data[:guestpath]
-          machine.provider_config.volumes << "#{host_path}:#{guest_path}"
-        end
-      end
-    end
-  end
-end