vagrant-ansible-fixed 0.1.0

data/lib/plugin.rb

@@ -0,0 +1,80 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Ansible_Fixed
+    class Plugin < Vagrant.plugin("2")
+
+      name "ansible_fixed"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with Ansible
+      from the Vagrant host (`ansible`) or from the guests (`ansible_local`).
+      DESC with patch for Windows systems until version 1.8.2 is public
+
+      config("ansible_fixed", :provisioner) do
+        require_relative "config/host"
+        Config::Host
+      end
+
+      config("ansible_fixed_local", :provisioner) do
+        require_relative "config/guest"
+        Config::Guest
+      end
+
+      provisioner("ansible_fixed") do
+        require_relative "provisioner/host"
+        Provisioner::Host
+      end
+
+      provisioner("ansible_fixed_local") do
+        require_relative "provisioner/guest"
+        Provisioner::Guest
+      end
+
+      guest_capability(:linux, :ansible_installed) do
+        require_relative "cap/guest/posix/ansible_installed"
+        Cap::Guest::POSIX::AnsibleInstalled
+      end
+
+      guest_capability(:freebsd, :ansible_installed) do
+        require_relative "cap/guest/posix/ansible_installed"
+        Cap::Guest::POSIX::AnsibleInstalled
+      end
+
+      guest_capability(:arch, :ansible_install) do
+        require_relative "cap/guest/arch/ansible_install"
+        Cap::Guest::Arch::AnsibleInstall
+      end
+
+      guest_capability(:debian, :ansible_install) do
+        require_relative "cap/guest/debian/ansible_install"
+        Cap::Guest::Debian::AnsibleInstall
+      end
+
+      guest_capability(:ubuntu, :ansible_install) do
+        require_relative "cap/guest/ubuntu/ansible_install"
+        Cap::Guest::Ubuntu::AnsibleInstall
+      end
+
+      guest_capability(:fedora, :ansible_install) do
+        require_relative "cap/guest/fedora/ansible_install"
+        Cap::Guest::Fedora::AnsibleInstall
+      end
+
+      guest_capability(:redhat, :ansible_install) do
+        require_relative "cap/guest/redhat/ansible_install"
+        Cap::Guest::RedHat::AnsibleInstall
+      end
+
+      guest_capability(:suse, :ansible_install) do
+        require_relative "cap/guest/suse/ansible_install"
+        Cap::Guest::SUSE::AnsibleInstall
+      end
+
+      guest_capability(:freebsd, :ansible_install) do
+        require_relative "cap/guest/freebsd/ansible_install"
+        Cap::Guest::FreeBSD::AnsibleInstall
+      end
+
+    end
+  end
+end

data/lib/provisioner/base.rb

@@ -0,0 +1,219 @@
+require_relative "../errors"
+require_relative "../helpers"
+
+module VagrantPlugins
+  module Ansible_Fixed
+    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
+
+        protected
+
+        def initialize(machine, config)
+          super
+
+          @command_arguments = []
+          @environment_variables = {}
+          @inventory_machines = {}
+          @inventory_path = nil
+        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 << "--sudo" if config.sudo
+          @command_arguments << "--sudo-user=#{config.sudo_user}" if config.sudo_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
+
+          # Finally, add the raw configuration options, which has the highest precedence
+          # and can therefore potentially override any other options of this provisioner.
+          @command_arguments.concat(Helpers::as_array(config.raw_arguments)) if config.raw_arguments
+        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?
+        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| "#{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$/, ""))
+              inventory_groups += "\n[#{gname}]\n" + gmembers.join("\n") + "\n"
+            end
+          end
+
+          return inventory_groups
+        end
+
+        def extra_vars_argument
+          if config.extra_vars.kind_of?(String) and config.extra_vars =~ /^@.+$/
+            # 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(base_dir)
+          Helpers::expand_path_in_unix_style(config.galaxy_role_file, base_dir)
+        end
+
+        def get_galaxy_roles_path(base_dir)
+          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
+
+      end
+    end
+  end
+end

data/lib/provisioner/guest.rb

@@ -0,0 +1,149 @@
+require 'tempfile'
+
+require_relative "base"
+
+module VagrantPlugins
+  module Ansible_Fixed
+    module Provisioner
+      class Guest < Base
+
+        def initialize(machine, config)
+          super
+          @logger = Log4r::Logger.new("vagrant::provisioners::ansible_guest")
+        end
+
+        def provision
+          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.
+        #
+        # Current limitations:
+        #   - The installation of a specific Ansible version is not supported.
+        #     Such feature is difficult to systematically provide via package repositories (apt, yum, ...).
+        #     Installing via pip python packaging or directly from github source would be appropriate,
+        #     but these approaches require more dependency burden.
+        #   - There is no guarantee that the automated installation will replace
+        #     a previous Ansible installation.
+        #
+        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)
+          end
+
+          # Check that ansible binaries are well installed on the guest,
+          @machine.communicate.execute(
+            "ansible-galaxy info --help && ansible-playbook --help",
+            :error_class => Ansible::Errors::AnsibleNotFoundOnGuest,
+            :error_key => :ansible_not_found_on_guest)
+
+          # Check if requested ansible version is available
+          if (!config.version.empty? &&
+              config.version.to_s.to_sym != :latest &&
+              !@machine.guest.capability(:ansible_installed, config.version))
+            raise Ansible::Errors::AnsibleVersionNotFoundOnGuest, required_version: config.version.to_s
+          end
+        end
+
+        def execute_ansible_galaxy_on_guest
+          command_values = {
+            :role_file => get_galaxy_role_file(config.provisioning_path),
+            :roles_path => get_galaxy_roles_path(config.provisioning_path)
+          }
+          remote_command = config.galaxy_command % command_values
+
+          execute_ansible_command_on_guest "galaxy", remote_command
+        end
+
+        def execute_ansible_playbook_on_guest
+          prepare_common_command_arguments
+          prepare_common_environment_variables
+
+          command = (%w(ansible-playbook) << @command_arguments << config.playbook).flatten
+          remote_command = "cd #{config.provisioning_path} && #{Helpers::stringify_ansible_playbook_command(@environment_variables, command)}"
+
+          execute_ansible_command_on_guest "playbook", remote_command
+        end
+
+        def execute_ansible_command_on_guest(name, command)
+          ui_running_ansible_command name, command
+
+          result = execute_on_guest(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")
+
+          temp_inventory = Tempfile.new("vagrant_ansible_local_inventory_#{@machine.name}")
+          temp_inventory.write(inventory_content)
+          temp_inventory.close
+
+          create_and_chown_remote_folder(inventory_basedir)
+          @machine.communicate.tap do |comm|
+            comm.sudo("rm -f #{inventory_path}", error_check: false)
+            comm.upload(temp_inventory.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
+
+      end
+    end
+  end
+end