vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/salt/provisioner.rb

@@ -1,472 +0,0 @@
-require 'json'
-
-module VagrantPlugins
-  module Salt
-    class Provisioner < Vagrant.plugin("2", :provisioner)
-
-      # Default path values to set within configuration only
-      # if configuration value is unset and local path exists
-      OPTIMISTIC_PATH_DEFAULTS = Hash[*[
-        "minion_config", "salt/minion",
-        "minion_key", "salt/key/minion.key",
-        "minion_pub", "salt/key/minion.pub",
-        "master_config", "salt/master",
-        "master_key", "salt/key/master.key",
-        "master_pub", "salt/key/master.pub"
-      ].map(&:freeze)].freeze
-
-      def provision
-        set_default_configs
-        upload_configs
-        upload_keys
-        run_bootstrap_script
-        call_overstate
-        call_highstate
-        call_orchestrate
-      end
-
-      # Return a list of accepted keys
-      def keys(group='minions')
-        out = @machine.communicate.sudo("salt-key --out json") do |type, output|
-          begin
-            if type == :stdout
-              out = JSON::load(output)
-              break out[group]
-            end
-          end
-        end
-        return out
-      end
-
-      ## Utilities
-      def expanded_path(rel_path)
-        Pathname.new(rel_path).expand_path(@machine.env.root_path)
-      end
-
-      def binaries_found
-        ## Determine States, ie: install vs configure
-        desired_binaries = []
-        if !@config.no_minion
-          if @machine.config.vm.communicator == :winrm
-            desired_binaries.push('C:\\salt\\salt-minion.bat')
-            desired_binaries.push('C:\\salt\\salt-call.bat')
-          else
-            desired_binaries.push('salt-minion')
-            desired_binaries.push('salt-call')
-          end
-        end
-
-        if @config.install_master
-          if @machine.config.vm.communicator == :winrm
-            raise Vagrant::Errors::ProvisionerWinRMUnsupported,
-              name: "salt.install_master"
-          else
-            desired_binaries.push('salt-master')
-          end
-        end
-
-        if @config.install_syndic
-          if @machine.config.vm.communicator == :winrm
-            raise Vagrant::Errors::ProvisionerWinRMUnsupported,
-              name: "salt.install_syndic"
-          else
-            desired_binaries.push('salt-syndic')
-          end
-        end
-
-        found = true
-        for binary in desired_binaries
-          @machine.env.ui.info "Checking if %s is installed" % binary
-          if !@machine.communicate.test("which %s" % binary)
-            @machine.env.ui.info "%s was not found." % binary
-            found = false
-          else
-            @machine.env.ui.info "%s found" % binary
-          end
-        end
-
-        return found
-      end
-
-      def need_configure
-        @config.minion_config or @config.minion_key or @config.master_config or @config.master_key or @config.grains_config or @config.version or @config.minion_json_config or @config.master_json_config
-      end
-
-      def need_install
-        if @config.always_install
-          return true
-        else
-          return !binaries_found()
-        end
-      end
-
-      def temp_config_dir
-        if @machine.config.vm.communicator == :winrm
-          return @config.temp_config_dir || "C:\\tmp"
-        else
-          return @config.temp_config_dir || "/tmp"
-        end
-      end
-
-      # Generates option string for bootstrap script
-      def bootstrap_options(install, configure, config_dir)
-        options = ""
-
-        # Any extra options passed to bootstrap
-        if @config.bootstrap_options
-          options = "%s %s" % [options, @config.bootstrap_options]
-        end
-
-        if @config.master_json_config && @machine.config.vm.communicator != :winrm
-          config = @config.master_json_config
-          options = "%s -J '#{config}'" % [options]
-        end
-
-        if @config.minion_json_config && @machine.config.vm.communicator != :winrm
-          config = @config.minion_json_config
-          options = "%s -j '#{config}'" % [options]
-        end
-
-        if configure && @machine.config.vm.communicator != :winrm
-          options = "%s -F -c %s" % [options, config_dir]
-        end
-
-        if @config.seed_master && @config.install_master && @machine.config.vm.communicator != :winrm
-          seed_dir = "/tmp/minion-seed-keys"
-          @machine.communicate.sudo("mkdir -p -m777 #{seed_dir}")
-          @config.seed_master.each do |name, keyfile|
-            sourcepath = expanded_path(keyfile).to_s
-            dest = "#{seed_dir}/#{name}"
-            @machine.communicate.upload(sourcepath, dest)
-          end
-          options = "#{options} -k #{seed_dir}"
-        end
-
-        if configure && !install && @machine.config.vm.communicator != :winrm
-          options = "%s -C" % options
-        end
-
-        if @config.install_master && @machine.config.vm.communicator != :winrm
-          options = "%s -M" % options
-        end
-
-        if @config.install_syndic && @machine.config.vm.communicator != :winrm
-          options = "%s -S" % options
-        end
-
-        if @config.no_minion && @machine.config.vm.communicator != :winrm
-          options = "%s -N" % options
-        end
-
-        if @config.install_type && @machine.config.vm.communicator != :winrm
-          options = "%s %s" % [options, @config.install_type]
-        end
-
-        if @config.install_args && @machine.config.vm.communicator != :winrm
-          options = "%s %s" % [options, @config.install_args]
-        end
-
-        if @config.verbose
-          @machine.env.ui.info "Using Bootstrap Options: %s" % options
-        end
-
-        return options
-      end
-
-      ## Actions
-      # Get pillar string to pass with the salt command
-      def get_pillar
-        " pillar='#{@config.pillar_data.to_json}'" if !@config.pillar_data.empty?
-      end
-
-      # Get colorization option string to pass with the salt command
-      def get_colorize
-        @config.colorize ? " --force-color" : " --no-color"
-      end
-
-      # Get log output level option string to pass with the salt command
-      def get_loglevel
-        log_levels = ["all", "garbage", "trace", "debug", "info", "warning", "error", "quiet"]
-        if log_levels.include? @config.log_level
-          " --log-level=#{@config.log_level}"
-        else
-          " --log-level=debug"
-        end
-      end
-
-      # Get command-line options for masterless provisioning
-      def get_masterless
-        options = ""
-
-        if @config.masterless
-          options = " --local"
-          if @config.minion_id
-            options += " --id #{@config.minion_id}"
-          end
-        end
-
-        return options
-      end
-
-      # Append additional arguments to the salt command
-      def get_salt_args
-        " " + Array(@config.salt_args).join(" ")
-      end
-
-      # Append additional arguments to the salt-call command
-      def get_call_args
-        " " + Array(@config.salt_call_args).join(" ")
-      end
-
-      # Copy master and minion configs to VM
-      def upload_configs
-        if @config.minion_config
-          @machine.env.ui.info "Copying salt minion config to vm."
-          @machine.communicate.upload(expanded_path(@config.minion_config).to_s, temp_config_dir + "/minion")
-        end
-
-        if @config.master_config
-          @machine.env.ui.info "Copying salt master config to vm."
-          @machine.communicate.upload(expanded_path(@config.master_config).to_s, temp_config_dir + "/master")
-        end
-
-        if @config.grains_config
-          @machine.env.ui.info "Copying salt grains config to vm."
-          @machine.communicate.upload(expanded_path(@config.grains_config).to_s, temp_config_dir + "/grains")
-        end
-      end
-
-      # Copy master and minion keys to VM
-      def upload_keys
-        if @config.minion_key and @config.minion_pub
-          @machine.env.ui.info "Uploading minion keys."
-          @machine.communicate.upload(expanded_path(@config.minion_key).to_s, temp_config_dir + "/minion.pem")
-          @machine.communicate.sudo("chmod u+w #{temp_config_dir}/minion.pem")
-          @machine.communicate.upload(expanded_path(@config.minion_pub).to_s, temp_config_dir + "/minion.pub")
-        end
-
-        if @config.master_key and @config.master_pub
-          @machine.env.ui.info "Uploading master keys."
-          @machine.communicate.upload(expanded_path(@config.master_key).to_s, temp_config_dir + "/master.pem")
-          @machine.communicate.sudo("chmod u+w #{temp_config_dir}/master.pem")
-          @machine.communicate.upload(expanded_path(@config.master_pub).to_s, temp_config_dir + "/master.pub")
-        end
-      end
-
-      # Get bootstrap file location, bundled or custom
-      def get_bootstrap
-        if @config.bootstrap_script
-          bootstrap_abs_path = expanded_path(@config.bootstrap_script)
-        else
-          if @machine.config.vm.communicator == :winrm
-            bootstrap_abs_path = Pathname.new("../bootstrap-salt.ps1").expand_path(__FILE__)
-          else
-            bootstrap_abs_path = Pathname.new("../bootstrap-salt.sh").expand_path(__FILE__)
-          end
-        end
-
-        return bootstrap_abs_path
-      end
-
-      # Determine if we are configure and/or installing, then do either
-      def run_bootstrap_script
-        install = need_install()
-        configure = need_configure()
-        config_dir = temp_config_dir()
-        options = bootstrap_options(install, configure, config_dir)
-
-        if configure or install
-          if configure and !install
-            @machine.env.ui.info "Salt binaries found. Configuring only."
-          else
-            @machine.env.ui.info "Bootstrapping Salt... (this may take a while)"
-          end
-
-          bootstrap_path = get_bootstrap
-          if @machine.config.vm.communicator == :winrm
-            if @config.version
-              options += " -version %s" % @config.version
-            end
-            if @config.python_version
-              options += " -pythonVersion %s" % @config.python_version
-            end
-            if @config.run_service
-              @machine.env.ui.info "Salt minion will be stopped after installing."
-              options += " -runservice %s" % @config.run_service
-            end
-            if @config.minion_id
-              @machine.env.ui.info "Setting minion to @config.minion_id."
-              options += " -minion %s" % @config.minion_id
-            end
-            if @config.master_id
-              @machine.env.ui.info "Setting master to @config.master_id."
-              options += " -master %s" % @config.master_id
-            end
-            bootstrap_destination = File.join(config_dir, "bootstrap_salt.ps1")
-          else
-            bootstrap_destination = File.join(config_dir, "bootstrap_salt.sh")
-          end
-
-          if @machine.communicate.test("test -f %s" % bootstrap_destination)
-            @machine.communicate.sudo("rm -f %s" % bootstrap_destination)
-          end
-          @machine.communicate.upload(bootstrap_path.to_s, bootstrap_destination)
-          @machine.communicate.sudo("chmod +x %s" % bootstrap_destination)
-          if @machine.config.vm.communicator == :winrm
-            bootstrap = @machine.communicate.sudo("powershell.exe -NonInteractive -NoProfile -executionpolicy bypass -file %s %s" % [bootstrap_destination, options]) do |type, data|
-              if data[0] == "\n"
-                # Remove any leading newline but not whitespace. If we wanted to
-                # remove newlines and whitespace we would have used data.lstrip
-                data = data[1..-1]
-              end
-              if @config.verbose
-                @machine.env.ui.info(data.rstrip)
-              end
-            end
-          else
-            bootstrap = @machine.communicate.sudo("%s %s" % [bootstrap_destination, options]) do |type, data|
-              if data[0] == "\n"
-                # Remove any leading newline but not whitespace. If we wanted to
-                # remove newlines and whitespace we would have used data.lstrip
-                data = data[1..-1]
-              end
-              if @config.verbose
-                @machine.env.ui.info(data.rstrip)
-              end
-            end
-          end
-
-          if !bootstrap
-            raise Salt::Errors::SaltError, :bootstrap_failed
-          end
-
-          if configure and !install
-            @machine.env.ui.info "Salt successfully configured!"
-          elsif configure and install
-            @machine.env.ui.info "Salt successfully configured and installed!"
-          elsif !configure and install
-            @machine.env.ui.info "Salt successfully installed!"
-          end
-        else
-          @machine.env.ui.info "Salt did not need installing or configuring."
-        end
-      end
-
-      def call_overstate
-        if @config.run_overstate
-          # If verbose is on, do not duplicate a failed command's output in the error message.
-          ssh_opts = {}
-          if @config.verbose
-            ssh_opts = { error_key: :ssh_bad_exit_status_muted }
-          end
-          if @config.install_master
-            @machine.env.ui.info "Calling state.overstate... (this may take a while)"
-            @machine.communicate.sudo("salt '*' saltutil.sync_all")
-            @machine.communicate.sudo("salt-run state.over", ssh_opts) do |type, data|
-              if @config.verbose
-                @machine.env.ui.info(data)
-              end
-            end
-          else
-            @machine.env.ui.info "run_overstate does not make sense on a minion. Not running state.overstate."
-          end
-        else
-          @machine.env.ui.info "run_overstate set to false. Not running state.overstate."
-        end
-      end
-
-      def call_highstate
-        if @config.run_highstate
-          # If verbose is on, do not duplicate a failed command's output in the error message.
-          ssh_opts = {}
-          if @config.verbose
-            ssh_opts = { error_key: :ssh_bad_exit_status_muted }
-          end
-
-          @machine.env.ui.info "Calling state.highstate... (this may take a while)"
-          if @config.install_master
-            unless @config.masterless
-              @machine.communicate.sudo("salt '*' saltutil.sync_all")
-            end
-            options = "#{get_masterless}#{get_loglevel}#{get_colorize}#{get_pillar}#{get_salt_args}"
-            @machine.communicate.sudo("salt '*' state.highstate --verbose#{options}", ssh_opts) do |type, data|
-            if @config.verbose
-                @machine.env.ui.info(data.rstrip)
-            end
-          end
-          else
-            if @machine.config.vm.communicator == :winrm
-              opts = { elevated: true }
-              unless @config.masterless
-                @machine.communicate.execute("C:\\salt\\salt-call.bat saltutil.sync_all", opts)
-              end
-              # TODO: something equivalent to { error_key: :ssh_bad_exit_status_muted }?
-              options = "#{get_masterless}#{get_loglevel}#{get_colorize}#{get_pillar}#{get_call_args}"
-              @machine.communicate.execute("C:\\salt\\salt-call.bat state.highstate --retcode-passthrough#{options}", opts) do |type, data|
-                if @config.verbose
-                  @machine.env.ui.info(data.rstrip)
-                end
-              end
-            else
-              unless @config.masterless
-                @machine.communicate.sudo("salt-call saltutil.sync_all")
-              end
-              options = "#{get_masterless}#{get_loglevel}#{get_colorize}#{get_pillar}#{get_call_args}"
-              @machine.communicate.sudo("salt-call state.highstate --retcode-passthrough#{options}", ssh_opts) do |type, data|
-                if @config.verbose
-                  @machine.env.ui.info(data.rstrip)
-                end
-              end
-            end
-          end
-        else
-          @machine.env.ui.info "run_highstate set to false. Not running state.highstate."
-        end
-      end
-
-      def call_orchestrate
-        if !@config.orchestrations
-          @machine.env.ui.info "orchestrate is nil. Not running state.orchestrate."
-          return
-        end
-
-        if !@config.install_master
-          @machine.env.ui.info "orchestrate does not make sense on a minion. Not running state.orchestrate."
-          return
-        end
-
-        log_output = lambda do |type, data|
-          if @config.verbose
-            @machine.env.ui.info(data)
-          end
-        end
-
-        # If verbose is on, do not duplicate a failed command's output in the error message.
-        ssh_opts = {}
-        if @config.verbose
-          ssh_opts = { error_key: :ssh_bad_exit_status_muted }
-        end
-
-        @machine.env.ui.info "Running the following orchestrations: #{@config.orchestrations}"
-        @machine.env.ui.info "Running saltutil.sync_all before orchestrating"
-        @machine.communicate.sudo("salt '*' saltutil.sync_all", ssh_opts, &log_output)
-
-        @config.orchestrations.each do |orchestration|
-          cmd = "salt-run -l info state.orchestrate #{orchestration}"
-          @machine.env.ui.info "Calling #{cmd}... (this may take a while)"
-          @machine.communicate.sudo(cmd, ssh_opts, &log_output)
-        end
-      end
-
-      # Sets optimistic default values into config
-      def set_default_configs
-        OPTIMISTIC_PATH_DEFAULTS.each do |config_key, config_default|
-          if config.send(config_key) == Config::UNSET_VALUE
-            config_value = File.exist?(expanded_path(config_default)) ? config_default : nil
-            config.send("#{config_key}=", config_value)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,133 +0,0 @@
-require 'uri'
-
-module VagrantPlugins
-  module Shell
-    class Config < Vagrant.plugin("2", :config)
-      attr_accessor :inline
-      attr_accessor :path
-      attr_accessor :md5
-      attr_accessor :sha1
-      attr_accessor :env
-      attr_accessor :upload_path
-      attr_accessor :args
-      attr_accessor :privileged
-      attr_accessor :binary
-      attr_accessor :keep_color
-      attr_accessor :name
-      attr_accessor :sensitive
-      attr_accessor :powershell_args
-      attr_accessor :powershell_elevated_interactive
-
-      def initialize
-        @args                  = UNSET_VALUE
-        @inline                = UNSET_VALUE
-        @path                  = UNSET_VALUE
-        @md5                   = UNSET_VALUE
-        @sha1                  = UNSET_VALUE
-        @env                   = UNSET_VALUE
-        @upload_path           = UNSET_VALUE
-        @privileged            = UNSET_VALUE
-        @binary                = UNSET_VALUE
-        @keep_color            = UNSET_VALUE
-        @name                  = UNSET_VALUE
-        @sensitive             = UNSET_VALUE
-        @powershell_args       = UNSET_VALUE
-        @powershell_elevated_interactive  = UNSET_VALUE
-      end
-
-      def finalize!
-        @args                 = nil if @args == UNSET_VALUE
-        @inline               = nil if @inline == UNSET_VALUE
-        @path                 = nil if @path == UNSET_VALUE
-        @md5                  = nil if @md5 == UNSET_VALUE
-        @sha1                 = nil if @sha1 == UNSET_VALUE
-        @env                  = {}  if @env == UNSET_VALUE
-        @upload_path          = "/tmp/vagrant-shell" if @upload_path == UNSET_VALUE
-        @privileged           = true if @privileged == UNSET_VALUE
-        @binary               = false if @binary == UNSET_VALUE
-        @keep_color           = false if @keep_color == UNSET_VALUE
-        @name                 = nil if @name == UNSET_VALUE
-        @sensitive            = false if @sensitive == UNSET_VALUE
-        @powershell_args      = "-ExecutionPolicy Bypass" if @powershell_args == UNSET_VALUE
-        @powershell_elevated_interactive = false if @powershell_elevated_interactive == UNSET_VALUE
-
-        if @args && args_valid?
-          @args = @args.is_a?(Array) ? @args.map { |a| a.to_s } : @args.to_s
-        end
-
-        if @sensitive
-          @env.each do |_, v|
-            Vagrant::Util::CredentialScrubber.sensitive(v)
-          end
-        end
-      end
-
-      def validate(machine)
-        errors = _detected_errors
-
-        # Validate that the parameters are properly set
-        if path && inline
-          errors << I18n.t("vagrant.provisioners.shell.path_and_inline_set")
-        elsif !path && !inline
-          errors << I18n.t("vagrant.provisioners.shell.no_path_or_inline")
-        end
-
-        # If it is not an URL, we validate the existence of a script to upload
-        if path && !remote?
-          expanded_path = Pathname.new(path).expand_path(machine.env.root_path)
-          if !expanded_path.file?
-            errors << I18n.t("vagrant.provisioners.shell.path_invalid",
-                              path: expanded_path)
-          else
-            data = expanded_path.read(16)
-            if data && !data.valid_encoding?
-              errors << I18n.t(
-                "vagrant.provisioners.shell.invalid_encoding",
-                actual: data.encoding.to_s,
-                default: Encoding.default_external.to_s,
-                path: expanded_path.to_s)
-            end
-          end
-        end
-
-        if !env.is_a?(Hash)
-          errors << I18n.t("vagrant.provisioners.shell.env_must_be_a_hash")
-        end
-
-        # There needs to be a path to upload the script to
-        if !upload_path
-          errors << I18n.t("vagrant.provisioners.shell.upload_path_not_set")
-        end
-
-        if !args_valid?
-          errors << I18n.t("vagrant.provisioners.shell.args_bad_type")
-        end
-
-        if powershell_elevated_interactive && !privileged
-          errors << I18n.t("vagrant.provisioners.shell.interactive_not_elevated")
-        end
-
-        { "shell provisioner" => errors }
-      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
-
-      def remote?
-        path =~ URI.regexp(["ftp", "http", "https"])
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/plugins/provisioners/shell/plugin.rb

@@ -1,23 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module Shell
-    class Plugin < Vagrant.plugin("2")
-      name "shell"
-      description <<-DESC
-      Provides support for provisioning your virtual machines with
-      shell scripts.
-      DESC
-
-      config(:shell, :provisioner) do
-        require File.expand_path("../config", __FILE__)
-        Config
-      end
-
-      provisioner(:shell) do
-        require File.expand_path("../provisioner", __FILE__)
-        Provisioner
-      end
-    end
-  end
-end