vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/destroy.rb

@@ -1,31 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      class Destroy
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          env[:ui].info I18n.t("docker_provider.messages.destroying")
-
-          machine = env[:machine]
-          driver  = machine.provider.driver
-
-          # If we have a build image, store that
-          image_file = machine.data_dir.join("docker_build_image")
-          image      = nil
-          if image_file.file?
-            image = image_file.read.chomp
-          end
-          env[:build_image] = image
-
-          driver.rm(machine.id)
-          machine.id = nil
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/destroy_build_image.rb

@@ -1,48 +0,0 @@
-require "log4r"
-
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      class DestroyBuildImage
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::docker::destroybuildimage")
-        end
-
-        def call(env)
-          machine = env[:machine]
-          image   = env[:build_image]
-          image_file = nil
-
-          if !image
-            # Try to read the image ID from the cache file if we've
-            # already built it.
-            image_file = machine.data_dir.join("docker_build_image")
-            image      = nil
-            if image_file.file?
-              image = image_file.read.chomp
-            end
-          end
-
-          if image
-            machine.ui.output(I18n.t("docker_provider.build_image_destroy"))
-            if !machine.provider.driver.rmi(image)
-              machine.ui.detail(I18n.t(
-                "docker_provider.build_image_destroy_in_use"))
-            end
-          end
-
-          if image_file && image_file.file?
-            begin
-              image_file.delete
-            rescue Errno::ENOENT
-              # Its okay
-            end
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/forwarded_ports.rb

@@ -1,31 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      class ForwardedPorts
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          env[:machine].provider_config.ports.each do |p|
-            host_ip = nil
-            protocol = "tcp"
-            host, guest = p.split(":", 2)
-            if guest.include?(":")
-              host_ip = host
-              host, guest = guest.split(":", 2)
-            end
-
-            guest, protocol = guest.split("/", 2) if guest.include?("/")
-            env[:machine].config.vm.network "forwarded_port",
-              host: host.to_i, guest: guest.to_i,
-              host_ip: host_ip,
-              protocol: protocol
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/has_ssh.rb

@@ -1,18 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      # This middleware is used with Call to test if this machine supports
-      # SSH.
-      class HasSSH
-        def initialize(app, env)
-          @app    = app
-        end
-
-        def call(env)
-          env[:result] = env[:machine].provider_config.has_ssh
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/host_machine.rb

@@ -1,72 +0,0 @@
-require "log4r"
-
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      # This action is responsible for creating the host machine if
-      # we need to. The host machine is where Docker containers will
-      # live.
-      class HostMachine
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::docker::hostmachine")
-        end
-
-        def call(env)
-          if !env[:machine].provider.host_vm?
-            @logger.info("No host machine needed.")
-            return @app.call(env)
-          end
-
-          env[:machine].ui.output(I18n.t(
-            "docker_provider.host_machine_needed"))
-
-          host_machine = env[:machine].provider.host_vm
-
-          begin
-            env[:machine].provider.host_vm_lock do
-              setup_host_machine(host_machine, env)
-            end
-          rescue Vagrant::Errors::EnvironmentLockedError
-            sleep 1
-            retry
-          end
-
-          @app.call(env)
-        end
-
-        protected
-
-        def setup_host_machine(host_machine, env)
-          # Create a UI for this machine that stays at the detail level
-          proxy_ui = host_machine.ui.dup
-          proxy_ui.opts[:bold] = false
-          proxy_ui.opts[:prefix_spaces] = true
-          proxy_ui.opts[:target] = env[:machine].name.to_s
-
-          # Reload the machine so that if it was created while we didn't
-          # hold the lock, we'll see the updated state.
-          host_machine.reload
-
-          # See if the machine is ready already. If not, start it.
-          if host_machine.communicate.ready?
-            env[:machine].ui.detail(I18n.t("docker_provider.host_machine_ready"))
-          else
-            env[:machine].ui.detail(
-              I18n.t("docker_provider.host_machine_starting"))
-            env[:machine].ui.detail(" ")
-            host_machine.with_ui(proxy_ui) do
-              host_machine.action(:up)
-            end
-
-            # Verify communication is ready. If not, we have a problem.
-            if !host_machine.communicate.ready?
-              raise Errors::HostVMCommunicatorNotReady,
-                id: host_machine.id
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/host_machine_build_dir.rb

@@ -1,46 +0,0 @@
-require "digest/md5"
-
-require "log4r"
-
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      class HostMachineBuildDir
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::docker::hostmachinebuilddir")
-        end
-
-        def call(env)
-          machine   = env[:machine]
-          build_dir = machine.provider_config.build_dir
-
-          # If we're not building a Dockerfile, ignore
-          return @app.call(env) if !build_dir
-
-          # If we're building a docker file, expand the directory
-          build_dir = File.expand_path(build_dir, env[:machine].env.root_path)
-          env[:build_dir] = build_dir
-
-          # If we're not on a host VM, we're done
-          return @app.call(env) if !machine.provider.host_vm?
-
-          # We're on a host VM, so we need to move our build dir to
-          # that machine. We do this by putting the synced folder on
-          # ourself and letting HostMachineSyncFolders handle it.
-          new_build_dir = "/var/lib/docker/docker_build_#{Digest::MD5.hexdigest(build_dir)}"
-          options       = {
-            docker__ignore: true,
-            docker__exact: true,
-          }.merge(machine.provider_config.host_vm_build_dir_options || {})
-          machine.config.vm.synced_folder(build_dir, new_build_dir, options)
-
-          # Set the build dir to be the correct one
-          env[:build_dir] = new_build_dir
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/host_machine_port_checker.rb

@@ -1,31 +0,0 @@
-require "log4r"
-
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      # This sets up the middleware env var to check for ports in use.
-      class HostMachinePortChecker
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::docker::hostmachineportchecker")
-        end
-
-        def call(env)
-          return @app.call(env) if !env[:machine].provider.host_vm?
-
-          @machine = env[:machine]
-          env[:port_collision_port_check] = method(:port_check)
-
-          @app.call(env)
-        end
-
-        protected
-
-        def port_check(port)
-          host_machine = @machine.provider.host_vm
-          host_machine.guest.capability(:port_open_check, port)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/host_machine_port_warning.rb

@@ -1,37 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      class HostMachinePortWarning
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if !env[:machine].provider.host_vm?
-            return @app.call(env)
-          end
-
-          # If we have forwarded ports, then notify the user that they
-          # won't be immediately available unless a private network
-          # is created.
-          if has_forwarded_ports?(env[:machine])
-            env[:machine].ui.warn(I18n.t(
-              "docker_provider.host_machine_forwarded_ports"))
-          end
-
-          @app.call(env)
-        end
-
-        protected
-
-        def has_forwarded_ports?(machine)
-          machine.config.vm.networks.each do |type, _|
-            return true if type == :forwarded_port
-          end
-
-          false
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/host_machine_required.rb

@@ -1,17 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      # This middleware is used with Call to test if we're using a host VM.
-      class HostMachineRequired
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          env[:result] = env[:machine].provider.host_vm?
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/host_machine_sync_folders.rb

@@ -1,174 +0,0 @@
-require "digest/md5"
-require "securerandom"
-
-require "log4r"
-
-require "vagrant/action/builtin/mixin_synced_folders"
-
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      # This action is responsible for creating the host machine if
-      # we need to. The host machine is where Docker containers will
-      # live.
-      class HostMachineSyncFolders
-        include Vagrant::Action::Builtin::MixinSyncedFolders
-
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::docker::hostmachine")
-        end
-
-        def call(env)
-          return @app.call(env) if !env[:machine].provider.host_vm?
-
-          if !env.key?(:host_machine_sync_folders)
-            env[:host_machine_sync_folders] = true
-          end
-
-          host_machine = env[:machine].provider.host_vm
-
-          # Lock while we make changes
-          begin
-            env[:machine].provider.host_vm_lock do
-              setup_synced_folders(host_machine, env)
-            end
-          rescue Vagrant::Errors::EnvironmentLockedError
-            sleep 1
-            retry
-          end
-
-          @app.call(env)
-        end
-
-        protected
-
-        def setup_synced_folders(host_machine, env)
-          # Write the host machine SFID if we have one
-          id_path   = env[:machine].data_dir.join("host_machine_sfid")
-          if !id_path.file?
-            host_sfid = SecureRandom.uuid
-            id_path.open("w") do |f|
-              f.binmode
-              f.write("#{host_sfid}\n")
-            end
-          else
-            host_sfid = id_path.read.chomp
-          end
-
-          # Create a UI for this machine that stays at the detail level
-          proxy_ui = host_machine.ui.dup
-          proxy_ui.opts[:bold] = false
-          proxy_ui.opts[:prefix_spaces] = true
-          proxy_ui.opts[:target] = env[:machine].name.to_s
-
-          # Read the existing folders that are setup
-          existing_folders = synced_folders(host_machine, cached: true)
-          existing_ids = {}
-          if existing_folders
-            existing_folders.each do |impl, fs|
-              fs.each do |_name, data|
-                if data[:docker_sfid] && data[:docker_host_sfid] == host_sfid
-                  existing_ids[data[:docker_sfid]] = data
-                end
-              end
-            end
-          end
-
-          # Sync some folders so that our volumes work later.
-          new_config  = VagrantPlugins::Kernel_V2::VMConfig.new
-          our_folders = synced_folders(env[:machine])
-          our_folders.each do |type, folders|
-            folders.each do |id, data|
-              data = data.dup
-
-              if type == :docker
-                # We don't use the Docker type explicitly on the host VM
-                data.delete(:type)
-              end
-
-              # Expand the hostpath relative to _our_ root path. Otherwise,
-              # it expands it relative to the proxy VM, which is not what
-              # we want.
-              data[:hostpath] = File.expand_path(
-                data[:hostpath], env[:machine].env.root_path)
-
-              # Generate an ID that is deterministic based on our machine
-              # and Vagrantfile path...
-              id = Digest::MD5.hexdigest(
-                "#{env[:machine].env.root_path}" +
-                "#{data[:hostpath]}" +
-                "#{data[:guestpath]}" +
-                "#{env[:machine].name}")
-
-              # Generate a new guestpath
-              data[:docker_guestpath] = data[:guestpath]
-              data[:docker_sfid] = id
-              data[:docker_host_sfid] = host_sfid
-              data[:id] = id[0...6] + rand(10000).to_s
-
-              # If we specify exact then we know what we're doing
-              if !data[:docker__exact]
-                data[:guestpath] =
-                  "/var/lib/docker/docker_#{Time.now.to_i}_#{rand(100000)}"
-              end
-
-              # Add this synced folder onto the new config if we haven't
-              # already shared it before.
-              if !existing_ids.key?(id)
-                # A bit of a hack for VirtualBox to mount our
-                # folder as transient. This can be removed once
-                # the VirtualBox synced folder mechanism is smarter.
-                data[:virtualbox__transient] = true
-
-                new_config.synced_folder(
-                  data[:hostpath],
-                  data[:guestpath],
-                  data)
-              else
-                # We already have the folder, so just load its data
-                data = existing_ids[id]
-              end
-
-              # Remove from our machine
-              env[:machine].config.vm.synced_folders.delete(id)
-
-              # Add the "fixed" folder to our machine
-              data = data.merge({
-                hostpath_exact: true,
-                type: :docker,
-              })
-              env[:machine].config.vm.synced_folder(
-                data[:guestpath],
-                data[:docker_guestpath],
-                data)
-            end
-          end
-
-          if !env[:host_machine_sync_folders]
-            @logger.info("Not syncing folders because container created.")
-          end
-
-          if !new_config.synced_folders.empty?
-            # Sync the folders!
-            env[:machine].ui.output(I18n.t(
-              "docker_provider.host_machine_syncing_folders"))
-            host_machine.with_ui(proxy_ui) do
-              action_env = { synced_folders_config: new_config }
-              begin
-                host_machine.action(:sync_folders, action_env)
-              rescue Vagrant::Errors::MachineActionLockedError
-                sleep 1
-                retry
-              rescue Vagrant::Errors::UnimplementedProviderAction
-                callable = Vagrant::Action::Builder.new
-                callable.use Vagrant::Action::Builtin::SyncedFolders
-                host_machine.action_raw(:sync_folders, callable, action_env)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/host_machine_sync_folders_disable.rb

@@ -1,88 +0,0 @@
-require "log4r"
-
-require "vagrant/action/builtin/mixin_synced_folders"
-
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      # This action disables the synced folders we created.
-      class HostMachineSyncFoldersDisable
-        include Vagrant::Action::Builtin::MixinSyncedFolders
-
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::docker::hostmachine")
-        end
-
-        def call(env)
-          return @app.call(env) if !env[:machine].provider.host_vm?
-
-          # Read our random ID for this instance
-          id_path   = env[:machine].data_dir.join("host_machine_sfid")
-          return @app.call(env) if !id_path.file?
-          host_sfid = id_path.read.chomp
-
-          host_machine = env[:machine].provider.host_vm
-
-          @app.call(env)
-
-          begin
-            env[:machine].provider.host_vm_lock do
-              setup_synced_folders(host_machine, host_sfid, env)
-            end
-          rescue Vagrant::Errors::EnvironmentLockedError
-            sleep 1
-            retry
-          end
-        end
-
-        protected
-
-        def setup_synced_folders(host_machine, host_sfid, env)
-          to_disable = []
-
-          # Read the existing folders that are setup
-          existing_folders = synced_folders(host_machine, cached: true)
-          if existing_folders
-            existing_folders.each do |impl, fs|
-              fs.each do |id, data|
-                if data[:docker_host_sfid] == host_sfid
-                  to_disable << id
-                end
-              end
-            end
-          end
-
-          # Nothing to do if we have no bad folders
-          return if to_disable.empty?
-
-          # Create a UI for this machine that stays at the detail level
-          proxy_ui = host_machine.ui.dup
-          proxy_ui.opts[:bold] = false
-          proxy_ui.opts[:prefix_spaces] = true
-          proxy_ui.opts[:target] = env[:machine].name.to_s
-
-          env[:machine].ui.output(I18n.t(
-            "docker_provider.host_machine_disabling_folders"))
-          host_machine.with_ui(proxy_ui) do
-            action_env = {
-              synced_folders_cached: true,
-              synced_folders_disable: to_disable,
-            }
-
-            begin
-              host_machine.action(:sync_folders, action_env)
-            rescue Vagrant::Errors::MachineActionLockedError
-              sleep 1
-              retry
-            rescue Vagrant::Errors::UnimplementedProviderAction
-              callable = Vagrant::Action::Builder.new
-              callable.use Vagrant::Action::Builtin::SyncedFolders
-              host_machine.action_raw(:sync_folders, callable, action_env)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/init_state.rb

@@ -1,20 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      class InitState
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          # We set the ID of the machine to "preparing" so that we can use
-          # the data dir without it being deleted with the not_created state.
-          env[:machine].id = nil
-          env[:machine].id = "preparing"
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/is_build.rb

@@ -1,16 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      class IsBuild
-        def initialize(app, env)
-          @app    = app
-        end
-
-        def call(env)
-          env[:result] = !!env[:machine].provider_config.build_dir
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/bundler/gems/vagrant-04f7215b5e3f/plugins/providers/docker/action/is_host_machine_created.rb

@@ -1,29 +0,0 @@
-module VagrantPlugins
-  module DockerProvider
-    module Action
-      class IsHostMachineCreated
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if !env[:machine].provider.host_vm?
-            env[:result] = true
-            return @app.call(env)
-          end
-
-          host_machine = env[:machine].provider.host_vm
-          env[:result] =
-            host_machine.state.id != Vagrant::MachineState::NOT_CREATED_ID
-
-          # If the host machine isn't created, neither are we. It is
-          # important we set this to nil here so that global-status
-          # sees the right thing.
-          env[:machine].id = nil if !env[:result]
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end