vagrant-bolt 0.1.0

data/lib/vagrant-bolt/util/config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module VagrantBolt::Util
+  module Config
+    # Config Utility Functions
+
+    # Merge config objects overriding Nil and UNSET_VALUE
+    # Since the configs have been finalized they will have `nil` values
+    # Arrays will be merged and override parent non arrays
+    # instead of UNSET_VALUE
+    # @param local [Object] The local config object
+    # @param other [Object] The other config object
+    # @return [Object] A merged result with local overriding other
+    def self.merge_config(local, other)
+      result = local.class.new
+      [other, local].each do |obj|
+        obj.instance_variables.each do |key|
+          value = obj.instance_variable_get(key)
+          if value.is_a? Array
+            res_value = result.instance_variable_get(key)
+            value = (value + res_value).uniq if res_value.is_a? Array
+          elsif value.is_a? Hash
+            res_value = result.instance_variable_get(key)
+            value = res_value.merge(value) if res_value.is_a? Hash
+          end
+          result.instance_variable_set(key, value) if value != Vagrant::Plugin::V2::Config::UNSET_VALUE && !value.nil?
+        end
+      end
+      result.finalize!
+      result
+    end
+
+    # Convert a path to the absolute path of the inventory if it is relative
+    # @param path [String] The path to convert
+    # @param root_path [Object] The root path to append
+    # @return [String] The absolute path or nil if path is nil
+    def self.full_path(path, root_path)
+      return path if path.nil? || root_path.nil?
+
+      %r{^/.*}.match?(path) ? path : "#{root_path}/#{path}"
+    end
+  end
+end

data/lib/vagrant-bolt/util/machine.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module VagrantBolt::Util
+  module Machine
+    # Machine based Utility Functions
+
+    # Run a command locally with an execute
+    # @param command [String] The command to run
+    # @param localui [Object] The UI object to write to
+    def self.run_command(command, localui)
+      localui.info(
+        I18n.t('vagrant-bolt.provisioner.bolt.info.running_bolt',
+               command: command),
+      )
+
+      # TODO: Update this so it works on windows platforms
+      Vagrant::Util::Subprocess.execute(
+        'bash',
+        '-c',
+        command,
+        notify: [:stdout, :stderr],
+        env: { PATH: ENV["VAGRANT_OLD_ENV_PATH"] },
+      ) do |io_name, data|
+        if io_name == :stdout
+          localui.info data
+        elsif io_name == :stderr
+          localui.warn data
+        end
+      end
+    end
+
+    # Generate a list of active machines in the environment
+    # @param env [Object] The Environment
+    # @return [Array<Object>]
+    def self.nodes_in_environment(env)
+      env.active_machines.map { |vm|
+        begin
+          env.machine(*vm)
+        rescue Vagrant::Errors::MachineNotFound
+          nil
+        end
+      }.compact
+    end
+
+    # Return if the guest is windows. This only works for online machines
+    # @param machine [Object] The machine
+    # @return [Boolean]
+    def self.windows?(machine)
+      machine.config.vm.communicator == :winrm
+    end
+
+    # Return if the guest is running by checking the communicator
+    # @param machine [Object] The machine
+    # @return [Boolean]
+    def self.running?(machine)
+      # Taken from https://github.com/oscar-stack/vagrant-hosts/blob/master/lib/vagrant-hosts/provisioner/hosts.rb
+      machine.communicate.ready?
+    rescue
+      false
+    end
+
+    # Get the running machine object by the machine name
+    # @param env [Object] The enviornment to look in
+    # @param name [String, Symbol] The name of the machine in the environment
+    # @return [Object, nil] The object or nil if it is not found
+    def self.machine_by_name(env, name)
+      vm = env.active_machines.find { |m| m[0] == name.to_sym }
+      env.machine(*vm) unless vm.nil?
+    rescue Vagrant::Errors::MachineNotFound
+      nil
+    end
+  end
+end

data/lib/vagrant-bolt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module VagrantBolt
+  VERSION = '0.1.0'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+# Disable Vagrant autoloading so that other plugins defined in the Gemfile for
+# Acceptance tests are not loaded.
+ENV['VAGRANT_NO_PLUGINS'] = '1'
+ENV['VAGRANT_DISABLE_PLUGIN_INIT'] = '1'
+
+require 'vagrant'
+require 'vagrant-spec/unit'
+require 'vagrant-bolt'

data/spec/unit/config/bolt_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'vagrant-bolt/config'
+
+describe VagrantBolt::Config::Bolt do
+  let(:machine) { double("machine") }
+
+  context "validation" do
+    it "validates with the defaults" do
+      subject.finalize!
+      expect(subject.validate(machine)).to eq("Bolt" => [])
+    end
+
+    it "allows for a task" do
+      subject.command = :task
+      subject.name = "foo"
+      subject.finalize!
+      expect(subject.validate(machine)).to eq("Bolt" => [])
+    end
+
+    it "allows for a plan" do
+      subject.command = :plan
+      subject.name = "foo"
+      subject.finalize!
+      expect(subject.validate(machine)).to eq("Bolt" => [])
+    end
+
+    it "allows for a command" do
+      subject.command = :command
+      subject.name = "foo"
+      subject.finalize!
+      expect(subject.validate(machine)).to eq("Bolt" => [])
+    end
+
+    it "reports invalid options" do
+      subject.foo = "bar"
+      subject.finalize!
+      expect(subject.validate(machine)["Bolt"][0]).to eq("The following settings shouldn't exist: foo")
+    end
+
+    it "reports an error when the command is invalid" do
+      subject.command = "bar"
+      subject.name = "foo"
+      subject.finalize!
+      expect(subject.validate(machine)["Bolt"][0]).to match(%r{Type can only be})
+    end
+
+    it "reports an error when the name is not specified" do
+      subject.command = "task"
+      subject.name = nil
+      subject.finalize!
+      expect(subject.validate(machine)["Bolt"][0]).to match(%r{No name set})
+    end
+
+    it "reports an error when the command is not specified" do
+      subject.command = nil
+      subject.name = "foo"
+      subject.finalize!
+      expect(subject.validate(machine)["Bolt"][0]).to match(%r{No command set})
+    end
+
+    it "reports an error when noop is used without a task" do
+      subject.command = :plan
+      subject.name = "foo"
+      subject.noop = true
+      subject.finalize!
+      expect(subject.validate(machine)["Bolt"][0]).to match(%r{Noop is not compatible})
+    end
+  end
+
+  context "defaults" do
+    expected_values = {
+      nodes: [],
+      excludes: [],
+    }
+    expected_values.each do |val, expected|
+      it "defaults #{val} to #{expected}" do
+        subject.finalize!
+        expect(subject.send(val)).to eq(expected)
+      end
+    end
+
+    expected_nil = [
+      "name",
+      "command",
+      "params",
+      "node_list",
+      "user",
+      "password",
+      "port",
+      "sudo_password",
+      "private_key",
+      "tmpdir",
+      "run_as",
+      "args",
+      "ssl",
+      "ssl_verify",
+      "verbose",
+      "debug",
+      "host_key_check",
+      "modulepath",
+      "bolt_exe",
+      "boltdir",
+      "noop",
+    ]
+    expected_nil.each do |val|
+      it "defaults #{val} to nil" do
+        subject.finalize!
+        expect(subject.send(val)).to eq(nil)
+      end
+    end
+  end
+
+  context "inventory config" do
+    let(:default_hash) do
+      {
+        "config" => {
+          "ssh" => {
+            "password" => "foo",
+            "port" => "22",
+            "run-as" => "root",
+            "host-key-check" => false,
+          },
+          "winrm" => {
+            "password" => "foo",
+            "port" => "22",
+            "run-as" => "root",
+            "ssl" => false,
+          },
+        },
+      }
+    end
+    before(:each) do
+      subject.password = 'foo'
+      subject.run_as = 'root'
+      subject.port = '22'
+      subject.ssl = false
+      subject.host_key_check = false
+      subject.finalize!
+    end
+
+    it 'generates the basic hash structure' do
+      expect(subject.inventory_config).to include(default_hash)
+    end
+    it 'converts names with _ to -' do
+      expect(subject.inventory_config['config']['ssh']['run-as']).to eq('root')
+    end
+  end
+end

data/spec/unit/config/global_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'vagrant-bolt/config'
+
+describe VagrantBolt::Config::Global do
+  let(:machine) { double("machine") }
+
+  context "validation" do
+    it "validates with the defaults" do
+      subject.finalize!
+      expect(subject.validate(machine)).to eq("GlobalBolt" => [])
+    end
+
+    it "reports invalid options" do
+      subject.foo = "bar"
+      subject.finalize!
+      expect(subject.validate(machine)["GlobalBolt"][0]).to eq("The following settings shouldn't exist: foo")
+    end
+  end
+
+  context "defaults" do
+    expected_values = {
+      modulepath: "modules",
+      bolt_exe: "bolt",
+      boltdir: ".",
+    }
+    expected_values.each do |val, expected|
+      it "defaults #{val} to #{expected}" do
+        subject.finalize!
+        expect(subject.send(val)).to eq(expected)
+      end
+    end
+
+    expected_nil = [
+      "user",
+      "password",
+      "port",
+      "sudo_password",
+      "private_key",
+      "tmpdir",
+      "run_as",
+      "ssl",
+      "ssl_verify",
+      "host_key_check",
+      "verbose",
+      "debug",
+      "facts",
+      "vars",
+      "features",
+    ]
+    expected_nil.each do |val|
+      it "defaults #{val} to nil" do
+        subject.finalize!
+        expect(subject.send(val)).to eq(nil)
+      end
+    end
+  end
+
+  context "inventory config" do
+    let(:default_hash) do
+      {
+        "config" => {
+          "ssh" => {
+            "password" => "foo",
+            "port" => "22",
+            "run-as" => "root",
+            "host-key-check" => false,
+          },
+          "winrm" => {
+            "password" => "foo",
+            "port" => "22",
+            "run-as" => "root",
+            "ssl" => false,
+          },
+        },
+      }
+    end
+    before(:each) do
+      subject.password = 'foo'
+      subject.run_as = 'root'
+      subject.port = '22'
+      subject.ssl = false
+      subject.host_key_check = false
+      subject.finalize!
+    end
+
+    it 'generates the basic hash structure' do
+      expect(subject.inventory_config).to include(default_hash)
+    end
+    it 'converts names with _ to -' do
+      expect(subject.inventory_config['config']['ssh']['run-as']).to eq('root')
+    end
+  end
+end

data/spec/unit/provisioner/bolt_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'vagrant-bolt/config'
+require 'vagrant-bolt/provisioner'
+
+describe VagrantBolt::Provisioner do
+  include_context 'vagrant-unit'
+  subject { described_class.new(machine, config) }
+
+  let(:iso_env) do
+    env = isolated_environment
+    env.vagrantfile <<-VAGRANTFILE
+    Vagrant.configure('2') do |config|
+      config.vm.define :server
+    end
+    VAGRANTFILE
+    env.create_vagrant_env
+  end
+  let(:machine) { iso_env.machine(:server, :dummy) }
+  let(:config) { double :config }
+  let(:runner) { double :runner }
+  before(:each) do
+    allow(machine).to receive(:env).and_return(:iso_env)
+    allow(config).to receive(:name).and_return('foo')
+    allow(config).to receive(:command).and_return('task')
+  end
+
+  context 'provision' do
+    before(:each) do
+      allow(VagrantBolt::Runner).to receive(:new).with(:iso_env, machine, config).and_return(runner)
+      allow(runner).to receive(:run).with('task', 'foo').and_return('runner created')
+    end
+
+    it 'creates a new runner' do
+      expect(subject.provision).to eq('runner created')
+    end
+  end
+end

data/spec/unit/runner/runner_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'vagrant-bolt/runner'
+require 'vagrant-bolt/config'
+
+describe VagrantBolt::Runner do
+  include_context 'vagrant-unit'
+  subject { described_class.new(iso_env, machine, config) }
+
+  let(:iso_env) do
+    env = isolated_environment
+    env.vagrantfile <<-VAGRANTFILE
+    Vagrant.configure('2') do |config|
+      config.vm.define :server
+      config.vm.define :server2
+    end
+    VAGRANTFILE
+    env.create_vagrant_env
+  end
+  let(:machine) { iso_env.machine(:server, :dummy) }
+  let(:machine2) { iso_env.machine(:server2, :dummy) }
+  let(:runner) { double :runner }
+  let(:config) { VagrantBolt::Config::Bolt.new }
+  let(:subprocess_result) do
+    double("subprocess_result").tap do |result|
+      allow(result).to receive(:exit_code).and_return(0)
+      allow(result).to receive(:stderr).and_return("")
+    end
+  end
+  let(:root_path) { '/root/path' }
+  let(:local_data_path) { '/local/data/path' }
+  let(:inventory_path) { "#{local_data_path}/bolt_inventory.yaml" }
+  before(:each) do
+    allow(VagrantBolt::Util::Bolt).to receive(:update_inventory_file).with(iso_env).and_return(inventory_path)
+    allow(iso_env).to receive(:root_path).and_return(root_path)
+    allow(iso_env).to receive(:local_data_path).and_return(local_data_path)
+    allow(machine).to receive(:env).and_return(:iso_env)
+    allow(machine).to receive(:ssh_info).and_return(
+      host: 'foo',
+      port: '22',
+      username: 'user',
+      private_key_path: ['path'],
+      verify_host_key: true,
+    )
+    config.finalize!
+  end
+
+  context 'setup_overrides' do
+    before(:each) do
+      allow(VagrantBolt::Util::Machine).to receive(:nodes_in_environment).with(iso_env).and_return([machine, machine2])
+    end
+    it 'adds the command and name to the config' do
+      result = subject.send(:setup_overrides, 'task', 'foo')
+      expect(result.command).to eq('task')
+      expect(result.name).to eq('foo')
+    end
+
+    it 'uses the server name for the nodes' do
+      result = subject.send(:setup_overrides, 'task', 'foo')
+      expect(result.node_list).to eq('server')
+    end
+
+    it 'allows for using multiple nodes' do
+      config.nodes = ['server', 'server2']
+      config.finalize!
+      result = subject.send(:setup_overrides, 'task', 'foo')
+      expect(result.node_list).to eq('server,server2')
+    end
+
+    it 'adds all nodes when "all" is specified' do
+      config.nodes = 'all'
+      config.finalize!
+      result = subject.send(:setup_overrides, 'task', 'foo')
+      expect(result.node_list).to eq('server,server2')
+    end
+
+    it 'does not override specified ssh settings' do
+      config.node_list = 'ssh://test:22'
+      config.user = 'root'
+      config.finalize!
+      result = subject.send(:setup_overrides, 'task', 'foo')
+      expect(result.node_list).to eq('ssh://test:22')
+      expect(result.user).to eq('root')
+    end
+
+    it 'allows for specifying additional args' do
+      result = subject.send(:setup_overrides, 'task', 'foo', password: 'foo')
+      expect(result.password).to eq('foo')
+    end
+  end
+
+  context 'run' do
+    let(:options) { { notify: [:stdout, :stderr], env: { PATH: nil } } }
+    before(:each) do
+      allow(Vagrant::Util::Subprocess).to receive(:execute).and_return(subprocess_result)
+    end
+
+    it 'does not raise an exeption when all parameters are specified' do
+      expect { subject.run('task', 'foo') }.to_not raise_error
+    end
+
+    it 'raises an exception if the command is not specified' do
+      expect { subject.run(nil, 'foo') }.to raise_error(Vagrant::Errors::ConfigInvalid, %r{No command set})
+    end
+
+    it 'raises an exception if the name is not specified' do
+      expect { subject.run('task', nil) }.to raise_error(Vagrant::Errors::ConfigInvalid, %r{No name set})
+    end
+
+    it 'creates a shell execution' do
+      config.bolt_exe = 'bolt'
+      config.modulepath = 'modules'
+      config.boltdir = '.'
+      config.node_list = 'ssh://test:22'
+      config.finalize!
+      command = "bolt task run 'foo' --boltdir '#{root_path}/.' --modulepath '#{root_path}/modules' --inventoryfile '#{inventory_path}' --nodes 'ssh://test:22'"
+      expect(Vagrant::Util::Subprocess).to receive(:execute).with('bash', '-c', command, options).and_return(subprocess_result)
+      subject.run('task', 'foo')
+    end
+  end
+end