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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/plugins/provisioners/ansible/provisioner/base.rb

@@ -0,0 +1,401 @@
+require_relative "../constants"
+require_relative "../errors"
+require_relative "../helpers"
+
+module VagrantPlugins
+  module Ansible
+    module Provisioner
+
+      # This class is a base class where the common functionality shared between
+      # both Ansible provisioners are stored.
+      # This is **not an actual provisioner**.
+      # Instead, {Host} (ansible) or {Guest} (ansible_local) should be used.
+
+      class Base < Vagrant.plugin("2", :provisioner)
+
+        RANGE_PATTERN = %r{(?:\[[a-z]:[a-z]\]|\[[0-9]+?:[0-9]+?\])}.freeze
+
+        ANSIBLE_PARAMETER_NAMES = {
+          Ansible::COMPATIBILITY_MODE_V1_8 => {
+            ansible_host: "ansible_ssh_host",
+            ansible_password: "ansible_ssh_pass",
+            ansible_port: "ansible_ssh_port",
+            ansible_user: "ansible_ssh_user",
+            ask_become_pass: "ask-sudo-pass",
+            become: "sudo",
+            become_user: "sudo-user",
+          },
+          Ansible::COMPATIBILITY_MODE_V2_0 => {
+            ansible_host: "ansible_host",
+            ansible_password: "ansible_password",
+            ansible_port: "ansible_port",
+            ansible_user: "ansible_user",
+            ask_become_pass: "ask-become-pass",
+            become: "become",
+            become_user: "become-user",
+          }
+        }
+
+        protected
+
+        def initialize(machine, config)
+          super
+          @control_machine = nil
+
+          @command_arguments = []
+          @environment_variables = {}
+          @inventory_machines = {}
+          @inventory_path = nil
+
+          @gathered_version_stdout = nil
+          @gathered_version_major = nil
+          @gathered_version = nil
+        end
+
+        def set_and_check_compatibility_mode
+          begin
+            set_gathered_ansible_version(gather_ansible_version)
+          rescue StandardError => e
+            # Nothing to do here, as the fallback on safe compatibility_mode is done below
+            @logger.error("Error while gathering the ansible version: #{e.to_s}")
+          end
+
+          if @gathered_version_major
+            if config.compatibility_mode == Ansible::COMPATIBILITY_MODE_AUTO
+              detect_compatibility_mode
+            elsif @gathered_version_major.to_i < 2 && config.compatibility_mode == Ansible::COMPATIBILITY_MODE_V2_0
+              # A better version comparator will be needed
+              # when more compatibility modes come... but so far let's keep it simple!
+              raise Ansible::Errors::AnsibleCompatibilityModeConflict,
+                ansible_version: @gathered_version,
+                system: @control_machine,
+                compatibility_mode: config.compatibility_mode
+            end
+          end
+
+          if config.compatibility_mode == Ansible::COMPATIBILITY_MODE_AUTO
+            config.compatibility_mode = Ansible::SAFE_COMPATIBILITY_MODE
+
+            @machine.env.ui.warn(I18n.t("vagrant.provisioners.ansible.compatibility_mode_not_detected",
+              compatibility_mode: config.compatibility_mode,
+              gathered_version: @gathered_version_stdout) +
+            "\n")
+          end
+
+          unless Ansible::COMPATIBILITY_MODES.slice(1..-1).include?(config.compatibility_mode)
+            raise Ansible::Errors::AnsibleProgrammingError,
+              message: "The config.compatibility_mode must be correctly set at this stage!",
+              details: "config.compatibility_mode: '#{config.compatibility_mode}'"
+          end
+
+          @lexicon = ANSIBLE_PARAMETER_NAMES[config.compatibility_mode]
+        end
+
+        def check_files_existence
+          check_path_is_a_file(config.playbook, :playbook)
+
+          check_path_exists(config.inventory_path, :inventory_path) if config.inventory_path
+          check_path_is_a_file(config.config_file, :config_file) if config.config_file
+          check_path_is_a_file(config.extra_vars[1..-1], :extra_vars) if has_an_extra_vars_file_argument
+          check_path_is_a_file(config.galaxy_role_file, :galaxy_role_file) if config.galaxy_role_file
+          check_path_is_a_file(config.vault_password_file, :vault_password_file) if config.vault_password_file
+        end
+
+        def get_environment_variables_for_shell_execution
+          shell_env_vars = []
+          @environment_variables.each_pair do |k, v|
+            if k =~ /ANSIBLE_SSH_ARGS|ANSIBLE_ROLES_PATH|ANSIBLE_CONFIG/
+              shell_env_vars << "#{k}='#{v}'"
+            else
+              shell_env_vars << "#{k}=#{v}"
+            end
+          end
+          shell_env_vars
+        end
+
+        def ansible_galaxy_command_for_shell_execution
+          command_values = {
+            role_file: "'#{get_galaxy_role_file}'",
+            roles_path: "'#{get_galaxy_roles_path}'"
+          }
+
+          shell_command = get_environment_variables_for_shell_execution
+
+          shell_command << config.galaxy_command % command_values
+
+          shell_command.flatten.join(' ')
+        end
+
+        def ansible_playbook_command_for_shell_execution
+          shell_command = get_environment_variables_for_shell_execution
+
+          shell_command << config.playbook_command
+
+          shell_args = []
+          @command_arguments.each do |arg|
+            if arg =~ /(--start-at-task|--limit)=(.+)/
+              shell_args << %Q(#{$1}="#{$2}")
+            elsif arg =~ /(--extra-vars)=(.+)/
+              shell_args << %Q(%s=%s) % [$1, $2.shellescape]
+            else
+              shell_args << arg
+            end
+          end
+
+          shell_command << shell_args
+
+          # Add the raw arguments at the end, to give them the highest precedence
+          shell_command << config.raw_arguments if config.raw_arguments
+
+          shell_command << config.playbook
+
+          shell_command.flatten.join(' ')
+        end
+
+        def prepare_common_command_arguments
+          # By default we limit by the current machine,
+          # but this can be overridden by the `limit` option.
+          if config.limit
+            @command_arguments << "--limit=#{Helpers::as_list_argument(config.limit)}"
+          else
+            @command_arguments << "--limit=#{@machine.name}"
+          end
+
+          @command_arguments << "--inventory-file=#{inventory_path}"
+          @command_arguments << "--extra-vars=#{extra_vars_argument}" if config.extra_vars
+          @command_arguments << "--#{@lexicon[:become]}" if config.become
+          @command_arguments << "--#{@lexicon[:become_user]}=#{config.become_user}" if config.become_user
+          @command_arguments << "#{verbosity_argument}" if verbosity_is_enabled?
+          @command_arguments << "--vault-password-file=#{config.vault_password_file}" if config.vault_password_file
+          @command_arguments << "--tags=#{Helpers::as_list_argument(config.tags)}" if config.tags
+          @command_arguments << "--skip-tags=#{Helpers::as_list_argument(config.skip_tags)}" if config.skip_tags
+          @command_arguments << "--start-at-task=#{config.start_at_task}" if config.start_at_task
+        end
+
+        def prepare_common_environment_variables
+          # Ensure Ansible output isn't buffered so that we receive output
+          # on a task-by-task basis.
+          @environment_variables["PYTHONUNBUFFERED"] = 1
+
+          # When Ansible output is piped in Vagrant integration, its default colorization is
+          # automatically disabled and the only way to re-enable colors is to use ANSIBLE_FORCE_COLOR.
+          @environment_variables["ANSIBLE_FORCE_COLOR"] = "true" if @machine.env.ui.color?
+          # Setting ANSIBLE_NOCOLOR is "unnecessary" at the moment, but this could change in the future
+          # (e.g. local provisioner [GH-2103], possible change in vagrant/ansible integration, etc.)
+          @environment_variables["ANSIBLE_NOCOLOR"] = "true" if !@machine.env.ui.color?
+
+          # Use ANSIBLE_ROLES_PATH to tell ansible-playbook where to look for roles
+          # (there is no equivalent command line argument in ansible-playbook)
+          @environment_variables["ANSIBLE_ROLES_PATH"] = get_galaxy_roles_path if config.galaxy_roles_path
+
+          prepare_ansible_config_environment_variable
+        end
+
+        def prepare_ansible_config_environment_variable
+          @environment_variables["ANSIBLE_CONFIG"] = config.config_file if config.config_file
+        end
+
+        # Auto-generate "safe" inventory file based on Vagrantfile,
+        # unless inventory_path is explicitly provided
+        def inventory_path
+          if config.inventory_path
+            config.inventory_path
+          else
+            @inventory_path ||= generate_inventory
+          end
+        end
+
+        def get_inventory_host_vars_string(machine_name)
+          # In Ruby, Symbol and String values are different, but
+          # Vagrant has to unify them for better user experience.
+          vars = config.host_vars[machine_name.to_sym]
+          if !vars
+            vars = config.host_vars[machine_name.to_s]
+          end
+          s = nil
+          if vars.is_a?(Hash)
+            s = vars.each.collect {
+              |k, v|
+                if v.is_a?(String) && v.include?(' ') && !v.match(/^('|")[^'"]+('|")$/)
+                  v = %Q('#{v}')
+                end
+                "#{k}=#{v}"
+              }.join(" ")
+          elsif vars.is_a?(Array)
+            s = vars.join(" ")
+          elsif vars.is_a?(String)
+            s = vars
+          end
+          if s and !s.empty? then s else nil end
+        end
+
+        def generate_inventory
+          inventory = "# Generated by Vagrant\n\n"
+
+          # This "abstract" step must fill the @inventory_machines list
+          # and return the list of supported host(s)
+          inventory += generate_inventory_machines
+
+          inventory += generate_inventory_groups
+
+          # This "abstract" step must create the inventory file and
+          # return its location path
+          # TODO: explain possible race conditions, etc.
+          @inventory_path = ship_generated_inventory(inventory)
+        end
+
+        # Write out groups information.
+        # All defined groups will be included, but only supported
+        # machines and defined child groups will be included.
+        def generate_inventory_groups
+          groups_of_groups = {}
+          defined_groups = []
+          group_vars = {}
+          inventory_groups = ""
+
+          # Verify if host range patterns exist and warn
+          if config.groups.any? { |gm| gm.to_s[RANGE_PATTERN] }
+            @machine.ui.warn(I18n.t("vagrant.provisioners.ansible.ansible_host_pattern_detected"))
+          end
+
+          config.groups.each_pair do |gname, gmembers|
+            if gname.is_a?(Symbol)
+              gname = gname.to_s
+            end
+
+            if gmembers.is_a?(String)
+              gmembers = gmembers.split(/\s+/)
+            elsif gmembers.is_a?(Hash)
+              gmembers = gmembers.each.collect{ |k, v| "#{k}=#{v}" }
+            elsif !gmembers.is_a?(Array)
+              gmembers = []
+            end
+
+            if gname.end_with?(":children")
+              groups_of_groups[gname] = gmembers
+              defined_groups << gname.sub(/:children$/, '')
+            elsif gname.end_with?(":vars")
+              group_vars[gname] = gmembers
+            else
+              defined_groups << gname
+              inventory_groups += "\n[#{gname}]\n"
+              gmembers.each do |gm|
+                # TODO : Expand and validate host range patterns
+                # against @inventory_machines list before adding them
+                # otherwise abort with an error message
+                if gm[RANGE_PATTERN]
+                  inventory_groups += "#{gm}\n"
+                end
+                inventory_groups += "#{gm}\n" if @inventory_machines.include?(gm.to_sym)
+              end
+            end
+          end
+
+          defined_groups.uniq!
+          groups_of_groups.each_pair do |gname, gmembers|
+            inventory_groups += "\n[#{gname}]\n"
+            gmembers.each do |gm|
+              inventory_groups += "#{gm}\n" if defined_groups.include?(gm)
+            end
+          end
+
+          group_vars.each_pair do |gname, gmembers|
+            if defined_groups.include?(gname.sub(/:vars$/, "")) || gname == "all:vars"
+              inventory_groups += "\n[#{gname}]\n" + gmembers.join("\n") + "\n"
+            end
+          end
+
+          return inventory_groups
+        end
+
+        def has_an_extra_vars_file_argument
+          config.extra_vars && config.extra_vars.kind_of?(String) && config.extra_vars =~ /^@.+$/
+        end
+
+        def extra_vars_argument
+          if has_an_extra_vars_file_argument
+            # A JSON or YAML file is referenced.
+            config.extra_vars
+          else
+            # Expected to be a Hash after config validation.
+            config.extra_vars.to_json
+          end
+        end
+
+        def get_galaxy_role_file
+          Helpers::expand_path_in_unix_style(config.galaxy_role_file, get_provisioning_working_directory)
+        end
+
+        def get_galaxy_roles_path
+          base_dir = get_provisioning_working_directory
+          if config.galaxy_roles_path
+            Helpers::expand_path_in_unix_style(config.galaxy_roles_path, base_dir)
+          else
+            playbook_path = Helpers::expand_path_in_unix_style(config.playbook, base_dir)
+            File.join(Pathname.new(playbook_path).parent, 'roles')
+          end
+        end
+
+        def ui_running_ansible_command(name, command)
+          @machine.ui.detail I18n.t("vagrant.provisioners.ansible.running_#{name}")
+          if verbosity_is_enabled?
+            # Show the ansible command in use
+            @machine.env.ui.detail command
+          end
+        end
+
+        def verbosity_is_enabled?
+          config.verbose && !config.verbose.to_s.empty?
+        end
+
+        def verbosity_argument
+          if config.verbose.to_s =~ /^-?(v+)$/
+            "-#{$+}"
+          else
+            # safe default, in case input strays
+            '-v'
+          end
+        end
+
+        private
+
+        def detect_compatibility_mode
+          if !@gathered_version_major || config.compatibility_mode != Ansible::COMPATIBILITY_MODE_AUTO
+            raise Ansible::Errors::AnsibleProgrammingError,
+              message: "The detect_compatibility_mode() function shouldn't have been called!",
+              details: %Q(config.compatibility_mode: '#{config.compatibility_mode}'
+gathered version major number: '#{@gathered_version_major}'
+gathered version stdout version:
+#{@gathered_version_stdout})
+          end
+
+          if @gathered_version_major.to_i <= 1
+            config.compatibility_mode = Ansible::COMPATIBILITY_MODE_V1_8
+          else
+            config.compatibility_mode = Ansible::COMPATIBILITY_MODE_V2_0
+          end
+
+          @machine.env.ui.warn(I18n.t("vagrant.provisioners.ansible.compatibility_mode_warning",
+            compatibility_mode: config.compatibility_mode,
+            ansible_version: @gathered_version) +
+          "\n")
+        end
+
+        def set_gathered_ansible_version(stdout_output)
+          @gathered_version_stdout = stdout_output
+          if !@gathered_version_stdout.empty?
+            first_line = @gathered_version_stdout.lines[0]
+            ansible_version_pattern = first_line.match(/(^ansible\s+)(.+)$/)
+            if ansible_version_pattern
+              _, @gathered_version, _ = ansible_version_pattern.captures
+              if @gathered_version
+                @gathered_version_major = @gathered_version.match(/^(\d)\..+$/).captures[0].to_i
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-1ee58c40e3f5/plugins/provisioners/ansible/provisioner/guest.rb

@@ -0,0 +1,197 @@
+require "tempfile"
+
+require_relative "base"
+
+module VagrantPlugins
+  module Ansible
+    module Provisioner
+      class Guest < Base
+        include Vagrant::Util
+
+        def initialize(machine, config)
+          super
+          @control_machine = "guest"
+          @logger = Log4r::Logger.new("vagrant::provisioners::ansible_guest")
+        end
+
+        def provision
+          check_files_existence
+          check_and_install_ansible
+
+          execute_ansible_galaxy_on_guest if config.galaxy_role_file
+          execute_ansible_playbook_on_guest
+        end
+
+        protected
+
+        #
+        # This handles verifying the Ansible installation, installing it if it was
+        # requested, and so on. This method will raise exceptions if things are wrong.
+        # The compatibility mode checks are also performed here in order to fetch the
+        # Ansible version information only once.
+        #
+        # Current limitations:
+        #   - The installation of a specific Ansible version is only supported by
+        #     the "pip" install_mode.
+        #   - There is no absolute guarantee that the automated installation will replace
+        #     a previous Ansible installation (although it works fine in many cases)
+        #
+        def check_and_install_ansible
+          @logger.info("Checking for Ansible installation...")
+
+          # If the guest cannot check if Ansible is installed,
+          # print a warning and try to continue without any installation attempt...
+          if !@machine.guest.capability?(:ansible_installed)
+            @machine.ui.warn(I18n.t("vagrant.provisioners.ansible.cannot_detect"))
+            return
+          end
+
+          # Try to install Ansible (if needed and requested)
+          if config.install &&
+             (config.version.to_s.to_sym == :latest ||
+              !@machine.guest.capability(:ansible_installed, config.version))
+            @machine.ui.detail I18n.t("vagrant.provisioners.ansible.installing")
+            @machine.guest.capability(:ansible_install, config.install_mode, config.version, config.pip_args)
+          end
+
+          # This step will also fetch the Ansible version data into related instance variables
+          set_and_check_compatibility_mode
+
+          # Check if requested ansible version is available
+          if (!config.version.empty? &&
+              config.version.to_s.to_sym != :latest &&
+              config.version != @gathered_version)
+            raise Ansible::Errors::AnsibleVersionMismatch,
+              system: @control_machine,
+              required_version: config.version,
+              current_version: @gathered_version
+          end
+        end
+
+        def gather_ansible_version
+          raw_output = ""
+
+          result = @machine.communicate.execute(
+            "ansible --version",
+            error_class: Ansible::Errors::AnsibleNotFoundOnGuest,
+            error_key: :ansible_not_found_on_guest) do |type, output|
+            if type == :stdout && output.lines[0]
+              raw_output = output.lines[0]
+            end
+          end
+
+          if result != 0
+            raw_output = ""
+          end
+
+          raw_output
+        end
+
+        def get_provisioning_working_directory
+          config.provisioning_path
+        end
+
+        def execute_ansible_galaxy_on_guest
+          prepare_ansible_config_environment_variable
+
+          execute_ansible_command_on_guest "galaxy", ansible_galaxy_command_for_shell_execution
+        end
+
+        def execute_ansible_playbook_on_guest
+          prepare_common_command_arguments
+          prepare_common_environment_variables
+
+          execute_ansible_command_on_guest "playbook", ansible_playbook_command_for_shell_execution
+        end
+
+        def execute_ansible_command_on_guest(name, command)
+          remote_command = "cd #{config.provisioning_path} && #{command}"
+
+          ui_running_ansible_command name, remote_command
+
+          result = execute_on_guest(remote_command)
+          raise Ansible::Errors::AnsibleCommandFailed if result != 0
+        end
+
+        def execute_on_guest(command)
+          @machine.communicate.execute(command, error_check: false) do |type, data|
+            if [:stderr, :stdout].include?(type)
+              @machine.env.ui.info(data, new_line: false, prefix: false)
+            end
+          end
+        end
+
+        def ship_generated_inventory(inventory_content)
+          inventory_basedir = File.join(config.tmp_path, "inventory")
+          inventory_path = File.join(inventory_basedir, "vagrant_ansible_local_inventory")
+
+          create_and_chown_remote_folder(inventory_basedir)
+          @machine.communicate.sudo("rm -f #{inventory_path}", error_check: false)
+
+          Tempfile.open("vagrant-ansible-local-inventory-#{@machine.name}") do |f|
+            f.binmode
+            f.write(inventory_content)
+            f.fsync
+            f.close
+            @machine.communicate.upload(f.path, inventory_path)
+          end
+
+          return inventory_basedir
+        end
+
+        def generate_inventory_machines
+          machines = ""
+
+          # TODO: Instead, why not loop over active_machines and skip missing guests, like in Host?
+          machine.env.machine_names.each do |machine_name|
+            begin
+              @inventory_machines[machine_name] = machine_name
+              if @machine.name == machine_name
+                machines += "#{machine_name} ansible_connection=local\n"
+              else
+                machines += "#{machine_name}\n"
+              end
+              host_vars = get_inventory_host_vars_string(machine_name)
+              machines.sub!(/\n$/, " #{host_vars}\n") if host_vars
+            end
+          end
+
+          return machines
+        end
+
+        def create_and_chown_remote_folder(path)
+          @machine.communicate.tap do |comm|
+            comm.sudo("mkdir -p #{path}")
+            comm.sudo("chown -h #{@machine.ssh_info[:username]} #{path}")
+          end
+        end
+
+        def check_path(path, test_args, option_name)
+          # Checks for the existence of given file (or directory) on the guest system,
+          # and error if it doesn't exist.
+
+          remote_path = Helpers::expand_path_in_unix_style(path, config.provisioning_path)
+          command = "test #{test_args} '#{remote_path}'"
+
+          @machine.communicate.execute(
+            command,
+            error_class: Ansible::Errors::AnsibleError,
+            error_key: :config_file_not_found,
+            config_option: option_name,
+            path: remote_path,
+            system: @control_machine
+          )
+        end
+
+        def check_path_is_a_file(path, error_message_key)
+          check_path(path, "-f", error_message_key)
+        end
+
+        def check_path_exists(path, error_message_key)
+          check_path(path, "-e", error_message_key)
+        end
+
+      end
+    end
+  end
+end