vagrant-bolt 0.1.0

data/lib/vagrant-bolt/config_builder/monkey_patches.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# VM level requires overriding to_proc to allow access to the node config object
+# @!visibility private
+module VagrantBolt::ConfigBuilder::MonkeyPatches
+  def to_proc
+    proc do |config|
+      super.call(config)
+      eval_bolt_root(config)
+      eval_bolt_triggers_root(config)
+    end
+  end
+
+  def eval_bolt(config)
+    # noop
+  end
+
+  def eval_bolt_root(vm_root_config)
+    # Configure the vm bolt object if the options exist
+    with_attr(:bolt) do |bolt_config|
+      f = VagrantBolt::ConfigBuilder::Config.new_from_hash(bolt_config)
+      f.call(vm_root_config)
+    end
+  end
+
+  def eval_bolt_triggers(config)
+    # noop
+  end
+
+  def eval_bolt_triggers_root(vm_root_config)
+    # Configure the vm bolt object if the options exist
+    triggers = attr(:bolt_triggers) || [] # rubocop:disable Style/Attr
+    triggers.each do |config|
+      f = VagrantBolt::ConfigBuilder::Triggers.new_from_hash(config)
+      f.call(vm_root_config)
+    end
+  end
+end
+
+class ConfigBuilder::Model::VM
+  def_model_delegator :bolt
+  def_model_delegator :bolt_triggers
+end
+
+ConfigBuilder::Model::VM.prepend(VagrantBolt::ConfigBuilder::MonkeyPatches)
+
+# Allow for the role filter to handle bolt configs and bolt_triggers
+# @!visibility private
+module VagrantBolt::ConfigBuilder::MonkeyPatches::FilterRoles
+  def merge_nodes!(left, right)
+    super.tap do |result|
+      array_keys = ['bolt_triggers']
+      array_keys.each do |key|
+        next unless right.key?(key)
+
+        result[key] ||= []
+        result[key].unshift(*right[key])
+      end
+
+      hash_keys = ['bolt']
+      hash_keys.each do |key|
+        next unless right.key?(key)
+
+        result[key] ||= {}
+        result[key] = right[key].merge(result[key])
+      end
+    end
+  end
+end
+
+ConfigBuilder::Filter::Roles.prepend(VagrantBolt::ConfigBuilder::MonkeyPatches::FilterRoles)

data/lib/vagrant-bolt/config_builder/provisioner.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'config_builder/model'
+require_relative 'monkey_patches'
+
+class VagrantBolt::ConfigBuilder::Provisioner < ConfigBuilder::Model::Provisioner::Base
+  # @!attribute [rw] args
+  # @return [String] Additional arguments for the bolt command
+  def_model_attribute :args
+
+  # @!attribute [rw] bolt_exe
+  # @return [String] The full path to the bolt command. If not passed in, the default from PATH will be used.
+  def_model_attribute :bolt_exe
+
+  # @!attribute [rw] boltdir
+  # @return [String] The bolt working directory. Defaults to `.`
+  def_model_attribute :boltdir
+
+  # @!attribute [rw] debug
+  # @return [Boolean] Shows debug logging
+  def_model_attribute :debug
+
+  # @!attribute [rw] host_key_check
+  # @return [Boolean] If the connection should check the host key on the remote host (linux)
+  def_model_attribute :host_key_check
+
+  # @!attribute [rw] modulepath
+  # @return [String] The path to the modules. Defaults to `modules`.
+  def_model_attribute :modulepath
+
+  # @!attribute [rw] name
+  # @return [String] The name of task or plan to run
+  def_model_attribute :name
+
+  # @!attribute [rw] nodes
+  # Note: The `node_list` will override this setting.
+  # @return [Array<String, Symbol>, "ALL"] The nodes to run the task or plan on.
+  # Valid values are an array of machine names or the string "ALL".
+  def_model_attribute :nodes
+
+  # @!attribute [rw] noop
+  # @return [Boolean] If the command should be run with noop. Only valid with tasks and apply.
+  def_model_attribute :noop
+
+  # @!attribute [rw] excludes
+  # Note: The `node_list` will override this setting.
+  # Note: This will be merged with `nodes`, with `excludes` taking precidence.
+  # @return [Array<String, Symbol>] The nodes to exclude from running this task or plan on.
+  # Valid values are an array of machine names.
+  def_model_attribute :excludes
+
+  # @!attribute [rw] node_list
+  # This setting overrides `nodes` and needs to be in the `protocol://ipaddress:port` URI format
+  # @return [String] The bolt node list. This defaults to the currnet node.
+  def_model_attribute :node_list
+
+  # @!attribute [rw] params
+  # @return [Hash] The paramater hash for the task or plan
+  def_model_attribute :params
+
+  # @!attribute [rw] command
+  # @return [Symbol] Whether bolt should use a task or plan
+  def_model_attribute :command
+
+  # @!attribute [rw] user
+  # @return [String] The user to authenticate on the machine.
+  def_model_attribute :user
+
+  # @!attribute [rw] password
+  # @return [String] The password to authenticate on the machine.
+  def_model_attribute :password
+
+  # @!attribute [rw] port
+  # @return [String] The port to connect to the machine.
+  def_model_attribute :port
+
+  # @!attribute [rw] private_key
+  # @return [String] The path of the private_key to authenticate on the machine.
+  def_model_attribute :private_key
+
+  # @!attribute [rw] run_as
+  # @return [String] User to run as using privilege escalation.
+  def_model_attribute :run_as
+
+  # @!attribute [rw] sudo_password
+  # @return [String] The password to authenticate sudo on the machine.
+  def_model_attribute :sudo_password
+
+  # @!attribute [rw] ssl
+  # @return [Boolean] If the connection should use SSL on with WinRM (Windows)
+  def_model_attribute :ssl
+
+  # @!attribute [rw] ssl_verify
+  # @return [Boolean] If the connection should verify SSL on with WinRM (Windows)
+  def_model_attribute :ssl_verify
+
+  # @!attribute [rw] tmpdir
+  # @return [String] The directory to upload and execute temporary files on the target
+  def_model_attribute :tmpdir
+
+  # @!attribute [rw] verbose
+  # @return [Boolean] Shows verbose logging
+  def_model_attribute :verbose
+
+  ConfigBuilder::Model::Provisioner.register('bolt', self)
+end

data/lib/vagrant-bolt/config_builder/triggers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'config_builder/model'
+require_relative 'monkey_patches'
+
+class VagrantBolt::ConfigBuilder::Triggers < VagrantBolt::ConfigBuilder::Config
+  # @!attribute [rw] trigger_type
+  #   @return [Symbol] A symbol containing the the trigger action. Valid values are `:before` and `:after`
+  def_model_attribute :trigger_type
+
+  # @!attribute [rw] trigger_commands
+  #   @return [Array<Symbol>] The commands that the trigger should run on. E.g. `[:up, :provision]`
+  def_model_attribute :trigger_commands
+
+  def to_proc
+    options = @attrs.dup
+    trigger_type = options.delete(:trigger_type)
+    trigger_commands = options.delete(:trigger_commands)
+    command = options.delete(:command)
+    name = options.delete(:name)
+    proc do |config|
+      config.trigger.send(trigger_type, trigger_commands) do |trigger|
+        trigger.ruby do |env, machine|
+          VagrantBolt.send(command, name, env, machine, **options)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-bolt/plugin.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'vagrant'
+require_relative 'version'
+
+raise "vagrant-bolt version #{VagrantBolt::VERSION} requires Vagrant 2.2 or later" if Vagrant::VERSION < "2.2.0"
+
+class VagrantBolt::Plugin < Vagrant.plugin('2')
+  name 'bolt'
+
+  description <<-DESC
+    Vagrant provisioning with Puppet Bolt
+  DESC
+
+  config(:bolt) do
+    require_relative 'config'
+    VagrantBolt::Config::Global
+  end
+
+  config(:bolt, :provisioner) do
+    require_relative 'config'
+    VagrantBolt::Config::Bolt
+  end
+
+  provisioner(:bolt) do
+    require_relative 'provisioner'
+    VagrantBolt::Provisioner
+  end
+
+  command(:bolt) do
+    require_relative 'command'
+    VagrantBolt::Command
+  end
+
+  # Enables config builder loading of this plugin
+  def self.config_builder_hook
+    require_relative 'config_builder'
+  end
+end

data/lib/vagrant-bolt/provisioner.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'vagrant'
+require 'vagrant/errors'
+
+class VagrantBolt::Provisioner < Vagrant.plugin('2', :provisioner)
+  # Provision VMs with Bolt
+  # Creates a trigger for each bolt provisioner
+
+  def provision
+    runner = VagrantBolt::Runner.new(@machine.env, @machine, @config)
+    runner.run(@config.command, @config.name)
+  end
+
+  def cleanup
+    # We don't do any clean up for this provisioner
+  end
+end

data/lib/vagrant-bolt/runner.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'util/bolt'
+require_relative 'util/config'
+require_relative 'util/machine'
+
+class VagrantBolt::Runner
+  def initialize(env, machine, boltconfig = nil)
+    @env = env
+    @machine = machine
+    @boltconfig = boltconfig.nil? ? VagrantBolt::Config::Bolt.new : boltconfig
+    @inventory_path = VagrantBolt::Util::Bolt.inventory_file(@env)
+  end
+
+  # Run a bolt task or plan
+  # @param [Symbol, String] command The command of bolt to run; task or plan
+  # @param [String] name The name of the bolt task or plan to run
+  # @param [Hash] args A optional hash of bolt config overrides. No merging will be done with the overrides
+  # @example run('task', 'facts', {node_list: "machinename"})
+  def run(command, name, **args)
+    @boltconfig = setup_overrides(command, name, **args)
+    # Don't run anything if there are nodes to run it on
+    # TODO: Gate this in a more efficient manner. It is possible to run plans without a node list.
+    return if @boltconfig.node_list.nil?
+
+    @inventory_path = VagrantBolt::Util::Bolt.update_inventory_file(@env)
+    validate
+    command = VagrantBolt::Util::Bolt.generate_bolt_command(@boltconfig, @inventory_path)
+    VagrantBolt::Util::Machine.run_command(command, @machine.ui)
+  end
+
+  private
+
+  # Set up config overrides
+  # @param [Symbol, String] command The command of bolt to run; task or plan
+  # @param [String] name The name of the bolt task or plan to run
+  # @param [Hash] args A optional hash of bolt config overrides; {run_as: "vagrant"}
+  # @return [Object] Bolt config with ssh info populated
+  def setup_overrides(command, name, **args)
+    config = @boltconfig.dup
+    config.command = command
+    config.name = name
+    # Merge the root config to get the defaults for the environment
+    config = VagrantBolt::Util::Config.merge_config(config, @env.vagrantfile.config.bolt)
+    # Add any additional arguments to the config object
+    config.set_options(args) unless args.nil?
+    # Configure the node_list based on the config
+    config.node_list ||= [config.nodes - config.excludes].flatten.join(',') unless config.nodes.empty? || config.nodes.to_s.casecmp("all").zero?
+    config.node_list ||= [VagrantBolt::Util::Machine.nodes_in_environment(@env).map(&:name) - config.excludes].flatten.join(',') if config.nodes.to_s.casecmp("all").zero?
+    config.node_list ||= @machine.name.to_s unless config.excludes.include?(@machine.name.to_s)
+
+    # Ensure these are absolute paths to allow for running vagrant commands outside of the root dir
+    config.modulepath = VagrantBolt::Util::Config.full_path(config.modulepath, @env.root_path)
+    config.boltdir = VagrantBolt::Util::Config.full_path(config.boltdir, @env.root_path)
+
+    config
+  end
+
+  # Validate the config object for configuration issues
+  # Print and raise an exception if errors exist
+  def validate
+    errors = {}
+    errors.merge!(@boltconfig.validate(@machine))
+    errors.merge!(validate_config)
+
+    errors.keys.each do |key|
+      errors.delete(key) if errors[key].empty?
+    end
+
+    # rubocop:disable Style/GuardClause
+    if errors && !errors.empty?
+      raise Vagrant::Errors::ConfigInvalid,
+            errors: Vagrant::Util::TemplateRenderer.render(
+              "config/validation_failed",
+              errors: errors,
+            )
+    end
+    # rubocop:enable Style/GuardClause
+  end
+
+  # Validate a bolt config object for logical errors
+  def validate_config
+    errors = []
+    errors << I18n.t('vagrant-bolt.config.bolt.errors.command_not_specified') if @boltconfig.command.nil?
+    errors << I18n.t('vagrant-bolt.config.bolt.errors.no_task_or_plan') if @boltconfig.name.nil?
+    { "Bolt" => errors }
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative 'machine'
+
+module VagrantBolt::Util
+  module Bolt
+    # Bolt Centric Utility Functions
+
+    # Create a bolt command from the config
+    # @param config [Object] The config objects
+    # @param inventory_path [String] The path of the inventory file
+    # @return [String] The bolt command
+    def self.generate_bolt_command(config, inventory_path = nil)
+      command = []
+      command << config.bolt_exe
+      command << "#{config.command} run \'#{config.name}\'"
+
+      config.instance_variables_hash.each do |key, value|
+        next if key.to_s.start_with?('__')
+        next if config.blacklist.include?(key)
+        next if value.nil?
+
+        key = key.tr('_', '-')
+        case value
+        when TrueClass, FalseClass
+          # Verbose and debug do not have --no flags so exclude them
+          next if ['verbose', 'debug', 'noop'].include?(key) && !value
+
+          arg = value ? "--#{key}" : "--no-#{key}"
+          command << arg
+        when String
+          command << "--#{key} \'#{value}\'"
+        when Hash
+          command << "--#{key} \'#{value.to_json}\'" unless value.empty?
+        end
+      end
+
+      command << "--inventoryfile \'#{inventory_path}\'" unless inventory_path.nil?
+      command << "--nodes \'#{config.node_list}\'" unless config.node_list.nil?
+      command << config.args unless config.args.nil?
+      command.flatten.join(" ")
+    end
+
+    # Generate a bolt inventory hash for the environment
+    # @param env [Object] The env object
+    # @return [Hash] The hash of config options for the inventory.yaml
+    def self.generate_inventory_hash(env)
+      inventory = { 'nodes' => [] }
+      inventory.merge!(env.vagrantfile.config.bolt.inventory_config.compact)
+      VagrantBolt::Util::Machine.nodes_in_environment(env).each do |vm|
+        next unless VagrantBolt::Util::Machine.running?(vm)
+
+        inventory['nodes'] << generate_node_hash(vm)
+      end
+      inventory.compact
+    end
+
+    # Generate a bolt inventory node hash from the VM config
+    # @param machine [Object] The machine object
+    # @return [Hash] The hash of config options for the VM
+    def self.generate_node_hash(machine)
+      # Only call ssh_info once
+      node_hash = {}
+      ssh_info = machine.ssh_info
+      return node_hash if ssh_info.nil?
+
+      node_hash['alias'] = machine.name.to_s
+      machine_config = machine.config.bolt.inventory_config
+      node_hash['config'] = {}
+      transport = VagrantBolt::Util::Machine.windows?(machine) ? 'winrm' : 'ssh'
+      node_hash['config'][transport] = machine_transport_hash(machine, machine_config, ssh_info).compact
+      node_hash['config']['transport'] = transport
+      node_hash['name'] = "#{transport}://#{ssh_info[:host]}:#{node_hash['config'][transport]['port']}"
+      machine_config.each do |key, value|
+        next if key == 'config' || value.nil? || value.empty?
+
+        node_hash[key] = value
+      end
+      node_hash.compact
+    end
+
+    # Return a transport config hash for a node
+    # @param machine [Object] The machine
+    # @param machine_config [Hash] A hash of the machine config options
+    # @param ssh_info [Hash] The ssh hash for the machine
+    def self.machine_transport_hash(machine, machine_config = {}, ssh_info = nil)
+      config = {}
+      if VagrantBolt::Util::Machine.windows?(machine)
+        transport = 'winrm'
+        config['ssl'] = (machine.config.winrm.transport == :ssl)
+        config['ssl_verify'] = machine.config.winrm.ssl_peer_verification
+        config['port'] = machine.config.winrm.port
+        config['user'] = machine.config.winrm.username
+        config['password'] = machine.config.winrm.password
+      else
+        transport = 'ssh'
+        config['private-key'] = ssh_info[:private_key_path][0] unless ssh_info[:private_key_path].nil?
+        config['host-key-check'] = (ssh_info[:verify_host_key] == true)
+        config['port'] = ssh_info[:port]
+        config['user'] = ssh_info[:username]
+        config['password'] = ssh_info[:password]
+      end
+      config.merge!(machine_config['config'][transport]) if machine_config.dig('config', transport)
+      config
+    end
+
+    # Return the path to the inventory file
+    # @param env [Object] The environment
+    # @return [String] The path to the inventory file
+    def self.inventory_file(env)
+      File.join(env.local_data_path, 'bolt_inventory.yaml')
+    end
+
+    # Update and write the inventory file for the current running machines
+    # @param env [Object] The envionment object
+    # @param inventory_file [String] The path where the inventory_file should be written.
+    # @return path to the inventory file
+    def self.update_inventory_file(env, inventory_file = nil)
+      inventory = generate_inventory_hash(env).to_yaml
+      inventory_file ||= Pathname.new(inventory_file(env))
+      # TODO: This lock should be global
+      lock = Mutex.new
+      lock.synchronize do
+        if !File.exist?(inventory_file) || (inventory != File.read(inventory_file))
+          begin
+            inventory_tmpfile = Tempfile.new('.vagrant_bolt_inventory', env.local_data_path)
+            inventory_tmpfile.write(inventory)
+            inventory_tmpfile.close
+            File.rename(inventory_tmpfile.path, inventory_file)
+          ensure
+            inventory_tmpfile.close
+            inventory_tmpfile.unlink
+          end
+        end
+      end
+      inventory_file
+    end
+  end
+end