vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/docker/client.rb

@@ -1,194 +0,0 @@
-require 'digest/sha1'
-
-module VagrantPlugins
-  module DockerProvisioner
-    class Client
-      def initialize(machine)
-        @machine = machine
-      end
-
-      def build_images(images)
-        @machine.communicate.tap do |comm|
-          images.each do |path, opts|
-            @machine.ui.info(I18n.t("vagrant.docker_building_single", path: path))
-            comm.sudo("docker build #{opts[:args]} #{path}") do |type, data|
-              handle_comm(type, data)
-            end
-          end
-        end
-      end
-
-      def pull_images(*images)
-        @machine.communicate.tap do |comm|
-          images.each do |image|
-            @machine.ui.info(I18n.t("vagrant.docker_pulling_single", name: image))
-            comm.sudo("docker pull #{image}") do |type, data|
-              handle_comm(type, data)
-            end
-          end
-        end
-      end
-
-      def start_service
-        if !daemon_running? && @machine.guest.capability?(:docker_start_service)
-          @machine.guest.capability(:docker_start_service)
-        end
-      end
-
-      def daemon_running?
-        @machine.guest.capability(:docker_daemon_running)
-      end
-
-      def run(containers)
-        containers.each do |name, config|
-          cids_dir = "/var/lib/vagrant/cids"
-          config[:cidfile] ||= "#{cids_dir}/#{Digest::SHA1.hexdigest name}"
-
-          @machine.ui.info(I18n.t("vagrant.docker_running", name: name))
-          @machine.communicate.sudo("mkdir -p #{cids_dir}")
-          run_container({
-            name: name,
-            original_name: name,
-          }.merge(config))
-        end
-      end
-
-      def run_container(config)
-        raise "Container's cidfile was not provided!" if !config[:cidfile]
-
-        id = "$(cat #{config[:cidfile]})"
-
-        if container_exists?(id)
-          if container_args_changed?(config)
-            @machine.ui.info(I18n.t("vagrant.docker_restarting_container_args",
-              name: config[:name],
-            ))
-            stop_container(id)
-            create_container(config)
-          elsif container_image_changed?(config)
-            @machine.ui.info(I18n.t("vagrant.docker_restarting_container_image",
-              name: config[:name],
-            ))
-            stop_container(id)
-            create_container(config)
-          else
-            start_container(id)
-          end
-        else
-          create_container(config)
-        end
-      end
-
-      def container_exists?(id)
-        lookup_container(id, true)
-      end
-
-      def start_container(id)
-        if !container_running?(id)
-          @machine.communicate.sudo("docker start #{id}")
-        end
-      end
-
-      def stop_container(id)
-        @machine.communicate.sudo %[
-          docker stop #{id}
-          docker rm #{id}
-        ]
-      end
-
-      def container_running?(id)
-        lookup_container(id)
-      end
-
-      def container_image_changed?(config)
-        # Returns true if there is a container running with the given :name,
-        # and the container is not using the latest :image.
-
-        # Here, "docker inspect <container>" returns the id of the image
-        # that the container is using. We check that the latest image that
-        # has been built with that name (:image)  matches the one that the
-        # container is running.
-        cmd = ("docker inspect --format='{{.Image}}' #{config[:name]} |" +
-               " grep $(docker images -q #{config[:image]})")
-        return !@machine.communicate.test(cmd)
-      end
-
-      def container_args_changed?(config)
-        path = container_data_path(config)
-        return true if !path.exist?
-
-        args = container_run_args(config)
-        sha  = Digest::SHA1.hexdigest(args)
-        return true if path.read.chomp != sha
-
-        return false
-      end
-
-      def create_container(config)
-        args = container_run_args(config)
-
-        @machine.communicate.sudo %[rm -f "#{config[:cidfile]}"]
-        @machine.communicate.sudo %[docker run #{args}]
-
-        sha  = Digest::SHA1.hexdigest(args)
-        container_data_path(config).open("w+") do |f|
-          f.write(sha)
-        end
-      end
-
-      def lookup_container(id, list_all = false)
-        docker_ps = "sudo docker ps -q"
-        docker_ps << " -a" if list_all
-        @machine.communicate.tap do |comm|
-          # Docker < 0.7.0 stores container IDs using its short version while
-          # recent versions use the full container ID
-          # using full container ID from now on.
-          return comm.test("#{docker_ps} --no-trunc | grep -wFq #{id}")
-        end
-      end
-
-      def container_name(config)
-        name = config[:name]
-
-        # If the name is the automatically assigned name, then
-        # replace the "/" with "-" because "/" is not a valid
-        # character for a docker container name.
-        name = name.gsub("/", "-") if name == config[:original_name]
-        name
-      end
-
-      def container_run_args(config)
-        name = container_name(config)
-
-        args = "--cidfile=#{config[:cidfile]} "
-        args << "-d " if config[:daemonize]
-        args << "--name #{name} " if name && config[:auto_assign_name]
-        args << "--restart=#{config[:restart]}" if config[:restart]
-        args << " #{config[:args]}" if config[:args]
-
-        "#{args} #{config[:image]} #{config[:cmd]}".strip
-      end
-
-      def container_data_path(config)
-        name = container_name(config)
-        @machine.data_dir.join("docker-#{name}")
-      end
-
-      protected
-
-      # This handles outputting the communication data back to the UI
-      def handle_comm(type, data)
-        if [:stderr, :stdout].include?(type)
-          # Clear out the newline since we add one
-          data = data.chomp
-          return if data.empty?
-
-          options = {}
-          #options[:color] = color if !config.keep_color
-
-          @machine.ui.info(data.chomp, options)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/docker/config.rb

@@ -1,86 +0,0 @@
-require 'set'
-
-module VagrantPlugins
-  module DockerProvisioner
-    class Config < Vagrant.plugin("2", :config)
-      attr_reader :images
-      attr_accessor :post_install_provisioner
-
-      def initialize
-        @images = Set.new
-        @post_install_provisioner = nil
-
-        @__build_images   = []
-        @__containers     = Hash.new { |h, k| h[k] = {} }
-      end
-
-      # Accessor for internal state.
-      def build_images
-        @__build_images
-      end
-
-      # Accessor for the internal state.
-      def containers
-        @__containers
-      end
-
-      # Defines an image to build using `docker build` within the machine.
-      #
-      # @param [String] path Path to the Dockerfile to pass to
-      #   `docker build`.
-      def build_image(path, **opts)
-        @__build_images << [path, opts]
-      end
-
-      def images=(images)
-        @images = Set.new(images)
-      end
-
-      def pull_images(*images)
-        @images += images.map(&:to_s)
-      end
-
-      def post_install_provision(name, **options, &block)
-        # Abort
-        raise DockerError, :wrong_provisioner if options[:type] == "docker"
-
-        proxy = VagrantPlugins::Kernel_V2::VMConfig.new
-        proxy.provision(name, **options, &block)
-        @post_install_provisioner = proxy.provisioners.first
-      end
-
-      def run(name, **options)
-        @__containers[name.to_s] = options.dup
-      end
-
-      def merge(other)
-        super.tap do |result|
-          result.pull_images(*(other.images + self.images))
-
-          build_images = @__build_images.dup
-          build_images += other.build_images
-          result.instance_variable_set(:@__build_images, build_images)
-
-          containers = {}
-          @__containers.each do |name, params|
-            containers[name] = params.dup
-          end
-          other.containers.each do |name, params|
-            containers[name] = @__containers[name].merge(params)
-          end
-
-          result.instance_variable_set(:@__containers, containers)
-        end
-      end
-
-      def finalize!
-        @__containers.each do |name, params|
-          params[:image] ||= name
-          params[:auto_assign_name] = true if !params.key?(:auto_assign_name)
-          params[:daemonize] = true if !params.key?(:daemonize)
-          params[:restart] = "always" if !params.key?(:restart)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/docker/installer.rb

@@ -1,36 +0,0 @@
-module VagrantPlugins
-  module DockerProvisioner
-    class Installer
-      def initialize(machine)
-        @machine = machine
-      end
-
-      # This handles verifying the Docker installation, installing it if it was
-      # requested, and so on. This method will raise exceptions if things are
-      # wrong.
-      # @return [Boolean] - false if docker cannot be detected on machine, else
-      #                     true if docker installs correctly or is installed
-      def ensure_installed
-        if !@machine.guest.capability?(:docker_installed)
-          @machine.ui.warn(I18n.t("vagrant.docker_cant_detect"))
-          return false
-        end
-
-        if !@machine.guest.capability(:docker_installed)
-          @machine.ui.detail(I18n.t("vagrant.docker_installing"))
-          @machine.guest.capability(:docker_install)
-        end
-
-        if !@machine.guest.capability(:docker_installed)
-          raise DockerError, :install_failed
-        end
-
-        if @machine.guest.capability?(:docker_configure_vagrant_user)
-          @machine.guest.capability(:docker_configure_vagrant_user)
-        end
-
-        true
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module DockerProvisioner
-    class Plugin < Vagrant.plugin("2")
-      name "docker"
-      description <<-DESC
-      Provides support for provisioning your virtual machines with
-      Docker images and containers.
-      DESC
-
-      config(:docker, :provisioner) do
-        require_relative "config"
-        Config
-      end
-
-      guest_capability("debian", "docker_install") do
-        require_relative "cap/debian/docker_install"
-        Cap::Debian::DockerInstall
-      end
-
-      guest_capability("debian", "docker_start_service") do
-        require_relative "cap/debian/docker_start_service"
-        Cap::Debian::DockerStartService
-      end
-
-      guest_capability("fedora", "docker_install") do
-        require_relative "cap/fedora/docker_install"
-        Cap::Fedora::DockerInstall
-      end
-
-      guest_capability("redhat", "docker_install") do
-        require_relative "cap/redhat/docker_install"
-        Cap::Redhat::DockerInstall
-      end
-
-      guest_capability("redhat", "docker_start_service") do
-        require_relative "cap/redhat/docker_start_service"
-        Cap::Redhat::DockerStartService
-      end
-
-      guest_capability("linux", "docker_installed") do
-        require_relative "cap/linux/docker_installed"
-        Cap::Linux::DockerInstalled
-      end
-
-      guest_capability("linux", "docker_configure_vagrant_user") do
-        require_relative "cap/linux/docker_configure_vagrant_user"
-        Cap::Linux::DockerConfigureVagrantUser
-      end
-
-      guest_capability("linux", "docker_daemon_running") do
-        require_relative "cap/linux/docker_daemon_running"
-        Cap::Linux::DockerDaemonRunning
-      end
-
-      guest_capability("windows", "docker_daemon_running") do
-        require_relative "cap/windows/docker_daemon_running"
-        Cap::Windows::DockerDaemonRunning
-      end
-
-      provisioner(:docker) do
-        require_relative "provisioner"
-        Provisioner
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/docker/provisioner.rb

@@ -1,62 +0,0 @@
-require_relative "client"
-require_relative "installer"
-
-module VagrantPlugins
-  module DockerProvisioner
-    class DockerError < Vagrant::Errors::VagrantError
-      error_namespace("vagrant.provisioners.docker")
-    end
-
-    class Provisioner < Vagrant.plugin("2", :provisioner)
-      def initialize(machine, config, installer = nil, client = nil)
-        super(machine, config)
-
-        @installer = installer || Installer.new(@machine)
-        @client    = client    || Client.new(@machine)
-      end
-
-      def provision
-        @logger = Log4r::Logger.new("vagrant::provisioners::docker")
-
-        @logger.info("Checking for Docker installation...")
-        if @installer.ensure_installed
-          if !config.post_install_provisioner.nil?
-            @logger.info("Running post setup provision script...")
-            env = {
-                  callable: method(:run_provisioner),
-                  provisioner: config.post_install_provisioner,
-                  machine: machine}
-            machine.env.hook(:run_provisioner, env)
-          end
-        end
-
-        # Attempt to start service if not running
-        @client.start_service
-        raise DockerError, :not_running if !@client.daemon_running?
-
-        if config.images.any?
-          @machine.ui.info(I18n.t("vagrant.docker_pulling_images"))
-          @client.pull_images(*config.images)
-        end
-
-        if config.build_images.any?
-          @machine.ui.info(I18n.t("vagrant.docker_building_images"))
-          @client.build_images(config.build_images)
-        end
-
-        if config.containers.any?
-          @machine.ui.info(I18n.t("vagrant.docker_starting_containers"))
-          @client.run(config.containers)
-        end
-      end
-
-      def run_provisioner(env)
-        klass  = Vagrant.plugin("2").manager.provisioners[env[:provisioner].type]
-        result = klass.new(env[:machine], env[:provisioner].config)
-        result.config.finalize!
-
-        result.provision
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/file/config.rb

@@ -1,31 +0,0 @@
-require "pathname"
-
-require "vagrant"
-
-module VagrantPlugins
-  module FileUpload
-    class Config < Vagrant.plugin("2", :config)
-      attr_accessor :source
-      attr_accessor :destination
-
-      def validate(machine)
-        errors = _detected_errors
-        if !source
-          errors << I18n.t("vagrant.provisioners.file.no_source_file")
-        end
-        if !destination
-          errors << I18n.t("vagrant.provisioners.file.no_dest_file")
-        end
-        if source
-          s = Pathname.new(source).expand_path(machine.env.root_path)
-          if !s.exist?
-            errors << I18n.t("vagrant.provisioners.file.path_invalid",
-                              path: s.to_s)
-          end
-        end
-
-        { "File provisioner" => errors }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/file/plugin.rb

@@ -1,23 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module FileUpload
-    class Plugin < Vagrant.plugin("2")
-      name "file"
-      description <<-DESC
-      Provides support for provisioning your virtual machines with
-      uploaded files.
-      DESC
-
-      config(:file, :provisioner) do
-        require File.expand_path("../config", __FILE__)
-        Config
-      end
-
-      provisioner(:file) do
-        require File.expand_path("../provisioner", __FILE__)
-        Provisioner
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/file/provisioner.rb

@@ -1,58 +0,0 @@
-module VagrantPlugins
-  module FileUpload
-    class Provisioner < Vagrant.plugin("2", :provisioner)
-      def provision
-        @machine.communicate.tap do |comm|
-          source = File.expand_path(config.source)
-          destination = expand_guest_path(config.destination)
-
-          # if source is a directory, make it then trim destination with dirname
-          # Make sure the remote path exists
-          if File.directory?(source)
-            # We need to make sure the actual destination folder
-            # also exists before uploading, otherwise
-            # you will get nested folders
-            #
-            # https://serverfault.com/questions/538368/make-scp-always-overwrite-or-create-directory
-            # https://unix.stackexchange.com/questions/292641/get-scp-path-behave-like-rsync-path/292732
-            command = "mkdir -p \"%s\"" % destination
-            if !destination.end_with?(File::SEPARATOR) &&
-                !source.end_with?("#{File::SEPARATOR}.")
-              # We also need to append a '/.' to the source folder so we copy
-              # the contents rather than the folder itself, in case a users
-              # destination folder differs from its source
-              #
-              # If source is set as `source/` it will lose the trailing
-              # slash due to how `File.expand_path` works, so we don't need
-              # a conditional for that case.
-              if @machine.config.vm.communicator == :winrm
-                # windows needs an array of paths because of the
-                # winrm-fs function Vagrant is using to upload file/folder.
-                source = Dir["#{source}#{File::SEPARATOR}*"]
-              else
-                source << "#{File::SEPARATOR}."
-              end
-            end
-          else
-            command = "mkdir -p \"%s\"" % File.dirname(destination)
-          end
-          comm.execute(command)
-
-          # now upload the file
-          comm.upload(source, destination)
-        end
-      end
-
-      private
-
-      # Expand the guest path if the guest has the capability
-      def expand_guest_path(destination)
-        if machine.guest.capability?(:shell_expand_guest_path)
-          machine.guest.capability(:shell_expand_guest_path, destination)
-        else
-          destination
-        end
-      end
-    end
-  end
-end