vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/heroku/push.rb

@@ -1,137 +0,0 @@
-require "vagrant/util/subprocess"
-require "vagrant/util/which"
-
-require_relative "errors"
-
-module VagrantPlugins
-  module HerokuPush
-    class Push < Vagrant.plugin("2", :push)
-      def push
-        # Expand any paths relative to the root
-        dir = File.expand_path(config.dir, env.root_path)
-
-        # Verify git is installed
-        verify_git_bin!(config.git_bin)
-
-        # Verify we are operating in a git repo
-        verify_git_repo!(dir)
-
-        # Get the current branch
-        branch = git_branch(dir)
-
-        # Get the name of the app
-        app = config.app || interpret_app(dir)
-
-        # Check if we need to add the git remote
-        if !has_git_remote?(config.remote, dir)
-          add_heroku_git_remote(config.remote, app, dir)
-        end
-
-        # Push to Heroku
-        git_push_heroku(config.remote, branch, dir)
-      end
-
-      # Verify that git is installed.
-      # @raise [Errors::GitNotFound]
-      def verify_git_bin!(path)
-        if Vagrant::Util::Which.which(path).nil?
-          raise Errors::GitNotFound, bin: path
-        end
-      end
-
-      # Verify that the given path is a git directory.
-      # @raise [Errors::NotAGitRepo]
-      # @param [String]
-      def verify_git_repo!(path)
-        if !File.directory?(git_dir(path))
-          raise Errors::NotAGitRepo, path: path
-        end
-      end
-
-      # Interpret the name of the Heroku application from the given path.
-      # @param [String] path
-      # @return [String]
-      def interpret_app(path)
-        File.basename(path)
-      end
-
-      # The git directory for the given path.
-      # @param [String] path
-      # @return [String]
-      def git_dir(path)
-        "#{path}/.git"
-      end
-
-      # The name of the current git branch.
-      # @param [String] path
-      # @return [String]
-      def git_branch(path)
-        result = execute!("git",
-          "--git-dir", git_dir(path),
-          "--work-tree", path,
-          "symbolic-ref",
-          "HEAD",
-        )
-
-        # Returns something like "* master"
-        result.stdout.sub("*", "").strip
-      end
-
-      # Push to the Heroku remote.
-      # @param [String] remote
-      # @param [String] branch
-      def git_push_heroku(remote, branch, path)
-        execute!("git",
-          "--git-dir", git_dir(path),
-          "--work-tree", path,
-          "push", remote, "#{branch}:master",
-        )
-      end
-
-      # Check if the git remote has the given remote.
-      # @param [String] remote
-      # @return [true, false]
-      def has_git_remote?(remote, path)
-        result = execute!("git",
-          "--git-dir", git_dir(path),
-          "--work-tree", path,
-          "remote",
-        )
-        remotes = result.stdout.split(/\r?\n/).map(&:strip)
-        remotes.include?(remote.to_s)
-      end
-
-      # Add the Heroku to the current repository.
-      # @param [String] remote
-      # @param [String] app
-      def add_heroku_git_remote(remote, app, path)
-        execute!("git",
-          "--git-dir", git_dir(path),
-          "--work-tree", path,
-          "remote", "add", remote, heroku_git_url(app),
-        )
-      end
-
-      # The URL for this project on Heroku.
-      # @return [String]
-      def heroku_git_url(app)
-        "git@heroku.com:#{app}.git"
-      end
-
-      # Execute the command, raising an exception if it fails.
-      # @return [Vagrant::Util::Subprocess::Result]
-      def execute!(*cmd)
-        result = Vagrant::Util::Subprocess.execute(*cmd)
-
-        if result.exit_code != 0
-          raise Errors::CommandFailed,
-            cmd:    cmd.join(" "),
-            stdout: result.stdout,
-            stderr: result.stderr
-        end
-
-        result
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/local-exec/config.rb

@@ -1,77 +0,0 @@
-module VagrantPlugins
-  module LocalExecPush
-    class Config < Vagrant.plugin("2", :config)
-      # The path (relative to the machine root) to a local script that will be
-      # executed.
-      # @return [String]
-      attr_accessor :script
-
-      # The command (as a string) to execute.
-      # @return [String]
-      attr_accessor :inline
-
-      # The arguments to provide when executing the script.
-      # @return [Array<String>]
-      attr_accessor :args
-
-      def initialize
-        @script = UNSET_VALUE
-        @inline = UNSET_VALUE
-        @args   = UNSET_VALUE
-      end
-
-      def finalize!
-        @script = nil if @script == UNSET_VALUE
-        @inline = nil if @inline == UNSET_VALUE
-        @args   = nil if @args == UNSET_VALUE
-
-        if @args && args_valid?
-          @args = @args.is_a?(Array) ? @args.map { |a| a.to_s } : @args.to_s
-        end
-      end
-
-      def validate(machine)
-        errors = _detected_errors
-
-        if missing?(@script) && missing?(@inline)
-          errors << I18n.t("local_exec_push.errors.missing_attribute",
-            attribute: "script",
-          )
-        end
-
-        if !missing?(@script) && !missing?(@inline)
-          errors << I18n.t("local_exec_push.errors.cannot_specify_script_and_inline")
-        end
-
-        if !args_valid?
-          errors << I18n.t("local_exec_push.errors.args_bad_type")
-        end
-
-        { "Local Exec push" => errors }
-      end
-
-      private
-
-      # Determine if the given string is "missing" (blank)
-      # @return [true, false]
-      def missing?(obj)
-        obj.to_s.strip.empty?
-      end
-
-      # Args are optional, but if they're provided we only support them as a
-      # string or as an array.
-      def args_valid?
-        return true if !args
-        return true if args.is_a?(String)
-        return true if args.is_a?(Integer)
-        if args.is_a?(Array)
-          args.each do |a|
-            return false if !a.kind_of?(String) && !a.kind_of?(Integer)
-          end
-
-          return true
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/local-exec/errors.rb

@@ -1,13 +0,0 @@
-module VagrantPlugins
-  module LocalExecPush
-    module Errors
-      class Error < Vagrant::Errors::VagrantError
-        error_namespace("local_exec_push.errors")
-      end
-
-      class CommandFailed < Error
-        error_key(:command_failed)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/local-exec/locales/en.yml

@@ -1,23 +0,0 @@
-en:
-  local_exec_push:
-    errors:
-      cannot_specify_script_and_inline: |-
-        You have specified both the 'script' and 'inline' attributes for the
-        Vagrant Local Exec Push plugin. You may only specify one of these
-        attributes.
-      command_failed: |-
-        The following command exited with a non-zero exit status:
-
-            %{cmd}
-
-        stdout: %{stdout}
-        stderr: %{stderr}
-      missing_attribute: |-
-        Missing required attribute '%{attribute}'. The Vagrant Local Exec Push
-        plugin requires you set this attribute. Please set this attribute in
-        your Vagrantfile, for example:
-
-            config.push.define "local-exec" do |push|
-              push.%{attribute} = "..."
-            end
-      args_bad_type: "Local-exec push `args` must be a string or array."

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/local-exec/plugin.rb

@@ -1,33 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module LocalExecPush
-    class Plugin < Vagrant.plugin("2")
-      name "local-exec"
-      description <<-DESC
-      Run a local command or script to push
-      DESC
-
-      config(:"local-exec", :push) do
-        require File.expand_path("../config", __FILE__)
-        init!
-        Config
-      end
-
-      push(:"local-exec") do
-        require File.expand_path("../push", __FILE__)
-        init!
-        Push
-      end
-
-      protected
-
-      def self.init!
-        return if defined?(@_init)
-        I18n.load_path << File.expand_path("../locales/en.yml", __FILE__)
-        I18n.reload!
-        @_init = true
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/local-exec/push.rb

@@ -1,84 +0,0 @@
-require "fileutils"
-require "tempfile"
-require "vagrant/util/safe_exec"
-
-require_relative "errors"
-
-module VagrantPlugins
-  module LocalExecPush
-    class Push < Vagrant.plugin("2", :push)
-      def push
-        if config.inline
-          execute_inline!(config.inline, config.args)
-        else
-          execute_script!(config.script, config.args)
-        end
-      end
-
-      # Execute the inline script by writing it to a tempfile and executing.
-      def execute_inline!(inline, args)
-        script = Tempfile.new(["vagrant-local-exec-script", ".sh"])
-        script.write(inline)
-        script.rewind
-        script.close
-
-        execute_script!(script.path, args)
-      ensure
-        if script
-          script.close
-          script.unlink
-        end
-      end
-
-      # Execute the script, expanding the path relative to the current env root.
-      def execute_script!(path, args)
-        path = File.expand_path(path, env.root_path)
-        FileUtils.chmod("+x", path)
-
-        if args.is_a?(String)
-          args = " #{args.to_s}"
-        elsif args.is_a?(Array)
-          args = args.map { |a| quote_and_escape(a) }
-          args = " #{args.join(" ")}"
-        end
-
-        execute!("#{path}#{args}")
-      end
-
-      # Execute the script, raising an exception if it fails.
-      def execute!(*cmd)
-        if Vagrant::Util::Platform.windows?
-          execute_subprocess!(*cmd)
-        else
-          execute_exec!(*cmd)
-        end
-      end
-
-      private
-
-      # Quote and escape strings for shell execution, thanks to Capistrano.
-      def quote_and_escape(text, quote = '"')
-        "#{quote}#{text.gsub(/#{quote}/) { |m| "#{m}\\#{m}#{m}" }}#{quote}"
-      end
-
-      # Run the command as exec (unix).
-      def execute_exec!(*cmd)
-        Vagrant::Util::SafeExec.exec(cmd[0], *cmd[1..-1])
-      end
-
-      # Run the command as a subprocess (windows).
-      def execute_subprocess!(*cmd)
-        cmd = cmd.dup << { notify: [:stdout, :stderr] }
-        result = Vagrant::Util::Subprocess.execute(*cmd) do |type, data|
-          if type == :stdout
-            @env.ui.info(data, new_line: false)
-          elsif type == :stderr
-            @env.ui.warn(data, new_line: false)
-          end
-        end
-
-        Kernel.exit(result.exit_code)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/noop/config.rb

@@ -1,16 +0,0 @@
-module VagrantPlugins
-  module NoopDeploy
-    class Config < Vagrant.plugin("2", :config)
-      def initialize
-      end
-
-      def finalize!
-      end
-
-      def validate(machine)
-        errors = _detected_errors
-        { "Noop push" => errors }
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module NoopDeploy
-    class Plugin < Vagrant.plugin("2")
-      name "noop"
-      description <<-DESC
-      Literally do nothing
-      DESC
-
-      config(:noop, :push) do
-        require File.expand_path("../config", __FILE__)
-        Config
-      end
-
-      push(:noop) do
-        require File.expand_path("../push", __FILE__)
-        Push
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/pushes/noop/push.rb

@@ -1,9 +0,0 @@
-module VagrantPlugins
-  module NoopDeploy
-    class Push < Vagrant.plugin("2", :push)
-      def push
-        puts "pushed"
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/synced_folders/nfs/action_cleanup.rb

@@ -1,29 +0,0 @@
-require "log4r"
-
-module VagrantPlugins
-  module SyncedFolderNFS
-    class ActionCleanup
-      def initialize(app, env)
-        @app    = app
-        @logger = Log4r::Logger.new("vagrant::synced_folders::nfs")
-      end
-
-      def call(env)
-        if !env[:nfs_valid_ids]
-          @logger.warn("nfs_valid_ids not set, cleanup cannot occur")
-          return @app.call(env)
-        end
-
-        if !env[:machine].env.host.capability?(:nfs_prune)
-          @logger.info("Host doesn't support pruning NFS. Skipping.")
-          return @app.call(env)
-        end
-
-        @logger.info("NFS pruning. Valid IDs: #{env[:nfs_valid_ids].inspect}")
-        env[:machine].env.host.capability(
-          :nfs_prune, env[:machine].ui, env[:nfs_valid_ids])
-        @app.call(env)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/synced_folders/nfs/config.rb

@@ -1,32 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module SyncedFolderNFS
-    class Config < Vagrant.plugin("2", :config)
-      attr_accessor :functional
-      attr_accessor :map_uid
-      attr_accessor :map_gid
-      attr_accessor :verify_installed
-
-      def initialize
-        super
-
-        @functional = UNSET_VALUE
-        @map_uid    = UNSET_VALUE
-        @map_gid    = UNSET_VALUE
-        @verify_installed = UNSET_VALUE
-      end
-
-      def finalize!
-        @functional = true if @functional == UNSET_VALUE
-        @map_uid = :auto if @map_uid == UNSET_VALUE
-        @map_gid = :auto if @map_gid == UNSET_VALUE
-        @verify_installed = true if @verify_installed == UNSET_VALUE
-      end
-
-      def to_s
-        "NFS"
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module SyncedFolderNFS
-    # This plugin implements NFS synced folders. In order to take advantage
-    # of NFS synced folders, some provider-specific assistance is required.
-    # Within the middleware sequences, some data must be put into the
-    # environment state bag:
-    #
-    #   * `nfs_host_ip` (string) - The IP of the host machine that the NFS
-    #     client in the machine should talk to.
-    #   * `nfs_machine_ip` (string) - The IP of the guest machine that the NFS
-    #     server should serve the folders to.
-    #   * `nfs_valid_ids` (array of strings) - A list of IDs that are "valid"
-    #     and should not be pruned. The synced folder implementation will
-    #     regularly prune NFS exports of invalid IDs.
-    #
-    # If any of these variables are not set, an internal exception will be
-    # raised.
-    #
-    class Plugin < Vagrant.plugin("2")
-      name "NFS synced folders"
-      description <<-EOF
-      The NFS synced folders plugin enables you to use NFS as a synced folder
-      implementation.
-      EOF
-
-      config("nfs") do
-        require_relative "config"
-        Config
-      end
-
-      synced_folder("nfs", 5) do
-        require_relative "synced_folder"
-        SyncedFolder
-      end
-
-      action_hook("nfs_cleanup") do |hook|
-        require_relative "action_cleanup"
-        hook.before(
-          Vagrant::Action::Builtin::SyncedFolderCleanup,
-          ActionCleanup)
-      end
-    end
-  end
-end

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

@@ -1,161 +0,0 @@
-require 'fileutils'
-require 'thread'
-require 'zlib'
-
-require "log4r"
-
-require "vagrant/util/platform"
-
-module VagrantPlugins
-  module SyncedFolderNFS
-    # This synced folder requires that two keys be set on the environment
-    # within the middleware sequence:
-    #
-    #   - `:nfs_host_ip` - The IP of where to mount the NFS folder from.
-    #   - `:nfs_machine_ip` - The IP of the machine where the NFS folder
-    #     will be mounted.
-    #
-    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
-      @@lock = Mutex.new
-
-      def initialize(*args)
-        super
-
-        @logger = Log4r::Logger.new("vagrant::synced_folders::nfs")
-      end
-
-      def usable?(machine, raise_error=false)
-        # If the machine explicitly said NFS is not supported, then
-        # it isn't supported.
-        if !machine.config.nfs.functional
-          return false
-        end
-        return true if machine.env.host.capability(:nfs_installed)
-        return false if !raise_error
-        raise Vagrant::Errors::NFSNotSupported
-      end
-
-      def prepare(machine, folders, opts)
-        # Nothing is necessary to do before VM boot.
-      end
-
-      def enable(machine, folders, nfsopts)
-        raise Vagrant::Errors::NFSNoHostIP if !nfsopts[:nfs_host_ip]
-        raise Vagrant::Errors::NFSNoGuestIP if !nfsopts[:nfs_machine_ip]
-
-        if machine.config.nfs.verify_installed
-          if machine.guest.capability?(:nfs_client_installed)
-            installed = machine.guest.capability(:nfs_client_installed)
-            if !installed
-              can_install = machine.guest.capability?(:nfs_client_install)
-              raise Vagrant::Errors::NFSClientNotInstalledInGuest if !can_install
-              machine.ui.info I18n.t("vagrant.actions.vm.nfs.installing")
-              machine.guest.capability(:nfs_client_install)
-            end
-          end
-        end
-
-        machine_ip = nfsopts[:nfs_machine_ip]
-        machine_ip = [machine_ip] if !machine_ip.is_a?(Array)
-
-        # Prepare the folder, this means setting up various options
-        # and such on the folder itself.
-        folders.each { |id, opts| prepare_folder(machine, opts) }
-
-        # Determine what folders we'll export
-        export_folders = folders.dup
-        export_folders.keys.each do |id|
-          opts = export_folders[id]
-          if opts.key?(:nfs_export) && !opts[:nfs_export]
-            export_folders.delete(id)
-          end
-        end
-
-        # Update the exports when there are actually exports [GH-4148]
-        if !export_folders.empty?
-          # Export the folders. We do this with a class-wide lock because
-          # NFS exporting often requires sudo privilege and we don't want
-          # overlapping input requests. [GH-2680]
-          @@lock.synchronize do
-            begin
-              machine.env.lock("nfs-export") do
-                machine.ui.info I18n.t("vagrant.actions.vm.nfs.exporting")
-                machine.env.host.capability(
-                  :nfs_export,
-                  machine.ui, machine.id, machine_ip, export_folders)
-              end
-            rescue Vagrant::Errors::EnvironmentLockedError
-              sleep 1
-              retry
-            end
-          end
-        end
-
-        # Mount
-        machine.ui.info I18n.t("vagrant.actions.vm.nfs.mounting")
-
-        # Only mount folders that have a guest path specified.
-        mount_folders = {}
-        folders.each do |id, opts|
-          mount_folders[id] = opts.dup if opts[:guestpath]
-        end
-
-        # Mount them!
-        if machine.guest.capability?(:nfs_pre)
-          machine.guest.capability(:nfs_pre)
-        end
-
-        machine.guest.capability(:mount_nfs_folder,
-          nfsopts[:nfs_host_ip], mount_folders)
-
-        if machine.guest.capability?(:nfs_post)
-          machine.guest.capability(:nfs_post)
-        end
-      end
-
-      def cleanup(machine, opts)
-        ids = opts[:nfs_valid_ids]
-        raise Vagrant::Errors::NFSNoValidIds if !ids
-
-        # Prune any of the unused machines
-        @logger.info("NFS pruning. Valid IDs: #{ids.inspect}")
-        machine.env.host.capability(:nfs_prune, machine.ui, ids)
-      end
-
-      protected
-
-      def prepare_folder(machine, opts)
-        opts[:map_uid] = prepare_permission(machine, :uid, opts)
-        opts[:map_gid] = prepare_permission(machine, :gid, opts)
-        opts[:nfs_version] ||= 3
-        if !opts.key?(:nfs_udp)
-          opts[:nfs_udp] = !opts[:nfs_version].to_s.start_with?('4')
-        end
-
-        if opts[:nfs_version].to_s.start_with?('4') && opts[:nfs_udp]
-          machine.ui.info I18n.t("vagrant.actions.vm.nfs.v4_with_udp_warning")
-        end
-
-        # We use a CRC32 to generate a 32-bit checksum so that the
-        # fsid is compatible with both old and new kernels.
-        opts[:uuid] = Zlib.crc32(opts[:hostpath]).to_s
-      end
-
-      # Prepares the UID/GID settings for a single folder.
-      def prepare_permission(machine, perm, opts)
-        key = "map_#{perm}".to_sym
-        return nil if opts.key?(key) && opts[key].nil?
-
-        # The options on the hash get priority, then the default
-        # values
-        value = opts.key?(key) ? opts[key] : machine.config.nfs.send(key)
-        return value if value != :auto
-
-        # Get UID/GID from folder if we've made it this far
-        # (value == :auto)
-        stat = File.stat(opts[:hostpath])
-        return stat.send(perm)
-      end
-    end
-  end
-end