402 lines
15 KiB
Ruby
402 lines
15 KiB
Ruby
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
|