bolt 2.1.0 → 2.2.0

data/lib/bolt/executor.rb

@@ -10,8 +10,25 @@ require 'bolt/result'
 require 'bolt/config'
 require 'bolt/result_set'
 require 'bolt/puppetdb'
+# Load transports
+require 'bolt/transport/ssh'
+require 'bolt/transport/winrm'
+require 'bolt/transport/orch'
+require 'bolt/transport/local'
+require 'bolt/transport/local_windows'
+require 'bolt/transport/docker'
+require 'bolt/transport/remote'
 
 module Bolt
+  TRANSPORTS = {
+    ssh: Bolt::Transport::SSH,
+    winrm: Bolt::Transport::WinRM,
+    pcp: Bolt::Transport::Orch,
+    local: Bolt::Util.windows? ? Bolt::Transport::LocalWindows : Bolt::Transport::Local,
+    docker: Bolt::Transport::Docker,
+    remote: Bolt::Transport::Remote
+  }.freeze
+
   class Executor
     attr_reader :noop, :transports
     attr_accessor :run_as

data/lib/bolt/inventory.rb

@@ -60,25 +60,32 @@ module Bolt
                end
       end
 
-      inventory = create_version(data, config, plugins)
+      # Resolve plugin references from transport config
+      config.transports.each_value do |t|
+        t.resolve(plugins) unless t.resolved?
+      end
+
+      inventory = create_version(data, config.transport, config.transports, plugins)
       inventory.validate
       inventory
     end
 
-    def self.create_version(data, config, plugins)
+    def self.create_version(data, transport, transports, plugins)
       version = (data || {}).delete('version') { 2 }
+
       case version
       when 2
-        Bolt::Inventory::Inventory.new(data, config, plugins: plugins)
+        Bolt::Inventory::Inventory.new(data, transport, transports, plugins)
       else
         raise ValidationError.new("Unsupported version #{version} specified in inventory", nil)
       end
     end
 
     def self.empty
-      config = Bolt::Config.default
+      config  = Bolt::Config.default
       plugins = Bolt::Plugin.setup(config, nil, nil, Bolt::Analytics::NoopClient)
-      create_version({}, config, plugins)
+
+      create_version({}, config.transport, config.transports, plugins)
     end
   end
 end

data/lib/bolt/inventory/group.rb

@@ -15,7 +15,7 @@ module Bolt
       DATA_KEYS = %w[config facts vars features plugin_hooks].freeze
       TARGET_KEYS = DATA_KEYS + %w[name alias uri]
       GROUP_KEYS = DATA_KEYS + %w[name groups targets]
-      CONFIG_KEYS = Bolt::TRANSPORTS.keys.map(&:to_s) + ['transport']
+      CONFIG_KEYS = Bolt::Config::TRANSPORT_CONFIG.keys + ['transport']
 
       def initialize(input, plugins)
         @logger = Logging.logger[self]

data/lib/bolt/inventory/inventory.rb

@@ -6,24 +6,26 @@ require 'bolt/inventory/target'
 module Bolt
   class Inventory
     class Inventory
-      attr_reader :targets, :plugins, :config
+      attr_reader :targets, :plugins, :config, :transport
       class WildcardError < Bolt::Error
         def initialize(target)
           super("Found 0 targets matching wildcard pattern #{target}", 'bolt.inventory/wildcard-error')
         end
       end
 
-      def initialize(data, config = nil, plugins:)
-        @logger = Logging.logger[self]
-        # Config is saved to add config options to targets
-        @config = config || Bolt::Config.default
-        @data = data || {}
-        @groups = Group.new(@data.merge('name' => 'all'), plugins)
-        @plugins = plugins
+      # TODO: Pass transport config instead of config object
+      def initialize(data, transport, transports, plugins)
+        @logger       = Logging.logger[self]
+        @data         = data || {}
+        @transport    = transport
+        @config       = transports
+        @plugins      = plugins
+        @groups       = Group.new(@data.merge('name' => 'all'), plugins)
         @group_lookup = {}
-        # The targets hash is the canonical source for all targets in inventory
-        @targets = {}
+        @targets      = {}
+
         @groups.resolve_string_targets(@groups.target_aliases, @groups.all_targets)
+
         collect_groups
       end
 
@@ -71,18 +73,6 @@ module Bolt
         target_array.first
       end
 
-      def data_hash
-        {
-          data: {},
-          target_hash: {
-            target_vars: {},
-            target_facts: {},
-            target_features: {}
-          },
-          config: @config.transport_data_get
-        }
-      end
-
       def self.localhost_defaults(data)
         defaults = {
           'config' => {
@@ -284,6 +274,10 @@ module Bolt
         end
       end
 
+      def transport_data_get
+        { transport: transport, transports: config.transform_values(&:to_h) }
+      end
+
       def set_var(target, var_hash)
         @targets[target.name].set_var(var_hash)
       end

data/lib/bolt/inventory/target.rb

@@ -91,6 +91,7 @@ module Bolt
           end
           location[key] = value
         end
+
         invalidate_config_cache!
       end
 
@@ -101,28 +102,8 @@ module Bolt
       end
 
       def invalidate_config_cache!
-        @transport_config_cache = nil
-      end
-
-      # Computing the transport config is expensive as it requires cloning the
-      # base config, so we cache the effective config
-      def transport_config_cache
-        if @transport_config_cache.nil?
-          merged_config = Bolt::Util.deep_merge(group_cache['config'], @config)
-          base_config = @inventory.config
-          transport_data = Bolt::Util.deep_clone(base_config.transports)
-          Bolt::Config.update_transport_hash(base_config.boltdir.path, transport_data, merged_config)
-          transport = merged_config['transport'] || base_config.transport
-          Bolt::TRANSPORTS.each do |name, impl|
-            impl.validate(transport_data[name])
-          end
-          @transport_config_cache = {
-            'transport' => transport,
-            'transports' => transport_data
-          }
-        end
-
-        @transport_config_cache
+        @transport = nil
+        @transport_config = nil
       end
 
       # Validate the target. This implicitly also primes the group and config
@@ -135,6 +116,8 @@ module Bolt
         unless transport.nil? || Bolt::TRANSPORTS.include?(transport.to_sym)
           raise Bolt::UnknownTransportError.new(transport, uri)
         end
+
+        transport_config
       end
 
       def host
@@ -156,15 +139,23 @@ module Bolt
       # For remote targets, the transport is always 'remote'. Otherwise, it
       # will be either the URI scheme or set explicitly.
       def transport
-        if remote?
-          'remote'
-        else
-          @uri_obj.scheme || transport_config_cache['transport']
+        if @transport.nil?
+          config_transport = @config['transport'] ||
+                             group_cache.dig('config', 'transport') ||
+                             @inventory.transport
+
+          @transport = if @uri_obj.scheme == 'remote' || config_transport == 'remote'
+                         'remote'
+                       else
+                         @uri_obj.scheme || config_transport
+                       end
         end
+
+        @transport
       end
 
       def remote?
-        @uri_obj.scheme == 'remote' || transport_config_cache['transport'] == 'remote'
+        transport == 'remote'
       end
 
       def user
@@ -176,13 +167,19 @@ module Bolt
       end
 
       def options
-        transport_config.dup
+        transport_config
       end
 
       # We only want to look up transport config keys for the configured
       # transport
       def transport_config
-        transport_config_cache['transports'][transport.to_sym]
+        if @transport_config.nil?
+          config = @inventory.config[transport]
+                             .merge(group_cache.dig('config', transport), @config[transport])
+          @transport_config = config
+        end
+
+        @transport_config
       end
 
       def config

data/lib/bolt/plugin.rb

@@ -126,14 +126,14 @@ module Bolt
       # we can just add it first.
       plugins.add_plugin(Bolt::Plugin::Puppetdb.new(pdb_client))
 
-      # Initialize any plugins referenced in config. This will also indirectly
+      # Initialize any plugins referenced in plugin config. This will also indirectly
       # initialize any plugins they depend on.
       if plugins.reference?(config.plugins)
         msg = "The 'plugins' setting cannot be set by a plugin reference"
         raise PluginError.new(msg, 'bolt/plugin-error')
       end
 
-      config.plugins.keys.each do |plugin|
+      config.plugins.each_key do |plugin|
         plugins.by_name(plugin)
       end
 
@@ -263,9 +263,9 @@ module Bolt
       if data.is_a?(Array)
         data.flat_map { |elem| resolve_top_level_references(elem) }
       elsif reference?(data)
-        partially_resolved = data.map do |k, v|
-          [k, resolve_references(v)]
-        end.to_h
+        partially_resolved = data.transform_values do |v|
+          resolve_references(v)
+        end
         fully_resolved = resolve_single_reference(partially_resolved)
         # The top-level reference may have returned more references, so repeat the process
         resolve_top_level_references(fully_resolved)

data/lib/bolt/plugin/module.rb

@@ -91,7 +91,7 @@ module Bolt
       end
 
       def validate_config(config, config_schema)
-        config.keys.each do |key|
+        config.each_key do |key|
           msg = "Config for #{name} plugin contains unexpected key #{key}"
           raise Bolt::ValidationError, msg unless config_schema.include?(key)
         end

data/lib/bolt/plugin/pkcs7.rb

@@ -14,7 +14,7 @@ module Bolt
           end
         end
 
-        config.keys.each do |key|
+        config.each_key do |key|
           unless known_keys.include?(key)
             raise Bolt::ValidationError, "Unpexpected key in pkcs7 plugin config: #{key}"
           end

data/lib/bolt/result.rb

@@ -78,7 +78,7 @@ module Bolt
 
     def _pcore_init_from_hash(init_hash)
       opts = init_hash.reject { |k, _v| k == 'target' }
-      initialize(init_hash['target'], opts.map { |k, v| [k.to_sym, v] }.to_h)
+      initialize(init_hash['target'], opts.transform_keys(&:to_sym))
     end
 
     def _pcore_init_hash

data/lib/bolt/target.rb

@@ -76,7 +76,7 @@ module Bolt
     end
 
     def to_h
-      options.merge(
+      options.to_h.merge(
         'name' => name,
         'uri' => uri,
         'protocol' => protocol,
@@ -92,7 +92,10 @@ module Bolt
         'name' => name,
         'uri' => uri,
         'alias' => target_alias,
-        'config' => Bolt::Util.deep_merge(config, 'transport' => transport, transport => options),
+        'config' => {
+          'transport' => transport,
+          transport => options.to_h
+        },
         'vars' => vars,
         'features' => features,
         'facts' => facts,

data/lib/bolt/transport/base.rb

@@ -42,24 +42,6 @@ module Bolt
 
       attr_reader :logger
 
-      # Returns options this transport supports
-      def self.options
-        raise NotImplementedError,
-              "self.options() or self.filter_options(unfiltered) must be implemented by the transport class"
-      end
-
-      def self.default_options
-        {}
-      end
-
-      def self.filter_options(unfiltered)
-        unfiltered.select { |k| options.include?(k) }
-      end
-
-      def self.validate(_options)
-        raise NotImplementedError, "self.validate() must be implemented by the transport class"
-      end
-
       def initialize
         @logger = Logging.logger[self]
       end

data/lib/bolt/transport/docker.rb

@@ -7,36 +7,10 @@ require 'bolt/transport/base'
 module Bolt
   module Transport
     class Docker < Base
-      OPTIONS = {
-        "host"          => "Host name.",
-        "interpreters"  => "A map of an extension name to the absolute path of an executable, "\
-                            "enabling you to override the shebang defined in a task executable. The "\
-                            "extension can optionally be specified with the `.` character (`.py` and "\
-                            "`py` both map to a task executable `task.py`) and the extension is case "\
-                            "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
-                            "Bolt Ruby interpreter by default.",
-        "service-url"   => "URL of the Docker host used for API requests.",
-        "shell-command" => "A shell command to wrap any Docker exec commands in, such as `bash -lc`.",
-        "tmpdir"        => "The directory to upload and execute temporary files on the target.",
-        "tty"           => "Whether to enable tty on exec commands."
-      }.freeze
-
-      def self.options
-        OPTIONS.keys
-      end
-
       def provided_features
         ['shell']
       end
 
-      def self.validate(options)
-        if (url = options['service-url'])
-          unless url.instance_of?(String)
-            raise Bolt::ValidationError, 'service-url must be a string'
-          end
-        end
-      end
-
       def with_connection(target)
         conn = Connection.new(target)
         conn.connect

data/lib/bolt/transport/local.rb

@@ -3,40 +3,10 @@
 module Bolt
   module Transport
     class Local < Sudoable
-      OPTIONS = {
-        "interpreters"    => "A map of an extension name to the absolute path of an executable, "\
-                              "enabling you to override the shebang defined in a task executable. The "\
-                              "extension can optionally be specified with the `.` character (`.py` and "\
-                              "`py` both map to a task executable `task.py`) and the extension is case "\
-                              "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
-                              "Bolt Ruby interpreter by default.",
-        "run-as"          => "A different user to run commands as after login.",
-        "run-as-command"  => "The command to elevate permissions. Bolt appends the user and command "\
-                              "strings to the configured `run-as-command` before running it on the target. "\
-                              "This command must not require an interactive password prompt, and the "\
-                              "`sudo-password` option is ignored when `run-as-command` is specified. The "\
-                              "`run-as-command` must be specified as an array.",
-        "sudo-executable" => "The executable to use when escalating to the configured `run-as` user. This "\
-                              "is useful when you want to escalate using the configured `sudo-password`, since "\
-                              "`run-as-command` does not use `sudo-password` or support prompting. The command "\
-                              "executed on the target is `<sudo-executable> -S -u <user> -p custom_bolt_prompt "\
-                              "<command>`. **This option is experimental.**",
-        "sudo-password"   => "Password to use when changing users via `run-as`.",
-        "tmpdir"          => "The directory to copy and execute temporary files."
-      }.freeze
-
-      def self.options
-        OPTIONS.keys
-      end
-
       def provided_features
         ['shell']
       end
 
-      def self.validate(options)
-        validate_sudo_options(options)
-      end
-
       def with_connection(target, *_args)
         conn = Shell.new(target)
         yield conn

data/lib/bolt/transport/local_windows.rb

@@ -12,27 +12,6 @@ require 'bolt/util'
 module Bolt
   module Transport
     class LocalWindows < Base
-      OPTIONS = {
-        "interpreters"   => "A map of an extension name to the absolute path of an executable, "\
-                            "enabling you to override the shebang defined in a task executable. The "\
-                            "extension can optionally be specified with the `.` character (`.py` and "\
-                            "`py` both map to a task executable `task.py`) and the extension is case "\
-                            "sensitive. When a target's name is `localhost`, Ruby tasks run with the "\
-                            "Bolt Ruby interpreter by default.",
-        "run-as"         => "A different user to run commands as after login.",
-        "run-as-command" => "The command to elevate permissions. Bolt appends the user and command "\
-                            "strings to the configured `run-as-command` before running it on the target. "\
-                            "This command must not require an interactive password prompt, and the "\
-                            "`sudo-password` option is ignored when `run-as-command` is specified. The "\
-                            "`run-as-command` must be specified as an array.",
-        "sudo-password"  => "Password to use when changing users via `run-as`.",
-        "tmpdir"         => "The directory to copy and execute temporary files."
-      }.freeze
-
-      def self.options
-        OPTIONS.keys
-      end
-
       def provided_features
         ['powershell']
       end
@@ -42,13 +21,6 @@ module Bolt
         input_method
       end
 
-      def self.validate(options)
-        logger = Logging.logger[self]
-        if options['sudo-password'] || options['run-as'] || options['run-as-command'] || options[:run_as]
-          logger.warn("run-as is not supported for Windows hosts using the local transport")
-        end
-      end
-
       def in_tmpdir(base)
         args = base ? [nil, base] : []
         dir = begin
@@ -98,14 +70,12 @@ module Bolt
         result_output
       end
 
-      def upload(target, source, destination, options = {})
-        self.class.validate(options)
+      def upload(target, source, destination, _options = {})
         copy_file(source, destination)
         Bolt::Result.for_upload(target, source, destination)
       end
 
-      def run_command(target, command, options = {})
-        self.class.validate(options)
+      def run_command(target, command, _options = {})
         in_tmpdir(target.options['tmpdir']) do |dir|
           output = execute(command, dir: dir)
           Bolt::Result.for_command(target,
@@ -116,8 +86,7 @@ module Bolt
         end
       end
 
-      def run_script(target, script, arguments, options = {})
-        self.class.validate(options)
+      def run_script(target, script, arguments, _options = {})
         with_tmpscript(File.absolute_path(script), target.options['tmpdir']) do |file, dir|
           logger.debug "Running '#{file}' with #{arguments.to_json}"
 
@@ -141,8 +110,7 @@ module Bolt
         end
       end
 
-      def run_task(target, task, arguments, options = {})
-        self.class.validate(options)
+      def run_task(target, task, arguments, _options = {})
         implementation = select_implementation(target, task)
         executable = implementation['path']
         input_method = implementation['input_method']