bolt 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4e27492b22291a233b5fb9dfbb8e8648a15ce19
-  data.tar.gz: 9b2d163aa823b02cd7b6cfc6031846841d7c7b30
+  metadata.gz: 4990187d4d2da77d515fdbe3d840b415683d7082
+  data.tar.gz: 1eebdfd02969958314e3fa1b4ce0e03b6efc208c
 SHA512:
-  metadata.gz: b3d53aafec9ab3aa09d30dd5d45624aa74a20835373c70f174508f4986c33470b5b45350f40014e534b18f59a6267303395f2075cdb1269231b112c8d9ec1765
-  data.tar.gz: 664b5acf2aa442bf7e24dd76b61723819a4eb0523b34118bd0976f6c696db03319e979ad40521af7334bebf06cdd545b071b3eef87047b0b5ced11988f6e49a5
+  metadata.gz: 97ae71fbb805bc96980f1353eebcb458e528c74e9a9c1c94a33ffe0f7c6256058080e6052cee0909dcb06a84fea6cb764a59f47de86e1027df2ff06c9ac3e1f4
+  data.tar.gz: 4fa7f06bf895ab837451077997aa05bbc4b0291116a3be254cb9e4c600d5eb35da98b48fa349a32ca902b8f4849fa5d79d9bc44b05754a4dc6b46050d088b87b

data/lib/bolt/cli.rb

@@ -139,11 +139,19 @@ HELP
                 "Private ssh key to authenticate with (Optional)") do |key|
           results[:key] = key
         end
+        opts.on('--tmpdir DIR',
+                "The directory to upload and execute temporary files on the target(Optional)") do |tmpdir|
+          results[:tmpdir] = tmpdir
+        end
         opts.on('-c', '--concurrency CONCURRENCY', Integer,
                 "Maximum number of simultaneous connections " \
                 "(Optional, defaults to 100)") do |concurrency|
           results[:concurrency] = concurrency
         end
+        opts.on('--connect-timeout TIMEOUT', Integer,
+                "Connection timeout (Optional)") do |timeout|
+          results[:connect_timeout] = timeout
+        end
         opts.on('--modulepath MODULES',
                 "List of directories containing modules, " \
                 "separated by #{File::PATH_SEPARATOR}") do |modulepath|
@@ -401,15 +409,7 @@ HELP
                 outputter.print_event(node, event)
               end
             when 'task'
-              task_name = options[:object]
-
-              path, metadata = load_task_data(task_name, @config[:modulepath])
-              input_method = metadata['input_method']
-
-              input_method ||= 'both'
-              executor.run_task(
-                nodes, path, input_method, options[:task_options]
-              ) do |node, event|
+              execute_task(executor, options) do |node, event|
                 outputter.print_event(node, event)
               end
             when 'file'
@@ -433,12 +433,26 @@ HELP
       raise e
     end
 
+    def with_bolt_executor(executor, &block)
+      Puppet.override(bolt_executor: executor, &block)
+    end
+
+    def execute_task(executor, options, &block)
+      with_bolt_executor(executor) do
+        run_task(options[:object],
+                 options[:nodes],
+                 options[:task_options],
+                 &block)
+      end
+    rescue Puppet::Error
+      raise Bolt::CLIError, "Exiting because of an error in Puppet code"
+    end
+
     def execute_plan(executor, options)
       # Plans return null here?
-      result = Puppet.override(bolt_executor: executor) do
+      result = with_bolt_executor(executor) do
         run_plan(options[:object],
-                 options[:task_options],
-                 @config[:modulepath])
+                 options[:task_options])
       end
       outputter.print_plan(result)
     rescue Puppet::Error
@@ -469,48 +483,34 @@ HELP
       @outputter ||= Bolt::Outputter.for_format(@config[:format])
     end
 
-    def load_task_data(name, modulepath)
-      module_name, file_name = name.split('::', 2)
-      file_name ||= 'init'
-
-      begin
-        env = Puppet::Node::Environment.create('bolt', modulepath)
-        Puppet.override(environments: Puppet::Environments::Static.new(env)) do
-          data = Puppet::InfoService::TaskInformationService.task_data(
-            env.name, module_name, name
-          )
-
-          file = data[:files].find { |f| File.basename(f, '.*') == file_name }
-          if file.nil?
-            raise Bolt::CLIError, "Failed to load task file for '#{name}'"
+    def run_task(name, nodes, args, &block)
+      parse_error = nil
+      Puppet.initialize_settings
+      Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + @config[:modulepath], facts: {}) do |pal|
+        pal.with_script_compiler do |compiler|
+          begin
+            return compiler.call_function('run_task', name, nodes, args, &block)
+          rescue Puppet::ParseError => e
+            # we assume that the Puppet::ParseError is due to a problem with
+            # the task and/or its parameters, but since the with_script_compiler
+            # method rescues these errors and raises different ones instead,
+            # we save it in a local variable and raise it as Bolt::CLIError
+            # outside of the block
+            parse_error = e
           end
-
-          metadata =
-            if data[:metadata_file]
-              JSON.parse(File.read(data[:metadata_file]))
-            else
-              {}
-            end
-
-          [file, metadata]
         end
-      rescue Puppet::Module::Task::TaskNotFound
-        raise  Bolt::CLIError,
-               "Could not find task '#{name}' in module '#{module_name}'"
-      rescue Puppet::Module::MissingModule
-        # Generate message so we don't expose "bolt environment"
-        raise  Bolt::CLIError, "Could not find module '#{module_name}'"
       end
+      raise Bolt::CLIError, parse_error.message
     end
 
-    def run_plan(plan, args, modulepath)
+    def run_plan(plan, args)
       Dir.mktmpdir('bolt') do |dir|
         cli = []
         Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
           cli << "--#{setting}" << dir
         end
         Puppet.initialize_settings(cli)
-        Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + modulepath, facts: {}) do |pal|
+        Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + @config[:modulepath], facts: {}) do |pal|
           pal.with_script_compiler do |compiler|
             compiler.call_function('run_plan', plan, args)
           end

data/lib/bolt/config.rb

@@ -20,9 +20,10 @@ module Bolt
       log_destination: STDERR
     }.freeze
 
-    TRANSPORT_OPTIONS = %i[insecure password run_as sudo sudo_password key tty user].freeze
+    TRANSPORT_OPTIONS = %i[insecure password run_as sudo sudo_password key tty tmpdir user connect_timeout].freeze
 
     TRANSPORT_DEFAULTS = {
+      connect_timeout: 10,
       insecure: false,
       tty: false
     }.freeze
@@ -93,11 +94,22 @@ module Bolt
         if data['ssh']['insecure']
           self[:transports][:ssh][:insecure] = data['ssh']['insecure']
         end
+        if data['ssh']['connect-timeout']
+          self[:transports][:ssh][:connect_timeout] = data['ssh']['connect-timeout']
+        end
+        if data['ssh']['tmpdir']
+          self[:transports][:ssh][:tmpdir] = data['ssh']['tmpdir']
+        end
+      end
+
+      if data['winrm']
+        if data['winrm']['connect-timeout']
+          self[:transports][:winrm][:connect_timeout] = data['winrm']['connect-timeout']
+        end
+        if data['winrm']['tmpdir']
+          self[:transports][:winrm][:tmpdir] = data['winrm']['tmpdir']
+        end
       end
-      # if data['pcp']
-      # end
-      # if data['winrm']
-      # end
     end
 
     def load_file(path)
@@ -135,6 +147,14 @@ module Bolt
       unless %w[human json].include? self[:format]
         raise Bolt::CLIError, "Unsupported format: '#{self[:format]}'"
       end
+
+      self[:transports].each_value do |v|
+        timeout_value = v[:connect_timeout]
+        unless timeout_value.is_a?(Integer) || timeout_value.nil?
+          error_msg = "connect-timeout value must be an Integer, received #{timeout_value}:#{timeout_value.class}"
+          raise Bolt::CLIError, error_msg
+        end
+      end
     end
   end
 end

data/lib/bolt/node.rb

@@ -29,7 +29,7 @@ module Bolt
 
     def self.initialize_transport(_logger); end
 
-    attr_reader :logger, :host, :uri, :user, :password
+    attr_reader :logger, :host, :uri, :user, :password, :connect_timeout
 
     def initialize(host, port = nil, user = nil, password = nil, uri: nil,
                    config: Bolt::Config.new)
@@ -43,9 +43,11 @@ module Bolt
       @key = transport_conf[:key]
       @tty = transport_conf[:tty]
       @insecure = transport_conf[:insecure]
+      @connect_timeout = transport_conf[:connect_timeout]
       @sudo = transport_conf[:sudo]
       @sudo_password = transport_conf[:sudo_password]
       @run_as = transport_conf[:run_as]
+      @tmpdir = transport_conf[:tmpdir]
 
       @logger = init_logger(config[:log_destination], config[:log_level])
       @transport_logger = init_logger(config[:log_destination], Logger::WARN)

data/lib/bolt/node/ssh.rb

@@ -32,6 +32,7 @@ module Bolt
                                   else
                                     Net::SSH::Verifiers::Secure.new
                                   end
+      options[:timeout] = @connect_timeout if @connect_timeout
 
       @session = Net::SSH.start(@host, @user, options)
       @logger.debug { "Opened session" }
@@ -45,6 +46,11 @@ module Bolt
         "Host key verification failed for #{@uri}: #{e.message}",
         'HOST_KEY_ERROR'
       )
+    rescue Net::SSH::ConnectionTimeout
+      raise Bolt::Node::ConnectError.new(
+        "Timeout after #{@connect_timeout} seconds connecting to #{@uri}",
+        'CONNECT_ERROR'
+      )
     rescue StandardError => e
       raise Bolt::Node::ConnectError.new(
         "Failed to connect to #{@uri}: #{e.message}",
@@ -165,11 +171,18 @@ module Bolt
     end
 
     def make_tempdir
-      result = execute('mktemp -d')
+      tmppath = nil
+      if @tmpdir
+        tmppath = "#{@tmpdir}/#{SecureRandom.uuid}"
+        command = "mkdir -m 700 #{tmppath}"
+      else
+        command = 'mktemp -d'
+      end
+      result = execute(command)
       if result.exit_code != 0
         raise FileError.new("Could not make tempdir: #{result.stderr.string}", 'TEMPDIR_ERROR')
       end
-      result.stdout.string.chomp
+      tmppath || result.stdout.string.chomp
     end
 
     def with_remote_tempdir

data/lib/bolt/node/winrm.rb

@@ -17,14 +17,24 @@ module Bolt
     end
 
     def connect
-      @connection = ::WinRM::Connection.new(endpoint: @endpoint,
-                                            user: @user,
-                                            password: @password)
-      @connection.logger = @transport_logger
-
-      @session = @connection.shell(@shell)
-      @session.run('$PSVersionTable.PSVersion')
-      @logger.debug { "Opened session" }
+      options = { endpoint: @endpoint,
+                  user: @user,
+                  password: @password,
+                  retry_limit: 1 }
+
+      Timeout.timeout(@connect_timeout) do
+        @connection = ::WinRM::Connection.new(options)
+        @connection.logger = @transport_logger
+
+        @session = @connection.shell(@shell)
+        @session.run('$PSVersionTable.PSVersion')
+        @logger.debug { "Opened session" }
+      end
+    rescue Timeout::Error
+      raise Bolt::Node::ConnectError.new(
+        "Timeout after #{@connect_timeout} seconds connecting to #{@endpoint}",
+        'CONNECT_ERROR'
+      )
     rescue ::WinRM::WinRMAuthorizationError
       raise Bolt::Node::ConnectError.new(
         "Authentication failed for #{@endpoint}",
@@ -425,8 +435,9 @@ PS
     end
 
     def make_tempdir
+      find_parent = @tmpdir ? "\"#{@tmpdir}\"" : '[System.IO.Path]::GetTempPath()'
       result = execute(<<-PS)
-$parent = [System.IO.Path]::GetTempPath()
+$parent = #{find_parent}
 $name = [System.IO.Path]::GetRandomFileName()
 $path = Join-Path $parent $name
 New-Item -ItemType Directory -Path $path | Out-Null

data/lib/bolt/version.rb

@@ -1,3 +1,3 @@
 module Bolt
-  VERSION = '0.10.0'.freeze
+  VERSION = '0.11.0'.freeze
 end

data/modules/boltlib/lib/puppet/functions/run_plan.rb

@@ -6,7 +6,7 @@
 #     # do things with tasks
 #     notice "plan done with param x = ${x}"
 #   }
-#   run_plan('myplan', {x => 'testing' }
+#   run_plan('myplan', { x => 'testing' })
 #
 Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction) do
   dispatch :run_plan do

data/modules/boltlib/lib/puppet/functions/run_task.rb

@@ -10,45 +10,38 @@ Puppet::Functions.create_function(:run_task) do
     type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
   end
 
-  dispatch :run_task_type do
-    param 'Type[Task]', :task_type
+  dispatch :run_task do
+    param 'String[1]', :task_name
     param 'TargetOrTargets', :targets
     optional_param 'Hash[String[1], Any]', :task_args
   end
 
-  dispatch :run_named_task do
-    param 'String[1]', :task_type
+  # this is used from 'bolt task run'
+  dispatch :run_task_raw do
+    param 'String[1]', :task_name
     param 'TargetOrTargets', :targets
     optional_param 'Hash[String[1], Any]', :task_args
+    block_param
   end
 
-  dispatch :run_task_instance do
-    param 'Task', :task
-    repeated_param 'TargetOrTargets', :targets
+  def run_task(task_name, targets, task_args = nil)
+    Puppet::Pops::Types::ExecutionResult.from_bolt(
+      run_task_raw(task_name, targets, task_args)
+    )
   end
 
-  def run_task_type(task_type, targets, task_args = nil)
-    use_args = task_args.nil? ? {} : task_args
-    task_instance = call_function('new', task_type, use_args)
-    run_task_instance(task_instance, targets)
-  end
-
-  def run_named_task(task_name, targets, task_args = nil)
-    task_type = Puppet.lookup(:loaders).private_environment_loader.load(:type, task_name)
-    if task_type.nil?
+  def run_task_raw(task_name, targets, task_args = nil, &block)
+    unless Puppet[:tasks]
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::UNKNOWN_TASK, type_name: task_name
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_task'
       )
     end
-    use_args = task_args.nil? ? {} : task_args
-    task_instance = call_function('new', task_type, use_args)
-    run_task_instance(task_instance, targets)
-  end
 
-  def run_task_instance(task, *targets)
-    unless Puppet[:tasks]
+    # TODO: use the compiler injection once PUP-8237 lands
+    task_signature = Puppet::Pal::ScriptCompiler.new(closure_scope.compiler).task_signature(task_name)
+    if task_signature.nil?
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_task'
+        Puppet::Pops::Issues::UNKNOWN_TASK, type_name: task_name
       )
     end
 
@@ -59,22 +52,26 @@ Puppet::Functions.create_function(:run_task) do
       )
     end
 
+    use_args = task_args.nil? ? {} : task_args
+    task_signature.runnable_with?(use_args) do |mismatch|
+      raise Puppet::ParseError, mismatch
+    end || (raise Puppet::ParseError, 'Task parameters did not match')
+    task = task_signature.task
+
     # Ensure that that given targets are all Target instances
+    targets = [targets] unless targets.is_a?(Array)
     targets = targets.flatten.map { |t| t.is_a?(String) ? Puppet::Pops::Types::TypeFactory.target.create(t) : t }
     if targets.empty?
-      call_function('debug', "Simulating run of task #{task._pcore_type.name} - no targets given - no action taken")
-      Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
+      call_function('debug', "Simulating run of task #{task.name} - no targets given - no action taken")
+      Puppet::Pops::EMPTY_HASH
     else
-      # Awaits change in the executor, enabling it receive Target instances
+      # TODO: Awaits change in the executor, enabling it receive Target instances
       hosts = targets.map(&:host)
 
       # TODO: separate handling of default since it's platform specific
-      input_method = task._pcore_type['input_method'].value
+      input_method = task.input_method
 
-      arguments = task.task_args
-      Puppet::Pops::Types::ExecutionResult.from_bolt(
-        executor.run_task(executor.from_uris(hosts), task.executable_path, input_method, arguments)
-      )
+      executor.run_task(executor.from_uris(hosts), task.executable, input_method, use_args, &block)
     end
   end
 end

data/vendored/puppet/lib/puppet.rb

@@ -42,11 +42,8 @@ module Puppet
   require 'puppet/environments'
 
   class << self
-    Puppet::GettextConfig.create_text_domain('production')
-    locale_dir = Puppet::GettextConfig.puppet_locale_path
-    if Puppet::GettextConfig.load_translations('puppet', locale_dir, Puppet::GettextConfig.translation_mode(locale_dir))
-      Puppet::GettextConfig.set_locale(Locale.current.language)
-    end
+    Puppet::GettextConfig.setup_locale
+    Puppet::GettextConfig.create_default_text_domain
 
     include Puppet::Util
     attr_reader :features

data/vendored/puppet/lib/puppet/application.rb

@@ -281,6 +281,23 @@ class Application
       @run_mode = Puppet::Util::RunMode[ mode_name || Puppet.settings.preferred_run_mode ]
     end
 
+    # Sets environment_mode name
+    # @param mode_name [Symbol] The name of the environment mode to run in. May
+    #   be one of :local, :remote, or :not_required. This impacts where the
+    #   application looks for its specified environment. If :not_required or
+    #   :remote are set, the application will not fail if the environment does
+    #   not exist on the local filesystem.
+    def environment_mode(mode_name)
+      raise Puppet::Error, _("Invalid environment mode '%{mode_name}'") % { mode_name: mode_name } unless [:local, :remote, :not_required].include?(mode_name)
+      @environment_mode = mode_name
+    end
+
+    # Gets environment_mode name. If none is set with `environment_mode=`,
+    # default to :local.
+    def get_environment_mode
+      @environment_mode || :local
+    end
+
     # This is for testing only
     def clear_everything_for_tests
       @run_mode = @banner = @run_status = @option_parser_commands = nil
@@ -343,7 +360,7 @@ class Application
       initialize_app_defaults
     end
 
-    Puppet::ApplicationSupport.push_application_context(self.class.run_mode)
+    Puppet::ApplicationSupport.push_application_context(self.class.run_mode, self.class.get_environment_mode)
 
     exit_on_fail(_("Could not initialize"))                { preinit }
     exit_on_fail(_("Could not parse application options")) { parse_options }