vagrant-ansible_auto 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40fd0b7cb409371ac24b6e878076c7aa5020db70
+  data.tar.gz: 1ff945bf3f9f43324c504cb2a987c49f1d7eccce
+SHA512:
+  metadata.gz: 0a4e2871cff450346b750f166c39d4730b97e41ba8c39476582cde9ec307d6a42035b99739590fe7dc9baadd181efaf5776d67152ba424b57a877ce87e6530e7
+  data.tar.gz: 5d13474ca2aed002005b23f2c028fe932470293914551e9ddf32b3de0f5fbdd9e9f9ad5a576c2cc4c0ddd8a2502cafb79c22c77639488da910d3247936b98439

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+group :development do
+  gem 'pry'
+  gem 'vagrant', github: 'mitchellh/vagrant'
+end
+
+group :plugins do
+  gemspec
+end

data/LICENSE.md

@@ -0,0 +1,23 @@
+Copyright (c) 2014-2015 Ignacio Galindo
+Copyright (c) 2016-2017 Matt Schreiber
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# Vagrant::AnsibleAuto
+
+This Vagrant plugin provides the `ansible_auto` provisioner that automatically
+sets up the provisioned guest as an Ansible control machine for the nodes
+defined in your Vagrantfile.  It also provides the `vagrant ansible` subcommand
+that generates an inventory file for use on your Vagrant host machine.
+
+## Installation
+
+Install with:
+
+```shell
+$ vagrant plugin install vagrant-ansible_auto
+```
+
+## Usage
+
+### Inventory Generation
+
+Say you have a Vagrantfile with the following contents:
+
+```ruby
+Vagrant.configure(2) do |config|
+  config.vm.box = 'hashicorp/precise64'
+
+  (1..2).each do |i|
+    name = "ansible-test-worker-#{i}"
+    config.vm.define name do |target|
+    end
+  end
+
+  config.vm.define 'ansible-test-control' do |machine|
+    machine.vm.provision :ansible_auto do |ansible|
+      ansible.limit = '*'
+      ansible.playbook = 'playbooks/test.yml'
+    end
+  end
+
+  config.ansible.groups = {
+    'control'           => %w(ansible-test-control),
+    'worker'            => %w(ansible-test-worker-1 ansible-test-worker-2),
+    'cluster:children'  => %w(control worker),
+  }
+end
+```
+
+Running `vagrant ansible inventory` will print this Ansible inventory:
+
+```ini
+ansible-test-worker-1 ansible_ssh_user=vagrant ansible_ssh_host=127.0.0.1 ansible_ssh_port=2222 ansible_ssh_private_key_file=/home/matt/git/vagrant-ansible_inventory/.vagrant/machines/ansible-test-worker-1/virtualbox/private_key
+ansible-test-worker-2 ansible_ssh_user=vagrant ansible_ssh_host=127.0.0.1 ansible_ssh_port=2200 ansible_ssh_private_key_file=/home/matt/git/vagrant-ansible_inventory/.vagrant/machines/ansible-test-worker-2/virtualbox/private_key
+ansible-test-control ansible_ssh_user=vagrant ansible_ssh_host=127.0.0.1 ansible_ssh_port=2201 ansible_ssh_private_key_file=/home/matt/git/vagrant-ansible_inventory/.vagrant/machines/ansible-test-control/virtualbox/private_key
+[control]
+ansible-test-control
+[worker]
+ansible-test-worker-1
+ansible-test-worker-2
+[cluster:children]
+control
+worker
+```
+
+### Provisioning
+
+The `ansible_auto` provisioner is an augmented version of the
+[`ansible_local` provisioner included with Vagrant](https://www.vagrantup.com/docs/provisioning/ansible_local.html).
+It accepts all options valid for that provisioner, and adds the following
+options:
+
+```ruby
+Vagrant.configure(2) do |config|
+  config.define 'ansible-control' do |machine|
+    machine.provision :ansible_auto do |ansible|
+      # Will show up in inventory as
+      #   [control]
+      #   ansible-control
+      ansible.groups = {
+        'control'   => %(ansible-control)
+      }
+
+      # Will show up in inventory as
+      #  [dev:children]
+      #  control
+      ansible.children = {
+        'dev'   => %w(control)
+      }
+
+      # Will show up in inventory as
+      #   [dev:vars]
+      #   ansible_port = 2222
+      ansible.vars = {
+        'dev' => {
+          'ansible_port' => 2222
+        }
+      }
+
+      # Enable or disable `StrictHostKeyChecking` SSH option.
+      # Disabled by default.
+      ansible.strict_host_key_checking = false
+
+      # The number of times to attempt to connect to a managed host from the
+      # Ansible control machine.
+      ansible.host_connect_tries = 10
+
+      # The number of seconds to delay between connection attempts.
+      ansible.host_connect_sleep = 5
+    end
+  end
+end
+```
+
+Each guest provisioned with `ansible_auto` will be set up as an Ansible
+control machine with the ability to connect to other guests defined in the
+`Vagrantfile`.  This is facilitated by uploading the private keys of each guest
+to a temporary path on the control machine and assigning this path as the
+hostvar `ansible_ssh_private_key_file` to the relevant host in the generated
+inventory.
+
+## Contributing
+
+1. Fork it ( https://github.com/joiggama/vagrant-ansible_auto/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+[The MIT licence](LICENSE.md)

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.ruby_opts = "-w"
+end
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+task default: [:rubocop, :spec]

data/TODO.md

@@ -0,0 +1,8 @@
+# TODO
+
+- See if it possible to Vagrant::Util::IsPortOpen instead of Bash/nc/etc for
+  checking whether a port is open.  *Has to run on the guest*, so probably not
+  possible.
+- Util::ScopedHashOverride for the key conversions done in Host?
+- Util::HashWithIndifferentAccess for Host?
+- default vaues for arguments to attr_writer methods in `Inventory`

data/Vagrantfile

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+Vagrant.configure(2) do |config|
+  define_vm = lambda do |name, box, memory|
+    config.vm.define name do |instance|
+      instance.vm.box      = box
+      instance.vm.hostname = name
+      instance.vm.network 'private_network', type: 'dhcp'
+      instance.vm.provider :virtualbox do |i|
+        i.name   = name
+        i.memory = memory
+      end
+    end
+  end
+
+  define_vm.call 'master',  'ubuntu/trusty32', 256
+  define_vm.call 'slave-1', 'ubuntu/trusty32', 256
+  define_vm.call 'slave-2', 'ubuntu/trusty32', 256
+
+  config.ansible.groups = {
+    'cluster:children' => %w(master slaves),
+    'slaves'           => ['slave-1', 'slave-2'],
+  }
+end

data/Vagrantfile2

@@ -0,0 +1,4 @@
+Vagrant.configure(2) do |config|
+  config.vm.box = 'ubuntu/trusty64'
+  config.vm.network :private_network, type: :dhcp
+end

data/Vagrantfile3

@@ -0,0 +1,8 @@
+Vagrant.configure(2) do |config|
+  config.vm.box = 'trusty64'
+  config.vm.network :private_network, type: :dhcp
+
+  config.ansible.groups = {
+    'ubuntu' => ['default']
+  }
+end

data/Vagrantfile4

@@ -0,0 +1,31 @@
+Vagrant.configure(2) do |config|
+  config.vm.box = 'hashicorp/precise64'
+
+  (1..2).each do |i|
+    name = "ansible-test-worker-#{i}"
+    config.vm.define name do |target|
+    end
+  end
+
+  config.vm.define 'ansible-test-control' do |machine|
+    machine.vm.provision :ansible_auto do |ansible|
+      ansible.limit = '*'
+      ansible.playbook = 'playbooks/test.yml'
+    end
+  end
+
+  config.ansible.groups = {
+    'control'           => %w(ansible-test-control),
+    'worker'            => %w(ansible-test-worker-1 ansible-test-worker-2),
+    'cluster:children'  => %w(control worker),
+  }
+
+  config.ansible.vars = {
+    'control'   => {
+        'role'  => 'ansible-control',
+    },
+    'worker'    => {
+        'role'  => 'ansible-worker',
+    }
+  }
+end

data/lib/vagrant/ansible_auto/cap/guest/posix/bash_installed.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module VagrantPlugins
+  module AnsibleAuto
+    module Cap
+      module Guest
+        module POSIX
+          class BashInstalled
+            class << self
+              def bash_installed?(machine, version = nil)
+                machine.communicate.execute(%q(command bash -c 'printf -- "%s\t%s" "$BASH" "$BASH_VERSION"'), error_check: false) do |type, data|
+                  data.chomp!
+
+                  # Not sure why, but we always get an empty first line...
+                  next if data.empty?
+
+                  if type == :stdout
+                    bash_path, bash_version = *data.split("\t")
+                    return (!bash_path.empty? and (version.nil? or version == bash_version))
+                  end
+                end
+
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/cap/guest/posix/check_open_port.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'uri'
+
+module VagrantPlugins
+  module AnsibleAuto
+    module Cap
+      module Guest
+        module POSIX
+          class CheckOpenPort
+            class << self
+              def check_open_port(machine, host, port, proto = 'tcp')
+                return nil unless machine.communicate.test('bash')
+
+                # Check that we got a valid URI by constructing a URI object
+                # and watching for exceptions raised upon component assignment.
+                begin
+                  uri = URI('').tap do |u|
+                    u.host = host
+                    u.port = port
+                  end
+                rescue URI::InvalidComponentError
+                  return nil
+                end
+
+                target = File.join('/dev/', proto, uri.host, uri.port.to_s).shellescape
+                machine.communicate.test("read < #{target}", shell: '/bin/bash')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/cap/guest/posix/executable_installed.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'shellwords'
+
+module VagrantPlugins
+  module AnsibleAuto
+    module Cap
+      module Guest
+        module POSIX
+          class ExecutableInstalled
+            class << self
+              def executable_installed?(machine, executable)
+                machine.communicate.test(%[test -x "$(command -v #{executable.shellescape})"], error_check: false)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/cap/guest/posix/gateway_addresses.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'set'
+
+module VagrantPlugins
+  module AnsibleAuto
+    module Cap
+      module Guest
+        module POSIX
+          class GatewayAddresses
+            class << self
+              def gateway_addresses(machine)
+                with_default_gateway_addresses(machine).to_a.compact
+              end
+
+            private
+
+              def with_default_gateway_addresses(machine)
+                return enum_for(__method__, machine) unless block_given?
+
+                seen_addresses = Set.new
+                yield_unseen_address = lambda do |a|
+                  yield a unless seen_addresses.include? a
+                  seen_addresses << a
+                end
+
+                machine.communicate.execute('ip route show', error_check: false) do |type, data|
+                  if type == :stdout
+                    data.lines.each do |line|
+                      if line.start_with?('default')
+                        yield_unseen_address.call(line.split[2])
+                      end
+                    end
+                  end
+                end
+
+                machine.communicate.execute('route -n', error_check: false) do |type, data|
+                  if type == :stdout
+                    data.lines.each do |line|
+                      if line.start_with?('0.0.0.0')
+                        yield_unseen_address.call(line.split[1])
+                      end
+                    end
+                  end
+                end
+
+                machine.communicate.execute('netstat -rn', error_check: false) do |type, data|
+                  if type == :stdout
+                    data.lines.each do |line|
+                      if line.start_with?('0.0.0.0')
+                        yield_unseen_address.call(line.split[1])
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/cap/guest/posix/private_key.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module AnsibleAuto
+    module Cap
+      module Guest
+        module POSIX
+          class PrivateKey
+            class << self
+              def generate_private_key(machine, path, type = 'rsa', bits = '2048')
+                return unless machine.guest.capability?(:executable_installed?) \
+                  && machine.guest.capability(:executable_installed?, 'ssh-keygen')
+
+                machine.communicate.execute("ssh-keygen -t #{type} -b #{bits} -C 'Vagrant-generated keypair' -f #{path}")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/cap/guest/posix/public_key.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module AnsibleAuto
+    module Cap
+      module Guest
+        module POSIX
+          class PrivateKey
+            class << self
+              def fetch_public_key(machine, path)
+                return unless machine.guest.capability?(:executable_installed?) \
+                  && machine.guest.capability(:executable_installed?, 'ssh-keygen')
+
+                # TODO: handle bad status
+                public_key = ''
+                _status = machine.communicate.execute("ssh-keygen -f #{path} -y") do |data_type, data|
+                  public_key += data if data_type == :stdout
+                end
+
+                public_key
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/cap/guest/posix/ssh_server_address.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require 'set'
+
+module VagrantPlugins
+  module AnsibleAuto
+    module Cap
+      module Guest
+        module POSIX
+          class SSHServerAddress
+            class << self
+              def ssh_server_address(machine, target_machine = nil)
+                with_open_ports(machine, target_machine).first
+              end
+
+            private
+
+              def ssh_server_addresses(machine, target_machine = nil)
+                with_open_ports(machine, target_machine).to_a
+              end
+
+              def with_open_ports(machine, target_machine = nil)
+                return enum_for(__method__, machine, target_machine) unless block_given?
+
+                return unless machine.guest.capability?(:check_open_port)
+
+                target_machine ||= machine
+                ssh_info = target_machine.ssh_info
+                default_port = ssh_info.nil? ? 22 : ssh_info[:port]
+
+                with_candidate_addresses(target_machine) do |host, port|
+                  port ||= default_port
+
+                  if machine.guest.capability(:check_open_port, host, port)
+                    yield host, port
+                  end
+                end
+              end
+
+              network_type_precedence_map = Hash[[:forwarded_port, :public_network, :private_network].each_with_index.map { |type, i| [type, i] }]
+              define_method(:network_type_precedence) do |type|
+                network_type_precedence_map[type]
+              end
+
+              def with_candidate_addresses(machine)
+                return enum_for(__method__, machine) unless block_given?
+
+                seen_candidates = Set.new
+                yield_unseen_candidate = lambda do |host_and_port|
+                  yield(*host_and_port) unless seen_candidates.include?(host_and_port)
+                  seen_candidates << host_and_port
+                end
+
+                if machine.provider.capability?(:public_address)
+                  yield_unseen_candidate.call([machine.provider.capability(:public_address)])
+                end
+
+                unless machine.ssh_info.nil?
+                  yield_unseen_candidate.call([machine.ssh_info[:host]])
+                end
+
+                has_routable_ip = false
+                machine.config.vm.networks.sort_by { |(type, _)| network_type_precedence(type) }.each do |type, info|
+                  case type
+                  when :private_network, :public_network
+                      has_routable_ip = true
+
+                      yield_unseen_candidate.call([info[:ip]]) if info.key?(:ip)
+                  when :forwarded_port
+                      # TODO: the `:id' restriction might not be right.
+                      if info[:protocol] == 'tcp' and info[:id] == 'ssh'
+                        yield_unseen_candidate.call([info[:host_ip], info[:host]])
+                      end
+                  end
+                end
+
+                return if has_routable_ip or !machine.guest.capability?(:gateway_addresses)
+
+                machine.guest.capability(:gateway_addresses).each do |gateway_address|
+                  yield_unseen_candidate.call(gateway_address)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/command/inventory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require 'optparse'
+
+module VagrantPlugins
+  module AnsibleAuto
+    module Command
+      class Inventory < Vagrant.plugin(2, :command)
+        def self.synopsis
+          'dynamic ansible inventory'
+        end
+
+        def execute
+          opts = OptionParser.new do |op|
+            op.banner = 'Usage: vagrant ansible inventory [<options>]'
+            op.separator ''
+            op.separator 'Available options:'
+
+            op.on('-l', '--list', 'List all hosts as json') do |_target|
+              @env.ui.info inventory.to_json, prefix: false
+              return 0
+            end
+
+            op.on('-h', '--help', 'Show this message') do
+              @env.ui.info opts.help, prefix: false
+              return 0
+            end
+          end
+
+          @argv = parse_options(opts)
+
+          @env.ui.info inventory.to_ini, prefix: false
+
+          0
+        end
+
+      private
+
+        def inventory
+          @inventory = with_target_vms(@argv) {}.each_with_object(AnsibleAuto::Inventory.new) do |machine, inventory|
+            unless machine.state.id == :running
+              @env.ui.warn "machine #{machine.name} is not running; falling back to default hostvar values"
+            end
+            inventory.merge!(machine.config.ansible.inventory)
+            inventory.add_host(machine)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ansible_auto/command/root.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require 'optparse'
+
+module VagrantPlugins
+  module AnsibleAuto
+    module Command
+      class Root < Vagrant.plugin(2, :command)
+        def self.synopsis
+          'build ansible inventory'
+        end
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+
+          @subcommands.register(:inventory) do
+            require_relative 'inventory'
+            Inventory
+          end
+        end
+
+        def execute
+          if @main_args.include?('-h') || @main_args.include?('--help')
+            return help
+          end
+
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          command_class.new(@sub_args, @env).execute
+        end
+
+        def help
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant ansible <subcommand> [<options>]'
+            o.separator ''
+            o.separator 'Available subcommands:'
+
+            keys = []
+            @subcommands.each { |key, _value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              o.separator "     #{key}"
+            end
+
+            o.separator ""
+            o.separator "For help on any individual subcommand run `vagrant ansible <subcommand> -h`"
+          end
+
+          @env.ui.info(opts.help, prefix: false)
+        end
+      end
+    end
+  end
+end