vagrant-aws-mkubenka 0.7.2.pre.14 → 0.7.2.pre.16

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/guests/windows/plugin.rb

@@ -1,88 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module GuestWindows
-    autoload :Errors, File.expand_path("../errors", __FILE__)
-
-    class Plugin < Vagrant.plugin("2")
-      name "Windows guest."
-      description "Windows guest support."
-
-      config(:windows) do
-        require_relative "config"
-        Config
-      end
-
-      guest(:windows)  do
-        require_relative "guest"
-        init!
-        Guest
-      end
-
-      guest_capability(:windows, :change_host_name) do
-        require_relative "cap/change_host_name"
-        Cap::ChangeHostName
-      end
-
-      guest_capability(:windows, :configure_networks) do
-        require_relative "cap/configure_networks"
-        Cap::ConfigureNetworks
-      end
-
-      guest_capability(:windows, :halt) do
-        require_relative "cap/halt"
-        Cap::Halt
-      end
-
-      guest_capability(:windows, :mount_virtualbox_shared_folder) do
-        require_relative "cap/mount_shared_folder"
-        Cap::MountSharedFolder
-      end
-
-      guest_capability(:windows, :mount_vmware_shared_folder) do
-        require_relative "cap/mount_shared_folder"
-        Cap::MountSharedFolder
-      end
-
-      guest_capability(:windows, :mount_parallels_shared_folder) do
-        require_relative "cap/mount_shared_folder"
-        Cap::MountSharedFolder
-      end
-
-      guest_capability(:windows, :wait_for_reboot) do
-        require_relative "cap/reboot"
-        Cap::Reboot
-      end
-
-      guest_capability(:windows, :choose_addressable_ip_addr) do
-        require_relative "cap/choose_addressable_ip_addr"
-        Cap::ChooseAddressableIPAddr
-      end
-
-      guest_capability(:windows, :mount_smb_shared_folder) do
-        require_relative "cap/mount_shared_folder"
-        Cap::MountSharedFolder
-      end
-
-      guest_capability(:windows, :rsync_scrub_guestpath) do
-        require_relative "cap/rsync"
-        Cap::RSync
-      end
-
-      guest_capability(:windows, :rsync_pre) do
-        require_relative "cap/rsync"
-        Cap::RSync
-      end
-
-      protected
-
-      def self.init!
-        return if defined?(@_init)
-        I18n.load_path << File.expand_path(
-          "templates/locales/guest_windows.yml", Vagrant.source_root)
-        I18n.reload!
-        @_init = true
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/hosts/bsd/cap/nfs.rb

@@ -1,198 +0,0 @@
-require "log4r"
-
-require "vagrant/util"
-require "vagrant/util/shell_quote"
-require "vagrant/util/which"
-
-module VagrantPlugins
-  module HostBSD
-    module Cap
-      class NFS
-        def self.nfs_export(environment, ui, id, ips, folders)
-          nfs_exports_template = environment.host.capability(:nfs_exports_template)
-          nfs_restart_command  = environment.host.capability(:nfs_restart_command)
-          logger = Log4r::Logger.new("vagrant::hosts::bsd")
-
-          nfs_checkexports! if File.file?("/etc/exports")
-
-          # We need to build up mapping of directories that are enclosed
-          # within each other because the exports file has to have subdirectories
-          # of an exported directory on the same line. e.g.:
-          #
-          #   "/foo" "/foo/bar" ...
-          #   "/bar"
-          #
-          # We build up this mapping within the following hash.
-          logger.debug("Compiling map of sub-directories for NFS exports...")
-          dirmap = {}
-          folders.sort_by { |_, opts| opts[:hostpath] }.each do |_, opts|
-            hostpath = opts[:hostpath].dup
-            hostpath.gsub!('"', '\"')
-
-            found = false
-            dirmap.each do |dirs, diropts|
-              dirs.each do |dir|
-                if dir.start_with?(hostpath) || hostpath.start_with?(dir)
-                  # TODO: verify opts and diropts are _identical_, raise an error
-                  # if not. NFS mandates subdirectories have identical options.
-                  dirs << hostpath
-                  found = true
-                  break
-                end
-              end
-
-              break if found
-            end
-
-            if !found
-              dirmap[[hostpath]] = opts.dup
-            end
-          end
-
-          # Sort all the keys by length so that the directory closest to
-          # the root is exported first. Also, remove duplicates so that
-          # checkexports will work properly.
-          dirmap.each do |dirs, _|
-            dirs.uniq!
-            dirs.sort_by! { |d| d.length }
-          end
-
-          # Setup the NFS options
-          dirmap.each do |dirs, opts|
-            if !opts[:bsd__nfs_options]
-              opts[:bsd__nfs_options] = ["alldirs"]
-            end
-
-            hasmapall = false
-            opts[:bsd__nfs_options].each do |opt|
-              # mapall/maproot are mutually exclusive, so we have to check
-              # for both here.
-              if opt =~ /^mapall=/ || opt =~ /^maproot=/
-                hasmapall = true
-                break
-              end
-            end
-
-            if !hasmapall
-              opts[:bsd__nfs_options] << "mapall=#{opts[:map_uid]}:#{opts[:map_gid]}"
-            end
-
-            opts[:bsd__compiled_nfs_options] = opts[:bsd__nfs_options].map do |opt|
-              "-#{opt}"
-            end.join(" ")
-          end
-
-          logger.info("Exporting the following for NFS...")
-          dirmap.each do |dirs, opts|
-            logger.info("NFS DIR: #{dirs.inspect}")
-            logger.info("NFS OPTS: #{opts.inspect}")
-          end
-
-          output = Vagrant::Util::TemplateRenderer.render(nfs_exports_template,
-                                           uuid: id,
-                                           ips: ips,
-                                           folders: dirmap,
-                                           user: Process.uid)
-
-          # The sleep ensures that the output is truly flushed before any `sudo`
-          # commands are issued.
-          ui.info I18n.t("vagrant.hosts.bsd.nfs_export")
-          sleep 0.5
-
-          # First, clean up the old entry
-          nfs_cleanup(id)
-
-          # Only use "sudo" if we can't write to /etc/exports directly
-          sudo_command = ""
-          sudo_command = "sudo " if !File.writable?("/etc/exports")
-
-          # Output the rendered template into the exports
-          output.split("\n").each do |line|
-            line = Vagrant::Util::ShellQuote.escape(line, "'")
-            system(
-              "echo '#{line}' | " +
-              "#{sudo_command}tee -a /etc/exports >/dev/null")
-          end
-
-          # We run restart here instead of "update" just in case nfsd
-          # is not starting
-          system(*nfs_restart_command)
-        end
-
-        def self.nfs_exports_template(environment)
-          "nfs/exports"
-        end
-
-        def self.nfs_installed(environment)
-          !!Vagrant::Util::Which.which("nfsd")
-        end
-
-        def self.nfs_prune(environment, ui, valid_ids)
-          return if !File.exist?("/etc/exports")
-
-          logger = Log4r::Logger.new("vagrant::hosts::bsd")
-          logger.info("Pruning invalid NFS entries...")
-
-          output = false
-          user = Process.uid
-
-          File.read("/etc/exports").lines.each do |line|
-            if id = line[/^# VAGRANT-BEGIN:( #{user})? ([\.\/A-Za-z0-9\-_:]+?)$/, 2]
-              if valid_ids.include?(id)
-                logger.debug("Valid ID: #{id}")
-              else
-                if !output
-                  # We want to warn the user but we only want to output once
-                  ui.info I18n.t("vagrant.hosts.bsd.nfs_prune")
-                  output = true
-                end
-
-                logger.info("Invalid ID, pruning: #{id}")
-                nfs_cleanup(id)
-              end
-            end
-          end
-        rescue Errno::EACCES
-          raise Vagrant::Errors::NFSCantReadExports
-        end
-
-        def self.nfs_restart_command(environment)
-          ["sudo", "nfsd", "restart"]
-        end
-
-        protected
-
-        def self.nfs_cleanup(id)
-          return if !File.exist?("/etc/exports")
-
-          # Escape sed-sensitive characters:
-          id = id.gsub("/", "\\/")
-          id = id.gsub(".", "\\.")
-
-          user = Process.uid
-
-          command = []
-          command << "sudo" if !File.writable?("/etc/exports")
-          command += [
-            "sed", "-E", "-e",
-            "/^# VAGRANT-BEGIN:( #{user})? #{id}/," +
-            "/^# VAGRANT-END:( #{user})? #{id}/ d",
-            "-ibak",
-            "/etc/exports"
-          ]
-
-          # Use sed to just strip out the block of code which was inserted
-          # by Vagrant, and restart NFS.
-          system(*command)
-        end
-
-        def self.nfs_checkexports!
-          r = Vagrant::Util::Subprocess.execute("nfsd", "checkexports")
-          if r.exit_code != 0
-            raise Vagrant::Errors::NFSBadExports, output: r.stderr
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/hosts/gentoo/cap/nfs.rb

@@ -1,46 +0,0 @@
-require "vagrant/util/subprocess"
-require "vagrant/util/which"
-
-module VagrantPlugins
-  module HostGentoo
-    module Cap
-      class NFS
-        def self.nfs_check_command(env)
-          if systemd?
-            return "#{systemctl_path} status --no-pager nfs-server.service"
-          else
-            return "/etc/init.d/nfs status"
-          end
-        end
-
-        def self.nfs_start_command(env)
-          if systemd?
-            return "#{systemctl_path} start rpcbind nfs-server.service"
-          else
-            return "/etc/init.d/nfs restart"
-          end
-        end
-
-        protected
-
-        # This tests to see if systemd is used on the system. This is used
-        # in newer versions of Arch, and requires a change in behavior.
-        def self.systemd?
-          result = Vagrant::Util::Subprocess.execute("ps", "-o", "comm=", "1")
-          return result.stdout.chomp == "systemd"
-        end
-
-        def self.systemctl_path
-          path = Vagrant::Util::Which.which("systemctl")
-          return path if path
-
-          folders = ["/usr/bin", "/usr/sbin"]
-          folders.each do |folder|
-            path = "#{folder}/systemctl"
-            return path if File.file?(path)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/hosts/linux/cap/nfs.rb

@@ -1,194 +0,0 @@
-require "vagrant/util"
-require "vagrant/util/shell_quote"
-require "vagrant/util/retryable"
-
-module VagrantPlugins
-  module HostLinux
-    module Cap
-      class NFS
-
-        NFS_EXPORTS_PATH = "/etc/exports".freeze
-        extend Vagrant::Util::Retryable
-
-        def self.nfs_apply_command(env)
-          "exportfs -ar"
-        end
-
-        def self.nfs_check_command(env)
-          "/etc/init.d/nfs-kernel-server status"
-        end
-
-        def self.nfs_start_command(env)
-          "/etc/init.d/nfs-kernel-server start"
-        end
-
-        def self.nfs_export(env, ui, id, ips, folders)
-          # Get some values we need before we do anything
-          nfs_apply_command = env.host.capability(:nfs_apply_command)
-          nfs_check_command = env.host.capability(:nfs_check_command)
-          nfs_start_command = env.host.capability(:nfs_start_command)
-
-          nfs_opts_setup(folders)
-          output = Vagrant::Util::TemplateRenderer.render('nfs/exports_linux',
-                                           uuid: id,
-                                           ips: ips,
-                                           folders: folders,
-                                           user: Process.uid)
-
-          ui.info I18n.t("vagrant.hosts.linux.nfs_export")
-          sleep 0.5
-
-          nfs_cleanup("#{Process.uid} #{id}")
-          output = "#{nfs_exports_content}\n#{output}"
-          nfs_write_exports(output)
-
-          if nfs_running?(nfs_check_command)
-            system("sudo #{nfs_apply_command}")
-          else
-            system("sudo #{nfs_start_command}")
-          end
-        end
-
-        def self.nfs_installed(environment)
-          retryable(tries: 10, on: TypeError) do
-            # Check procfs to see if NFSd is a supported filesystem
-            system("cat /proc/filesystems | grep nfsd > /dev/null 2>&1")
-          end
-        end
-
-        def self.nfs_prune(environment, ui, valid_ids)
-          return if !File.exist?(NFS_EXPORTS_PATH)
-
-          logger = Log4r::Logger.new("vagrant::hosts::linux")
-          logger.info("Pruning invalid NFS entries...")
-
-          user = Process.uid
-
-          # Create editor instance for removing invalid IDs
-          editor = Vagrant::Util::StringBlockEditor.new(nfs_exports_content)
-
-          # Build composite IDs with UID information and discover invalid entries
-          composite_ids = valid_ids.map do |v_id|
-            "#{user} #{v_id}"
-          end
-          remove_ids = editor.keys - composite_ids
-
-          logger.debug("Known valid NFS export IDs: #{valid_ids}")
-          logger.debug("Composite valid NFS export IDs with user: #{composite_ids}")
-          logger.debug("NFS export IDs to be removed: #{remove_ids}")
-          if !remove_ids.empty?
-            ui.info I18n.t("vagrant.hosts.linux.nfs_prune")
-            nfs_cleanup(remove_ids)
-          end
-        end
-
-        protected
-
-        def self.nfs_cleanup(remove_ids)
-          return if !File.exist?(NFS_EXPORTS_PATH)
-
-          editor = Vagrant::Util::StringBlockEditor.new(nfs_exports_content)
-          remove_ids = Array(remove_ids)
-
-          # Remove all invalid ID entries
-          remove_ids.each do |r_id|
-            editor.delete(r_id)
-          end
-          nfs_write_exports(editor.value)
-        end
-
-        def self.nfs_write_exports(new_exports_content)
-          if(nfs_exports_content != new_exports_content.strip)
-            begin
-              # Write contents out to temporary file
-              new_exports_file = Tempfile.create('vagrant')
-              new_exports_file.puts(new_exports_content)
-              new_exports_file.close
-              new_exports_path = new_exports_file.path
-
-              # Only use "sudo" if we can't write to /etc/exports directly
-              sudo_command = ""
-              sudo_command = "sudo " if !File.writable?(NFS_EXPORTS_PATH)
-
-              # Ensure new file mode and uid/gid match existing file to replace
-              existing_stat = File.stat(NFS_EXPORTS_PATH)
-              new_stat = File.stat(new_exports_path)
-              if existing_stat.mode != new_stat.mode
-                File.chmod(existing_stat.mode, new_exports_path)
-              end
-              if existing_stat.uid != new_stat.uid || existing_stat.gid != new_stat.gid
-                chown_cmd = "#{sudo_command}chown #{existing_stat.uid}:#{existing_stat.gid} #{new_exports_path}"
-                result = Vagrant::Util::Subprocess.execute(*Shellwords.split(chown_cmd))
-                if result.exit_code != 0
-                  raise Vagrant::Errors::NFSExportsFailed,
-                    command: chown_cmd,
-                    stderr: result.stderr,
-                    stdout: result.stdout
-                end
-              end
-              # Always force move the file to prevent overwrite prompting
-              mv_cmd = "#{sudo_command}mv -f #{new_exports_path} #{NFS_EXPORTS_PATH}"
-              result = Vagrant::Util::Subprocess.execute(*Shellwords.split(mv_cmd))
-              if result.exit_code != 0
-                raise Vagrant::Errors::NFSExportsFailed,
-                  command: mv_cmd,
-                  stderr: result.stderr,
-                  stdout: result.stdout
-              end
-            ensure
-              if File.exist?(new_exports_path)
-                File.unlink(new_exports_path)
-              end
-            end
-          end
-        end
-
-        def self.nfs_exports_content
-          if(File.exist?(NFS_EXPORTS_PATH))
-            if(File.readable?(NFS_EXPORTS_PATH))
-              File.read(NFS_EXPORTS_PATH)
-            else
-              cmd = "sudo cat #{NFS_EXPORTS_PATH}"
-              result = Vagrant::Util::Subprocess.execute(*Shellwords.split(cmd))
-              if result.exit_code != 0
-                raise Vagrant::Errors::NFSExportsFailed,
-                  command: cmd,
-                  stderr: result.stderr,
-                  stdout: result.stdout
-              else
-                result.stdout
-              end
-            end
-          else
-            ""
-          end
-        end
-
-        def self.nfs_opts_setup(folders)
-          folders.each do |k, opts|
-            if !opts[:linux__nfs_options]
-              opts[:linux__nfs_options] ||= ["rw", "no_subtree_check", "all_squash"]
-            end
-
-            # Only automatically set anonuid/anongid if they weren't
-            # explicitly set by the user.
-            hasgid = false
-            hasuid = false
-            opts[:linux__nfs_options].each do |opt|
-              hasgid = !!(opt =~ /^anongid=/) if !hasgid
-              hasuid = !!(opt =~ /^anonuid=/) if !hasuid
-            end
-
-            opts[:linux__nfs_options] << "anonuid=#{opts[:map_uid]}" if !hasuid
-            opts[:linux__nfs_options] << "anongid=#{opts[:map_gid]}" if !hasgid
-            opts[:linux__nfs_options] << "fsid=#{opts[:uuid]}"
-          end
-        end
-
-        def self.nfs_running?(check_command)
-          system(check_command)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/hosts/redhat/cap/nfs.rb

@@ -1,47 +0,0 @@
-require "pathname"
-
-module VagrantPlugins
-  module HostRedHat
-    module Cap
-      class NFS
-        def self.nfs_check_command(env)
-          "#{nfs_server_binary} status"
-        end
-
-        def self.nfs_start_command(env)
-          "#{nfs_server_binary} start"
-        end
-
-        protected
-
-        def self.nfs_server_binary
-          nfs_server_binary = "/etc/init.d/nfs"
-
-          # On Fedora 16+, systemd replaced init.d, so we have to use the
-          # proper NFS binary. This checks to see if we need to do that.
-          release_file = Pathname.new("/etc/redhat-release")
-          begin
-            release_file.open("r:ISO-8859-1:UTF-8") do |f|
-              match = /(Red Hat|CentOS|Fedora).* release ([0-9]+)/.match(f.gets)
-              if match
-                distribution = match[1]
-                version_number = match[2].to_i
-                if (distribution =~ /Fedora/ && version_number >= 16) ||
-                   (distribution =~ /Red Hat|CentOS/ && version_number >= 7)
-                  # "service nfs-server" will redirect properly to systemctl
-                  # when "service nfs-server restart" is called.
-                  nfs_server_binary = "/usr/sbin/service nfs-server"
-                end
-              end
-            end
-          rescue Errno::ENOENT
-            # File doesn't exist, not a big deal, assume we're on a
-            # lower version.
-          end
-
-          nfs_server_binary
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/kernel_v2/config/ssh_connect.rb

@@ -1,68 +0,0 @@
-module VagrantPlugins
-  module Kernel_V2
-    class SSHConnectConfig < Vagrant.plugin("2", :config)
-      attr_accessor :host
-      attr_accessor :port
-      attr_accessor :private_key_path
-      attr_accessor :username
-      attr_accessor :password
-      attr_accessor :insert_key
-      attr_accessor :keys_only
-      attr_accessor :paranoid
-      attr_accessor :compression
-      attr_accessor :dsa_authentication
-
-      def initialize
-        @host             = UNSET_VALUE
-        @port             = UNSET_VALUE
-        @private_key_path = UNSET_VALUE
-        @username         = UNSET_VALUE
-        @password         = UNSET_VALUE
-        @insert_key       = UNSET_VALUE
-        @keys_only        = UNSET_VALUE
-        @paranoid         = UNSET_VALUE
-        @compression      = UNSET_VALUE
-        @dsa_authentication = UNSET_VALUE
-      end
-
-      def finalize!
-        @host             = nil if @host == UNSET_VALUE
-        @port             = nil if @port == UNSET_VALUE
-        @private_key_path = nil if @private_key_path == UNSET_VALUE
-        @username         = nil if @username == UNSET_VALUE
-        @password         = nil if @password == UNSET_VALUE
-        @insert_key       = true if @insert_key == UNSET_VALUE
-        @keys_only        = true if @keys_only == UNSET_VALUE
-        @paranoid         = false if @paranoid == UNSET_VALUE
-        @compression      = true if @compression == UNSET_VALUE
-        @dsa_authentication = true if @dsa_authentication == UNSET_VALUE
-
-        if @private_key_path && !@private_key_path.is_a?(Array)
-          @private_key_path = [@private_key_path]
-        end
-      end
-
-      # NOTE: This is _not_ a valid config validation method, since it
-      # returns an _array_ of strings rather than a Hash. This is meant to
-      # be used with a subclass that handles this.
-      #
-      # @return [Array<String>]
-      def validate(machine)
-        errors = _detected_errors
-
-        if @private_key_path
-          @private_key_path.each do |raw_path|
-            path = File.expand_path(raw_path, machine.env.root_path)
-            if !File.file?(path)
-              errors << I18n.t(
-                "vagrant.config.ssh.private_key_missing",
-                path: raw_path)
-            end
-          end
-        end
-
-        errors
-      end
-    end
-  end
-end