vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,319 +0,0 @@
-require "pathname"
-
-require_relative "../../../lib/vagrant/util/platform"
-
-module VagrantPlugins
-  module DockerProvider
-    class Config < Vagrant.plugin("2", :config)
-      attr_accessor :image, :cmd, :ports, :volumes, :privileged
-
-      # Additional arguments to pass to `docker build` when creating
-      # an image using the build dir setting.
-      #
-      # @return [Array<String>]
-      attr_accessor :build_args
-
-      # The directory with a Dockerfile to build and use as the basis
-      # for this container. If this is set, "image" should not be set.
-      #
-      # @return [String]
-      attr_accessor :build_dir
-
-      # Use docker-compose to manage the lifecycle and environment for
-      # containers instead of using docker directly.
-      #
-      # @return [Boolean]
-      attr_accessor :compose
-
-      # Configuration Hash used for build the docker-compose composition
-      # file. This can be used for adding networks or volumes.
-      #
-      # @return [Hash]
-      attr_accessor :compose_configuration
-
-      # An optional file name of a Dockerfile to be used when building
-      # the image. This requires Docker >1.5.0.
-      #
-      # @return [String]
-      attr_accessor :dockerfile
-
-      # Additional arguments to pass to `docker run` when creating
-      # the container for the first time. This is an array of args.
-      #
-      # @return [Array<String>]
-      attr_accessor :create_args
-
-      # Environmental variables to set in the container.
-      #
-      # @return [Hash]
-      attr_accessor :env
-
-      # Ports to expose from the container but not to the host machine.
-      # This is useful for links.
-      #
-      # @return [Array<Integer>]
-      attr_accessor :expose
-
-      # Force using a proxy VM, even on Linux hosts.
-      #
-      # @return [Boolean]
-      attr_accessor :force_host_vm
-
-      # True if the Docker container exposes SSH access. If this is true,
-      # then Vagrant can do a bunch more things like setting the hostname,
-      # provisioning, etc.
-      attr_accessor :has_ssh
-
-      # Options for the build dir synced folder if a host VM is in use.
-      #
-      # @return [Hash]
-      attr_accessor :host_vm_build_dir_options
-
-      # The name for the container. This must be unique for all containers
-      # on the proxy machine if it is made.
-      #
-      # @return [String]
-      attr_accessor :name
-
-      # If true, the image will be pulled on every `up` and `reload`
-      # to ensure the latest image.
-      #
-      # @return [Bool]
-      attr_accessor :pull
-
-      # True if the docker container is meant to stay in the "running"
-      # state (is a long running process). By default this is true.
-      #
-      # @return [Boolean]
-      attr_accessor :remains_running
-
-      # The time to wait before sending a SIGTERM to the container
-      # when it is stopped.
-      #
-      # @return [Integer]
-      attr_accessor :stop_timeout
-
-      # The name of the machine in the Vagrantfile set with
-      # "vagrant_vagrantfile" that will be the docker host. Defaults
-      # to "default"
-      #
-      # See the "vagrant_vagrantfile" docs for more info.
-      #
-      # @return [String]
-      attr_accessor :vagrant_machine
-
-      # The path to the Vagrantfile that contains a VM that will be
-      # started as the Docker host if needed (Windows, OS X, Linux
-      # without container support).
-      #
-      # Defaults to a built-in Vagrantfile that will load boot2docker.
-      #
-      # NOTE: This only has an effect if Vagrant needs a Docker host.
-      # Vagrant determines this automatically based on the environment
-      # it is running in.
-      #
-      # @return [String]
-      attr_accessor :vagrant_vagrantfile
-
-      #--------------------------------------------------------------
-      # Auth Settings
-      #--------------------------------------------------------------
-
-      # Server to authenticate to. If blank, will use the default
-      # Docker authentication endpoint (which is the Docker Hub at the
-      # time of this comment).
-      #
-      # @return [String]
-      attr_accessor :auth_server
-
-      # Email for logging in to a remote Docker server.
-      #
-      # @return [String]
-      attr_accessor :email
-
-      # Email for logging in to a remote Docker server.
-      #
-      # @return [String]
-      attr_accessor :username
-
-      # Password for logging in to a remote Docker server. If this is
-      # not blank, then Vagrant will run `docker login` prior to any
-      # Docker runs.
-      #
-      # The presence of auth will also force the Docker environments to
-      # serialize on `up` so that different users/passwords don't overlap.
-      #
-      # @return [String]
-      attr_accessor :password
-
-      def initialize
-        @build_args = []
-        @build_dir  = UNSET_VALUE
-        @cmd        = UNSET_VALUE
-        @compose    = UNSET_VALUE
-        @compose_configuration = {}
-        @create_args = UNSET_VALUE
-        @dockerfile = UNSET_VALUE
-        @env        = {}
-        @expose     = []
-        @force_host_vm = UNSET_VALUE
-        @has_ssh    = UNSET_VALUE
-        @host_vm_build_dir_options = UNSET_VALUE
-        @image      = UNSET_VALUE
-        @name       = UNSET_VALUE
-        @links      = []
-        @pull       = UNSET_VALUE
-        @ports      = UNSET_VALUE
-        @privileged = UNSET_VALUE
-        @remains_running = UNSET_VALUE
-        @stop_timeout = UNSET_VALUE
-        @volumes    = []
-        @vagrant_machine = UNSET_VALUE
-        @vagrant_vagrantfile = UNSET_VALUE
-
-        @auth_server = UNSET_VALUE
-        @email    = UNSET_VALUE
-        @username = UNSET_VALUE
-        @password = UNSET_VALUE
-      end
-
-      def link(name)
-        @links << name
-      end
-
-      def merge(other)
-        super.tap do |result|
-          # This is a bit confusing. The tests explain the purpose of this
-          # better than the code lets on, I believe.
-          if (other.image != UNSET_VALUE || other.build_dir != UNSET_VALUE) &&
-            (other.image == UNSET_VALUE || other.build_dir == UNSET_VALUE)
-            if other.image != UNSET_VALUE && @build_dir != UNSET_VALUE
-              result.build_dir = nil
-            end
-
-            if other.build_dir != UNSET_VALUE && @image != UNSET_VALUE
-              result.image = nil
-            end
-          end
-
-          env = {}
-          env.merge!(@env) if @env
-          env.merge!(other.env) if other.env
-          result.env = env
-
-          expose = self.expose.dup
-          expose += other.expose
-          result.instance_variable_set(:@expose, expose)
-
-          links = _links.dup
-          links += other._links
-          result.instance_variable_set(:@links, links)
-        end
-      end
-
-      def finalize!
-        @build_args = [] if @build_args == UNSET_VALUE
-        @build_dir  = nil if @build_dir == UNSET_VALUE
-        @cmd        = [] if @cmd == UNSET_VALUE
-        @compose    = false if @compose == UNSET_VALUE
-        @create_args = [] if @create_args == UNSET_VALUE
-        @dockerfile = nil if @dockerfile == UNSET_VALUE
-        @env       ||= {}
-        @has_ssh    = false if @has_ssh == UNSET_VALUE
-        @image      = nil if @image == UNSET_VALUE
-        @name       = nil if @name == UNSET_VALUE
-        @pull       = false if @pull == UNSET_VALUE
-        @ports      = [] if @ports == UNSET_VALUE
-        @privileged = false if @privileged == UNSET_VALUE
-        @remains_running = true if @remains_running == UNSET_VALUE
-        @stop_timeout = 1 if @stop_timeout == UNSET_VALUE
-        @vagrant_machine = nil if @vagrant_machine == UNSET_VALUE
-        @vagrant_vagrantfile = nil if @vagrant_vagrantfile == UNSET_VALUE
-
-        @auth_server = nil if @auth_server == UNSET_VALUE
-        @email = "" if @email == UNSET_VALUE
-        @username = "" if @username == UNSET_VALUE
-        @password = "" if @password == UNSET_VALUE
-
-        if @host_vm_build_dir_options == UNSET_VALUE
-          @host_vm_build_dir_options = nil
-        end
-
-        # On non-linux platforms (where there is no native docker), force the
-        # host VM. Other users can optionally disable this by setting the
-        # value explicitly to false in their Vagrantfile.
-        if @force_host_vm == UNSET_VALUE
-          @force_host_vm = !Vagrant::Util::Platform.linux? &&
-            !Vagrant::Util::Platform.darwin? &&
-            !Vagrant::Util::Platform.windows?
-        end
-
-        # The machine name must be a symbol
-        @vagrant_machine = @vagrant_machine.to_sym if @vagrant_machine
-
-        @expose.uniq!
-
-        if @compose_configuration.is_a?(Hash)
-          # Ensures configuration is using basic types
-          @compose_configuration = JSON.parse(@compose_configuration.to_json)
-        end
-      end
-
-      def validate(machine)
-        errors = _detected_errors
-
-        if @build_dir && @image
-          errors << I18n.t("docker_provider.errors.config.both_build_and_image")
-        end
-
-        if !@build_dir && !@image
-          errors << I18n.t("docker_provider.errors.config.build_dir_or_image")
-        end
-
-        if @build_dir
-          build_dir_pn = Pathname.new(@build_dir)
-          if !build_dir_pn.directory?
-            errors << I18n.t("docker_provider.errors.config.build_dir_invalid")
-          end
-        end
-
-        if !@compose_configuration.is_a?(Hash)
-          errors << I18n.t("docker_provider.errors.config.compose_configuration_hash")
-        end
-
-        if @compose && @force_host_vm
-          errors << I18n.t("docker_provider.errors.config.compose_force_vm")
-        end
-
-        if !@create_args.is_a?(Array)
-          errors << I18n.t("docker_provider.errors.config.create_args_array")
-        end
-
-        @links.each do |link|
-          parts = link.split(":")
-          if parts.length != 2 || parts[0] == "" || parts[1] == ""
-            errors << I18n.t(
-              "docker_provider.errors.config.invalid_link", link: link)
-          end
-        end
-
-        if @vagrant_vagrantfile
-          vf_pn = Pathname.new(@vagrant_vagrantfile)
-          if !vf_pn.file?
-            errors << I18n.t("docker_provider.errors.config.invalid_vagrantfile")
-          end
-        end
-
-        { "docker provider" => errors }
-      end
-
-      #--------------------------------------------------------------
-      # Functions below should not be called by config files
-      #--------------------------------------------------------------
-
-      def _links
-        @links
-      end
-    end
-  end
-end

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

@@ -1,294 +0,0 @@
-require "json"
-require "log4r"
-
-module VagrantPlugins
-  module DockerProvider
-    class Driver
-      class Compose < Driver
-
-        # @return [Integer] Maximum number of seconds to wait for lock
-        LOCK_TIMEOUT = 60
-        # @return [String] Compose file format version
-        COMPOSE_VERSION = "2".freeze
-
-        # @return [Pathname] data directory to store composition
-        attr_reader :data_directory
-        # @return [Vagrant::Machine]
-        attr_reader :machine
-
-        # Create a new driver instance
-        #
-        # @param [Vagrant::Machine] machine Machine instance for this driver
-        def initialize(machine)
-          if !Vagrant::Util::Which.which("docker-compose")
-            raise Errors::DockerComposeNotInstalledError
-          end
-          super()
-          @machine = machine
-          @data_directory = Pathname.new(machine.env.local_data_path).
-            join("docker-compose")
-          @data_directory.mkpath
-          @logger = Log4r::Logger.new("vagrant::docker::driver::compose")
-          @compose_lock = Mutex.new
-          @logger.debug("Docker compose driver initialize for machine `#{@machine.name}` (`#{@machine.id}`)")
-          @logger.debug("Data directory for composition file `#{@data_directory}`")
-        end
-
-        def build(dir, **opts, &block)
-          name = machine.name.to_s
-          @logger.debug("Applying build for `#{name}` using `#{dir}` directory.")
-          begin
-            update_composition do |composition|
-              services = composition["services"] ||= {}
-              services[name] ||= {}
-              services[name]["build"] = {"context" => dir}
-              # Extract custom dockerfile location if set
-              if opts[:extra_args] && opts[:extra_args].include?("--file")
-                services[name]["build"]["dockerfile"] = opts[:extra_args][opts[:extra_args].index("--file") + 1]
-              end
-              # Extract any build args that can be found
-              case opts[:build_args]
-              when Array
-                if opts[:build_args].include?("--build-arg")
-                  idx = 0
-                  build_args = {}
-                  while(idx < opts[:build_args].size)
-                    arg_value = opts[:build_args][idx]
-                    idx += 1
-                    if arg_value.start_with?("--build-arg")
-                      if !arg_value.include?("=")
-                        arg_value = opts[:build_args][idx]
-                        idx += 1
-                      end
-                      key, val = arg_value.to_s.split("=", 2).to_s.split("=")
-                      build_args[key] = val
-                    end
-                  end
-                end
-              when Hash
-                services[name]["build"]["args"] = opts[:build_args]
-              end
-            end
-          rescue => error
-            @logger.error("Failed to apply build using `#{dir}` directory: #{error.class} - #{error}")
-            update_composition do |composition|
-              composition["services"].delete(name)
-            end
-            raise
-          end
-        end
-
-        def create(params, **opts, &block)
-          # NOTE: Use the direct machine name as we don't
-          # need to worry about uniqueness with compose
-          name    = machine.name.to_s
-          image   = params.fetch(:image)
-          links   = Array(params.fetch(:links, [])).map do |link|
-            case link
-            when Array
-              link
-            else
-              link.to_s.split(":")
-            end
-          end
-          ports   = Array(params[:ports])
-          volumes = Array(params[:volumes]).map do |v|
-            v = v.to_s
-            host, guest = v.split(":", 2)
-            if v.include?(":") && (Vagrant::Util::Platform.windows? || Vagrant::Util::Platform.wsl?)
-              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]+/, "")
-            end
-            host = @machine.env.cwd.join(host).to_s
-            "#{host}:#{guest}"
-          end
-          cmd     = Array(params.fetch(:cmd))
-          env     = Hash[*params.fetch(:env).flatten.map(&:to_s)]
-          expose  = Array(params[:expose])
-          @logger.debug("Creating container `#{name}`")
-          begin
-            update_args = [:apply]
-            update_args.push(:detach) if params[:detach]
-            update_args << block
-            update_composition(*update_args) do |composition|
-              services = composition["services"] ||= {}
-              services[name] ||= {}
-              if params[:extra_args].is_a?(Hash)
-                services[name].merge!(
-                  Hash[
-                    params[:extra_args].map{ |k, v|
-                      [k.to_s, v]
-                    }
-                  ]
-                )
-              end
-              services[name].merge!(
-                "environment" => env,
-                "expose" => expose,
-                "ports" => ports,
-                "volumes" => volumes,
-                "links" => links,
-                "command" => cmd
-              )
-              services[name]["image"] = image if image
-              services[name]["hostname"] = params[:hostname] if params[:hostname]
-              services[name]["privileged"] = true if params[:privileged]
-              services[name]["pty"] = true if params[:pty]
-            end
-          rescue => error
-            @logger.error("Failed to create container `#{name}`: #{error.class} - #{error}")
-            update_composition do |composition|
-              composition["services"].delete(name)
-            end
-            raise
-          end
-          get_container_id(name)
-        end
-
-        def rm(cid)
-          if created?(cid)
-            destroy = false
-            synchronized do
-              compose_execute("rm", "-f", machine.name.to_s)
-              update_composition do |composition|
-                if composition["services"] && composition["services"].key?(machine.name.to_s)
-                  @logger.info("Removing container `#{machine.name}`")
-                  if composition["services"].size > 1
-                    composition["services"].delete(machine.name.to_s)
-                  else
-                    destroy = true
-                  end
-                end
-              end
-              if destroy
-                @logger.info("No containers remain. Destroying full environment.")
-                compose_execute("down", "--volumes", "--rmi", "local")
-                @logger.info("Deleting composition path `#{composition_path}`")
-                composition_path.delete
-              end
-            end
-          end
-        end
-
-        def rmi(*_)
-          true
-        end
-
-        def created?(cid)
-          result = super
-          if !result
-            composition = get_composition
-            if composition["services"] && composition["services"].has_key?(machine.name.to_s)
-              result = true
-            end
-          end
-          result
-        end
-
-        private
-
-        # Lookup the ID for the container with the given name
-        #
-        # @param [String] name Name of container
-        # @return [String] Container ID
-        def get_container_id(name)
-          compose_execute("ps", "-q", name).chomp
-        end
-
-        # Execute a `docker-compose` command
-        def compose_execute(*cmd, **opts, &block)
-          synchronized do
-            execute("docker-compose", "-f", composition_path.to_s,
-              "-p", machine.env.cwd.basename.to_s, *cmd, **opts, &block)
-          end
-        end
-
-        # Apply any changes made to the composition
-        def apply_composition!(*args)
-          block = args.detect{|arg| arg.is_a?(Proc) }
-          execute_args = ["up", "--remove-orphans"]
-          if args.include?(:detach)
-            execute_args << "-d"
-          end
-          machine.env.lock("compose", retry: true) do
-            if block
-              compose_execute(*execute_args, &block)
-            else
-              compose_execute(*execute_args)
-            end
-          end
-        end
-
-        # Update the composition and apply changes if requested
-        #
-        # @param [Boolean] apply Apply composition changes
-        def update_composition(*args)
-          synchronized do
-            machine.env.lock("compose", retry: true) do
-              composition = get_composition
-              result = yield composition
-              write_composition(composition)
-              if args.include?(:apply) || (args.include?(:conditional) && result)
-                apply_composition!(*args)
-              end
-            end
-          end
-        end
-
-        # @return [Hash] current composition contents
-        def get_composition
-          composition = {"version" => COMPOSE_VERSION.dup}
-          if composition_path.exist?
-            composition = Vagrant::Util::DeepMerge.deep_merge(composition, YAML.load(composition_path.read))
-          end
-          composition = Vagrant::Util::DeepMerge.deep_merge(composition, machine.provider_config.compose_configuration.dup)
-          @logger.debug("Fetched composition with provider configuration applied: #{composition}")
-          composition
-        end
-
-        # Save the composition
-        #
-        # @param [Hash] composition New composition
-        def write_composition(composition)
-          @logger.debug("Saving composition to `#{composition_path}`: #{composition}")
-          tmp_file = Tempfile.new("vagrant-docker-compose")
-          tmp_file.write(composition.to_yaml)
-          tmp_file.close
-          synchronized do
-            FileUtils.mv(tmp_file.path, composition_path.to_s)
-          end
-        end
-
-        # @return [Pathname] path to the docker-compose.yml file
-        def composition_path
-          data_directory.join("docker-compose.yml")
-        end
-
-        def synchronized
-          if !@compose_lock.owned?
-            timeout = LOCK_TIMEOUT.to_f
-            until @compose_lock.owned?
-              if @compose_lock.try_lock
-                if timeout > 0
-                  timeout -= sleep(1)
-                else
-                  raise Errors::ComposeLockTimeoutError
-                end
-              end
-            end
-            got_lock = true
-          end
-          begin
-            result = yield
-          ensure
-            @compose_lock.unlock if got_lock
-          end
-          result
-        end
-      end
-    end
-  end
-end