vagrant-ansible_auto 0.1.5 → 0.2.1

data/lib/vagrant/ansible_auto/provisioner.rb

@@ -1,83 +1,63 @@
 # frozen_string_literal: true
+
 require 'vagrant'
 require Vagrant.source_root + 'plugins/provisioners/ansible/provisioner/guest'
 require 'vagrant/util/keypair'
 
-require 'vagrant/ansible_auto/util'
+require 'vagrant/ansible_auto/util/keys'
 
+require 'i18n'
 require 'log4r'
-require 'shellwords'
 
 module VagrantPlugins
   module AnsibleAuto
+    # Class backing the +ansible_auto+ provisioner
     class Provisioner < VagrantPlugins::Ansible::Provisioner::Guest
       include Vagrant::Util::Retryable
-      include VagrantPlugins::AnsibleAuto::Util
+      include Util::Keys
 
       def initialize(machine, config)
         super
         @logger = Log4r::Logger.new('vagrant::provisioners::ansible_auto')
       end
 
+      # Configure the provisioner by storing the root Ansible configuration
+      # object for use as the set of base options for a particular machine
+      # @api private
+      # @return [void]
       def configure(root_config)
         super
         @__ansible_config = root_config.ansible
       end
 
+      # Provision a {Vagrant::Machine} with the +ansible_auto+ provisioner
+      # @api private
+      # @return [void]
       def provision
         @config = @__ansible_config.merge(config)
 
-        remote_priv_key_path, _remote_pub_key_path, openssh = configure_keypair!
-
-        # TODO: figure out how to access ansible_auto configuration done
-        # on the `other' machine.
-        # @config = other.config.ansible.merge(merged_config)
-        if machine.guest.capability?(:ssh_server_address)
+        return super unless machine.guest.capability?(:ssh_server_address)
 
-          with_active_machines do |other, name, provider|
-            # We're dealing with the machine doing the provisining
+        with_active_machines do |other, name, provider|
+          if other.nil?
+            @logger.warn I18n.t('vagrant.ansible_auto.provisioner.machine_not_configured', machine_name: name)
+          else
             if name == machine.name
-              other_hostvars = { connection: 'local' }
-            elsif other.nil?
-              machine.ui.warn "Machine #{name} is not configured for this environment; omitting it from the inventory"
+              other_hostvars = { ansible_connection: 'local' }
             else
-              # The machines we are trying to manage might not yet be ready to
-              # connect -- retry a configurable number of times/durations until
-              # we can connect; otherwise raise an exception.
-              private_key_paths = []
-              retryable(on: Vagrant::Errors::SSHNotReady, tries: @config.host_connect_tries, sleep: @config.host_connect_sleep) do
-                raise Vagrant::Errors::SSHNotReady unless other.communicate.ready? and !other.ssh_info.nil?
-
-                private_key_paths = other.ssh_info.fetch(:private_key_path, [])
-                raise Vagrant::Errors::SSHNotReady if private_key_paths.empty?
-
-                if other.config.ssh.insert_key
-                  raise Vagrant::Errors::SSHNotReady unless private_key_paths.any? { |k| !insecure_key?(k) }
-                end
-              end
-
-              ssh_host, ssh_port = machine.guest.capability(:ssh_server_address, other)
-              other_hostvars = { ssh_host: ssh_host, ssh_port: ssh_port }
+              # Merge the other machine's configuration, with this machine's
+              # configuration taking precedence.
+              @config = other.config.ansible.merge(@config)
 
-              if private_key_paths.empty?
-                machine.ui.warn "No private keys available for machine #{name}; provisioner will likely fail"
-              end
-
-              source_priv_key_path = fetch_private_key(other)
+              wait_for_ssh_ready!(other, @config.host_connect_tries, @config.host_connect_sleep)
 
-              if source_priv_key_path.nil?
-                machine.ui.warn "Private key for #{name} not available for upload; provisioner will likely fail"
-              else
-                machine.ui.info "Adding #{name} to Ansible inventory"
+              ssh_host, ssh_port = machine.guest.capability(:ssh_server_address, other)
+              other_hostvars = { ansible_ssh_host: ssh_host, ansible_ssh_port: ssh_port }
 
-                if other.guest.capability?(:insert_public_key)
-                  other.guest.capability(:insert_public_key, openssh)
-                else
-                  remote_priv_key_path = File.join(@config.tmp_path, 'ssh', name.to_s, provider.to_s, File.basename(source_priv_key_path))
-                  create_and_chown_and_chmod_remote_file(source_priv_key_path, remote_priv_key_path)
-                end
+              machine.ui.info I18n.t('vagrant.ansible_auto.provisioner.inventory_addition', machine_name: name)
 
-                other_hostvars[:ssh_private_key_file] = remote_priv_key_path
+              unless (other_ssh_private_key_file = configure_ssh_access!(other, name, provider)).nil?
+                other_hostvars[:ansible_ssh_private_key_file] = other_ssh_private_key_file
               end
             end
 
@@ -85,75 +65,128 @@ module VagrantPlugins
           end
         end
 
+        @config.inventory.validate!
+
         super
       end
 
     private
 
-      def configure_keypair!
-        # FIXME
-        remote_priv_key_path = "~#{machine.ssh_info[:username]}/.ssh/id_rsa"
-        remote_pub_key_path = "#{remote_priv_key_path}.pub"
+      def control_machine_ssh_key_dir
+        Pathname.new(@config.tmp_path).join('ssh')
+      end
+
+      def control_machine_private_key_path
+        @control_machine_private_key_path ||= control_machine_ssh_key_dir.join('vagrant_ansible_id_rsa')
+      end
+
+      def control_machine_public_key_path
+        @control_machine_public_key_path ||= control_machine_private_key_path.sub_ext('.pub')
+      end
 
-        # Check whether user has a private key already
-        if !machine.communicate.test("test -f #{remote_priv_key_path}") or !machine.communicate.test("test -f #{remote_pub_key_path}")
+      def control_machine_public_key
+        @control_machine_public_key ||= configure_keypair!
+      end
+
+      def configure_ssh_access!(other, name, provider)
+        # Insert the control machine's public key on the target machines
+        if config.insert_control_machine_public_key
+          insert_control_machine_public_key!(other, name)
+        elsif config.upload_inventory_host_private_keys
+          upload_inventory_host_private_key!(other, name, provider)
+        else
+          machine.ui.warn I18n.t('vagrant.ansible_auto.provisioner.cannot_configure_keys', machine_name: name)
+        end
+      end
+
+      def insert_control_machine_public_key!(other, name)
+        # Don't bother inserting the key if it is already authorized
+        if other.guest.capability?(:authorized_key?) && other.guest.capability(:authorized_key?, control_machine_public_key)
+          @logger.info I18n.t('vagrant.ansible_auto.provisioner.public_key_authorized', machine_name: name)
+        elsif other.guest.capability?(:insert_public_key)
+          @logger.info I18n.t('vagrant.ansible_auto.provisioner.inserting_public_key', machine_name: name)
+          other.guest.capability(:insert_public_key, control_machine_public_key)
+        else
+          @logger.warn I18n.t('vagrant.ansible_auto.provisioner.cannot_insert_public_key', machine_name: name)
+          return
+        end
+
+        control_machine_private_key_path
+      end
+
+      def upload_inventory_host_private_key!(other, name, provider)
+        source_priv_key_path = fetch_private_key(other)
+
+        if source_priv_key_path.nil?
+          @logger.warn I18n.t('vagrant.ansible_auto.provisioner.private_key_missing', machine_name: name)
+          return
+        end
+
+        @logger.info I18n.t('vagrant.ansible_auto.provisioner.uploading_private_key', machine_name: name)
+
+        other_priv_key_path = control_machine_ssh_key_dir.join(name.to_s, provider.to_s, File.basename(source_priv_key_path))
+        create_and_chown_and_chmod_remote_file(source_priv_key_path, other_priv_key_path)
+        other_priv_key_path
+      end
+
+      def configure_keypair!
+        # Check whether user already has a private key
+        if !machine.communicate.test("test -r #{control_machine_private_key_path} && test -r #{control_machine_public_key_path}")
           _pub, priv, openssh = Vagrant::Util::Keypair.create
-          write_and_chown_and_chmod_remote_file(priv, remote_priv_key_path)
-          write_and_chown_and_chmod_remote_file(openssh, remote_pub_key_path)
+          write_and_chown_and_chmod_remote_file(priv, control_machine_private_key_path)
+          write_and_chown_and_chmod_remote_file(openssh, control_machine_public_key_path)
         elsif machine.guest.capability?(:fetch_public_key)
-          openssh = machine.guest.capability(:fetch_public_key, remote_priv_key_path)
+          openssh = machine.guest.capability(:fetch_public_key, control_machine_private_key_path)
         end
 
-        [remote_priv_key_path, remote_pub_key_path, openssh]
+        openssh
       end
 
-      def handle_remote_file(to, _owner = machine.ssh_info[:username], mode = 0o600)
+      def handle_remote_file(to, opts = {})
+        owner = opts.fetch(:owner) { machine.ssh_info[:username] }
+        mode = opts.fetch(:mode) { 0o600 }
         machine.communicate.tap do |comm|
+          # NOTE create_and_chown_remote_folder is defined in the parent class
           create_and_chown_remote_folder(File.dirname(to))
 
           yield comm, to
 
-          comm.sudo("chown -h #{machine.ssh_info[:username]} #{to}")
+          comm.sudo("chown -h #{owner} #{to}")
           comm.sudo("chmod #{format('0%o', mode)} #{to}")
         end
       end
 
-      def create_and_chown_and_chmod_remote_file(from, to, mode = 0o600)
-        handle_remote_file(to, mode) do |comm, target|
+      def create_and_chown_and_chmod_remote_file(from, to, opts = {})
+        handle_remote_file(to, opts) do |comm, target|
           comm.upload(from, target)
         end
       end
 
-      def write_and_chown_and_chmod_remote_file(contents, to, mode = 0o600)
-        handle_remote_file(to, mode) do |comm, _target|
+      def write_and_chown_and_chmod_remote_file(contents, to, opts = {})
+        handle_remote_file(to, opts) do |comm, target|
           contents = contents.strip << "\n"
 
-          to_parent = File.dirname(to)
-
           remote_path = "/tmp/vagrant-temp-asset-#{Time.now.to_i}"
-          Tempfile.open("vagrant-temp-asset") do |f|
+          Tempfile.open('vagrant-temp-asset') do |f|
             f.binmode
             f.write(contents)
             f.fsync
             f.close
-            machine.ui.info("uploading #{f.path} to #{remote_path}")
+            machine.ui.detail I18n.t('vagrant.ansible_auto.provisioner.uploading_file', local_path: f.path, remote_path: remote_path)
             comm.upload(f.path, remote_path)
           end
 
-          # FIXME: configure perms on parent dir
-          comm.execute <<-EOH.gsub(/^ */, "")
-            mkdir #{to_parent}
-            mv #{remote_path} #{to}
-          EOH
+          # Parent directory of target will already exist
+          comm.execute("mv #{remote_path} #{target}")
         end
       end
 
       def generate_inventory_machines
-        if config.strict_host_key_checking
-          machine_format = '%s'
-        else
-          machine_format = "%s ansible_ssh_extra_args='-o UserKnownHostsFile=/dev/null -o IdentitiesOnly=yes -o StrictHostKeyChecking=no'"
-        end
+        machine_format = if config.strict_host_key_checking
+                           '%s'
+                         else
+                           "%s ansible_ssh_extra_args='-o UserKnownHostsFile=/dev/null -o IdentitiesOnly=yes -o StrictHostKeyChecking=no'"
+                         end
 
         config.inventory.with_ini_lines_hosts.map do |host_spec|
           machine_format % host_spec
@@ -171,11 +204,20 @@ module VagrantPlugins
           begin
             yield machine.env.machine(name, provider), name, provider
           rescue Vagrant::Errors::MachineNotFound, CommunicatorWinRM::Errors::WinRMNotReady => e
-            machine.ui.warn "unable to find machine #{name} (#{e.message})"
-            return nil, name, provider
+            @logger.warn I18n.t('vagrant.ansible_auto.provisioner.cannot_find_machine', machine_name: name, error_message: e.message)
+            yield nil, name, provider
           end
         end
       end
+
+      # The machines we are trying to manage might not yet be ready to
+      # connect -- retry a configurable number of times/durations until
+      # we can connect; otherwise raise an exception.
+      def wait_for_ssh_ready!(other, tries, sleep)
+        retryable(on: Vagrant::Errors::SSHNotReady, tries: tries, sleep: sleep) do
+          raise Vagrant::Errors::SSHNotReady unless other.communicate.ready? && !other.ssh_info.nil?
+        end
+      end
     end
   end
 end

data/lib/vagrant/ansible_auto/util/config.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'vagrant/util/deep_merge'
+
+module VagrantPlugins
+  module AnsibleAuto
+    # Helper methods for common operations
+    module Util
+      # Helper module for operations related to configuration settings
+      module Config
+        # @return [Boolean] +false+ when an object is +nil+, undefined, or the
+        #   special +UNSET_VALUE+ object, +true+ otherwise
+        def unset?(o)
+          o.nil? || !defined?(o) || (self.class.const_defined?(:UNSET_VALUE) && o == self.class.const_get(:UNSET_VALUE))
+        end
+
+        def bool?(o)
+          (o == true) || (o == false)
+        end
+
+        def num?(o)
+          float?(o) || int?(o)
+        end
+
+        def int?(o)
+          coerced_int = int!(o)
+          return false if coerced_int.nil?
+          float!(coerced_int) == float!(o)
+        end
+
+        def int!(o)
+          Integer(o)
+        rescue ArgumentError, TypeError
+          nil
+        end
+
+        def float?(o)
+          !float!(o).nil?
+        end
+
+        def float!(o)
+          Float(o)
+        rescue ArgumentError, TypeError
+          nil
+        end
+
+        # Deep merge two objects, ensuring first that neither object is
+        # {#unset?}
+        def conditional_merge(a, b, &block)
+          if unset? b
+            a
+          elsif unset? a
+            b
+          else
+            Vagrant::Util::DeepMerge.deep_merge(a, b, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/util/hash_with_indifferent_access.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'vagrant/util/hash_with_indifferent_access'
+
+module VagrantPlugins
+  module AnsibleAuto
+    # Helper methods for common operations
+    module Util
+      # Helper methods for operations related to SSH keys
+      class HashWithIndifferentAccess < Vagrant::Util::HashWithIndifferentAccess
+        # Combine two hashes into a new hash
+        # @overload merge(other)
+        #   @param (see #merge!)
+        #   @return (see #merge!)
+        # @overload merge(other, &block)
+        #   @param (see #merge!)
+        #   @return (see #merge!)
+        #   @yieldparam (see #merge!)
+        #   @yieldparam (see #merge!)
+        #   @yieldparam (see #merge!)
+        def merge(other, &block)
+          dup.merge!(other, &block)
+        end
+
+        # In-place merge of two {HashWithIndifferentAccess} object.  Provide
+        # the optional +&block+ argument if you want to control what happens a
+        # key exists in both hashes; by default, the value from +other+
+        # overwrites the current value for that key.
+        # @overload merge!(other)
+        #   @param [Hash] the hash to merge into the current hash
+        #   @return [HashWithIndifferentAccess] the merged hash
+        # @overload merge!(other, &block)
+        #   @param [Hash] the hash to merge into the current hash
+        #   @return [HashWithIndifferentAccess] the merged hash
+        #   @yieldparam [String] key
+        #   @yieldparam [HashWithIndifferentAccess] current
+        #   @yieldparam [Hash] other
+        def merge!(other)
+          if block_given?
+            other.each do |key, value|
+              convert_key(key).tap do |ckey|
+                self[ckey] = if key? ckey
+                               yield(ckey, self[ckey], value)
+                             else
+                               value
+                             end
+              end
+            end
+          else
+            super(other)
+          end
+
+          self
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/util/keys.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module AnsibleAuto
+    # Helper methods for common operations
+    module Util
+      # Helper methods for operations related to SSH keys
+      module Keys
+        # @return [Pathname] the path to the Vagrant insecure private key
+        def insecure_key_path
+          Vagrant.source_root.join('keys/vagrant')
+        end
+
+        # @return [String] the contents of the Vagrant insecure private key
+        def insecure_key_contents
+          @__insecure_key_contents ||= insecure_key_path.read.chomp
+        end
+
+        # @param [String] path path to a file
+        # @return [Boolean] whether the file is the Vagrant insecure private key
+        # @note Adapted from
+        #   {VagrantPlugins::CommunicatorSSH::Communicator#insecure_key?}
+        def insecure_key?(path)
+          return false if path.nil? || !File.file?(path)
+          File.read(path).chomp == insecure_key_contents
+        end
+
+        # @param [Vagrant::Machine] machine a guest machine
+        # @return [Array<String>] the first of the machine's keys that aren't the
+        #   Vagrant private key as determined by {#insecure_key?}
+        def fetch_private_key(machine)
+          fetch_private_keys(machine).first
+        end
+
+        # @param (see #fetch_private_key)
+        # @return [Array<String>] a list of the paths to all of the machine's
+        #   keys that aren't the Vagrant private key as determined by
+        #   {#insecure_key?}
+        def fetch_private_keys(machine)
+          if machine.config.ssh.insert_key && !machine.ssh_info.nil?
+            machine.ssh_info.fetch(:private_key_path, []).find_all { |k| !insecure_key?(k) }
+          else
+            [machine.env.default_private_key_path]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/util/shell_quote.rb

@@ -0,0 +1,24 @@
+module VagrantPlugins
+  module AnsibleAuto
+    # Helper methods for common operations
+    module Util
+      # Helper methods for operations related to SSH keys
+      module ShellQuote
+        # In-place equivalent of {#shellescape}
+        # @param text [#to_s] the text to escape
+        # @return [String] the text, with all occurrences of +'+ replaced by
+        #   +'"'"'+
+        def shellescape!(text)
+          text.to_s.gsub!(%('), %('"'"'))
+        end
+
+        # Escape a string for use as a shell parameter
+        # @param (see #shellescape!)
+        # @return (see #shellescape!)
+        def shellescape(text)
+          text.to_s.gsub(%('), %('"'"'))
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 module VagrantPlugins
   module AnsibleAuto
-    VERSION = '0.1.5'
+    VERSION = '0.2.1'.freeze
   end
 end

data/lib/vagrant/ansible_auto.rb

@@ -1,5 +1,20 @@
 # frozen_string_literal: true
+
+require 'pathname'
+
 require 'vagrant'
 
 require 'vagrant/ansible_auto/plugin'
 require 'vagrant/ansible_auto/version'
+
+module VagrantPlugins
+  # Ansible command and provisioner plugin with automatic inventory generation
+  module AnsibleAuto
+    class << self
+      # @return [Pathname] path to the gem source root directory
+      def source_root
+        Pathname.new('../../..').expand_path(__FILE__)
+      end
+    end
+  end
+end

data/locales/en.yml

@@ -0,0 +1,34 @@
+en:
+  vagrant:
+    ansible_auto:
+      provisioner:
+        machine_not_configured: 'Machine %{machine_name} is not configured for this environment; omitting it from the inventory'
+        private_key_missing: 'Private key for %{machine_name} not available for upload; provisioner will likely fail'
+        inventory_addition: 'Adding %{machine_name} to Ansible inventory'
+        public_key_authorized: 'Control machine public key already authorized on %{machine_name}'
+        inserting_public_key: 'Inserting control machine public key on %{machine_name}'
+        cannot_insert_public_key: 'Cannot insert control machine public key on %{machine_name}'
+        uploading_private_key: 'Uploading private key for %{machine_name} onto control machine'
+        cannot_configure_keys: 'unable to insert public key or upload existing private key to control machine for %{machine_name}'
+        uploading_file: 'Uploading %{local_path} to %{remote_path}'
+        cannot_find_machine: 'Unable to find machine %{machine_name}: %{error_message}'
+      command:
+        root:
+          synopsis: 'build an Ansible inventory'
+          option: {}
+          diag: {}
+        skel:
+          synopsis: 'output a dynamic Ansible inventory'
+          usage: 'Usage: vagrant ansible inventory [options]'
+          option:
+            list: 'List all hosts as JSON'
+          diag:
+            not_running: 'machine %{machine} is not running; falling back to default hostvar values'
+      errors:
+        inventory:
+          missing_group: 'expected group %{group} is missing from the inventory'
+          group_missing_child: 'group %{group} defines nonextant child group %{child}'
+          invalid_host_type: "cannot add object of type %{type} as inventory host"
+          invalid_group_name: "%{group} is not a valid group name"
+        command:
+          unrecognized_command: 'unrecognized_command: %{command}'

data/spec/spec_helper.rb

@@ -1,93 +1,13 @@
 # frozen_string_literal: true
-unless RUBY_ENGINE == 'rbx' # coverage support is broken on rbx
-  require 'simplecov'
-  require 'coveralls'
-
-  formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(formatters)
-  SimpleCov.start do
-    minimum_coverage 100
-    add_group 'Sources', 'lib'
-    add_group 'Tests', 'spec'
-  end
-end
 
 require 'pathname'
 
-$LOAD_PATH.unshift((Pathname.new(__FILE__).parent.parent + 'lib').to_s)
-
-require 'vagrant/ansible_auto'
-
-# We're using an older version of rspec-expectations that doesn't have the
-# `all' matcher.
-RSpec::Matchers.define :all do |expected|
-  define_method :index_failed_objects do |actual|
-  end
-
-  def index_failed_objects(actual)
-    return enum_for(__method__, actual) unless block_given?
-
-    @failed_items = []
-
-    actual.each_with_index do |o, i|
-      @failed_items[i] = yield o
-    end
-
-    @failed_items.compact.empty?
-  end
-
-  match_for_should do |actual|
-    index_failed_objects(actual) do |item|
-      expected.failure_message_for_should unless expected.matches?(item)
-    end
-  end
-
-  match_for_should_not do |actual|
-    index_failed_objects(actual) do |item|
-      expected.failure_message_for_should_not if expected.matches?(item)
-    end
-  end
+Pathname.new(__FILE__).tap do |helper|
+  $LOAD_PATH.unshift((helper.parent.parent + 'lib').to_s)
 
-  def failure_message(actual)
-    if actual.respond_to?(:each_with_index)
-      @failed_items.each_with_index.reject { |f, _i| f.nil? }.map do |f, i|
-        "object at index #{i} failed to match: #{f}"
-      end.join("\n")
-    else
-      "provided object is not iterable"
-    end
-  end
+  require 'vagrant/ansible_auto'
 
-  failure_message_for_should      { |actual| failure_message(actual) }
-  failure_message_for_should_not  { |actual| failure_message(actual) }
+  helper.parent.join('support').find { |f| require f if f.extname == '.rb' }
 end
 
-shared_context 'machine' do
-  let(:machine) { double('machine') }
-  let(:state) { double('state') }
-  let(:ssh_info) { Hash.new }
-
-  before do
-    machine.stub(ssh_info: ssh_info, state: state)
-    machine.stub(name: 'mymachine')
-    state.stub(id: :running)
-    allow(ssh_info).to receive(:[])
-    allow(ssh_info).to receive(:fetch).with(:private_key_path, anything).and_return([])
-  end
-end
-
-shared_context 'host' do
-  require 'vagrant/ansible_auto/host'
-
-  include_context 'machine'
-
-  let(:host) { VagrantPlugins::AnsibleAuto::Host.new(machine) }
-end
-
-shared_context 'inventory' do
-  require 'vagrant/ansible_auto/host'
-
-  include_context 'machine'
-
-  let(:inventory) { VagrantPlugins::AnsibleAuto.new }
-end
+SimpleCov.start