vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/heroku/push.rb

@@ -0,0 +1,137 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/local-exec/config.rb

@@ -0,0 +1,77 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/local-exec/errors.rb

@@ -0,0 +1,13 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/local-exec/locales/en.yml

@@ -0,0 +1,23 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/local-exec/plugin.rb

@@ -0,0 +1,33 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/local-exec/push.rb

@@ -0,0 +1,84 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/noop/config.rb

@@ -0,0 +1,16 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/noop/plugin.rb

@@ -0,0 +1,22 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/pushes/noop/push.rb

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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/synced_folders/nfs/action_cleanup.rb

@@ -0,0 +1,29 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/synced_folders/nfs/config.rb

@@ -0,0 +1,32 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/synced_folders/nfs/plugin.rb

@@ -0,0 +1,46 @@
+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.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/synced_folders/nfs/synced_folder.rb

@@ -0,0 +1,161 @@
+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