bolt 0.16.1 → 0.16.2

data/lib/bolt/version.rb

@@ -1,3 +1,3 @@
 module Bolt
-  VERSION = '0.16.1'.freeze
+  VERSION = '0.16.2'.freeze
 end

data/modules/boltlib/lib/puppet/datatypes/target.rb

@@ -5,7 +5,12 @@ Puppet::DataTypes.create_type('Target') do
       options => { type => Hash[String[1], Data], value => {} }
     },
     functions => {
+      host => Callable[[], String[1]],
       name => Callable[[], String[1]],
+      password => Callable[[], Optional[String[1]]],
+      port => Callable[[], Optional[Integer]],
+      protocol => Callable[[], Optional[String[1]]],
+      user => Callable[[], Optional[String[1]]],
     }
     PUPPET
 

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

@@ -5,7 +5,7 @@
 
 require 'bolt/error'
 
-Puppet::Functions.create_function(:fail_plan, Puppet::Functions::InternalFunction) do
+Puppet::Functions.create_function(:fail_plan) do
   dispatch :from_args do
     param 'String[1]', :msg
     optional_param 'String[1]', :kind

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

@@ -8,15 +8,11 @@
 require 'bolt/error'
 
 Puppet::Functions.create_function(:file_upload, Puppet::Functions::InternalFunction) do
-  local_types do
-    type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
-  end
-
   dispatch :file_upload do
     scope_param
     param 'String[1]', :source
     param 'String[1]', :destination
-    param 'TargetOrTargets', :targets
+    param 'Boltlib::TargetSpec', :targets
     optional_param 'Hash[String[1], Any]', :options
     return_type 'ResultSet'
   end

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

@@ -0,0 +1,41 @@
+# Parses common ways of referring to targets and returns an array of Targets.
+#
+# Accepts input consisting of
+# - a group
+# - a target URI
+# - an array of groups and/or target URIs
+# - a string that consists of a comma-separated list of groups and/or target URIs
+#
+# Examples of the above would be
+# - 'group1'
+# - 'host1,group1,winrm://host2:54321'
+# - ['host1', 'group1', 'winrm://host2:54321']
+#
+# Returns an array of unique Targets resolved from any target URIs and groups.
+
+require 'bolt/error'
+
+Puppet::Functions.create_function(:get_targets) do
+  dispatch :get_targets do
+    param 'Boltlib::TargetSpec', :names
+    return_type 'Array[Target]'
+  end
+
+  def get_targets(names)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'get_targets'
+      )
+    end
+
+    inventory = Puppet.lookup(:bolt_inventory) { nil }
+
+    unless inventory && Puppet.features.bolt?
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('process targets through inventory')
+      )
+    end
+
+    inventory.get_targets(names)
+  end
+end

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

@@ -8,13 +8,9 @@
 require 'bolt/error'
 
 Puppet::Functions.create_function(:run_command) do
-  local_types do
-    type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
-  end
-
   dispatch :run_command do
     param 'String[1]', :command
-    param 'TargetOrTargets', :targets
+    param 'Boltlib::TargetSpec', :targets
     optional_param 'Hash[String[1], Any]', :options
     return_type 'ResultSet'
   end
@@ -35,7 +31,7 @@ Puppet::Functions.create_function(:run_command) do
       )
     end
 
-    # Ensure that that given targets are all Target instances
+    # Ensure that given targets are all Target instances
     targets = inventory.get_targets(targets)
 
     if targets.empty?

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

@@ -61,7 +61,10 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
 
       return result
     end
+
     # Could not find plan
-    raise ArgumentError, "Function #{self.class.name}(): Unknown plan: '#{plan_name}'"
+    raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+      Puppet::Pops::Issues.issue(:UNKNOWN_PLAN) { Bolt::Error.unknown_plan(plan_name) }
+    )
   end
 end

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

@@ -6,14 +6,10 @@
 # * The returned value contains information about the result per target.
 #
 Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFunction) do
-  local_types do
-    type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
-  end
-
   dispatch :run_script do
     scope_param
     param 'String[1]', :script
-    param 'TargetOrTargets', :targets
+    param 'Boltlib::TargetSpec', :targets
     optional_param 'Hash[String[1], Any]', :options
     return_type 'ResultSet'
   end
@@ -46,7 +42,7 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
       )
     end
 
-    # Ensure that that given targets are all Target instances)
+    # Ensure that given targets are all Target instances)
     targets = inventory.get_targets(targets)
 
     #

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

@@ -8,13 +8,9 @@
 require 'bolt/error'
 
 Puppet::Functions.create_function(:run_task) do
-  local_types do
-    type 'TargetOrTargets = Variant[String[1], Target, Array[TargetOrTargets]]'
-  end
-
   dispatch :run_task do
     param 'String[1]', :task_name
-    param 'TargetOrTargets', :targets
+    param 'Boltlib::TargetSpec', :targets
     optional_param 'Hash[String[1], Any]', :task_args
     return_type 'ResultSet'
   end
@@ -22,7 +18,7 @@ Puppet::Functions.create_function(:run_task) do
   # this is used from 'bolt task run'
   dispatch :run_task_raw do
     param 'String[1]', :task_name
-    param 'TargetOrTargets', :targets
+    param 'Boltlib::TargetSpec', :targets
     optional_param 'Hash[String[1], Any]', :task_args
     # return_type 'ResultSet'
     block_param
@@ -48,9 +44,7 @@ Puppet::Functions.create_function(:run_task) do
     # 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::UNKNOWN_TASK, type_name: task_name
-      )
+      raise with_stack(:UNKNOWN_TASK, Bolt::Error.unknown_task(task_name))
     end
 
     executor = Puppet.lookup(:bolt_executor) { nil }
@@ -63,12 +57,12 @@ Puppet::Functions.create_function(:run_task) do
 
     use_args = task_args.reject { |k, _| k.start_with?('_') }
 
-    task_signature.runnable_with?(use_args) do |mismatch|
-      raise Puppet::ParseError, mismatch
-    end || (raise Puppet::ParseError, 'Task parameters did not match')
+    task_signature.runnable_with?(use_args) do |mismatch_message|
+      raise with_stack(:TYPE_MISMATCH, mismatch_message)
+    end || (raise with_stack(:TYPE_MISMATCH, 'Task parameters do not match'))
 
     unless Puppet::Pops::Types::TypeFactory.data.instance?(use_args)
-      raise Puppet::ParseError, 'Task parameters is not of type Data'
+      raise with_stack(:TYPE_NOT_DATA, 'Task parameters is not of type Data')
     end
 
     task = task_signature.task
@@ -77,18 +71,22 @@ Puppet::Functions.create_function(:run_task) do
       if task.supports_noop
         use_args['_noop'] = true
       else
-        raise Puppet::ParseError, 'Task does not support noop'
+        raise with_stack(:TASK_NO_NOOP, 'Task does not support noop')
       end
     end
 
-    # Ensure that that given targets are all Target instances
+    # Ensure that given targets are all Target instances
     targets = inventory.get_targets(targets)
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      # TODO: pass entire task to executor
       options = task_args.select { |k, _| k == '_run_as' }
-      executor.run_task(targets, task.executable, task.input_method, use_args, options, &block)
+      executor.run_task(targets, task, use_args, options, &block)
     end
   end
+
+  def with_stack(kind, msg)
+    issue = Puppet::Pops::Issues.issue(kind) { msg }
+    Puppet::ParseErrorWithIssue.from_issue_and_stack(issue)
+  end
 end

data/modules/boltlib/types/targetspec.pp

@@ -0,0 +1,7 @@
+# A TargetSpec represents any String, Target or combination thereof that can be
+# passed to get_targets() to return an Array[Target]. Generally, users
+# shouldn't need to worry about the distinction between TargetSpec and
+# Target/Array[Target], since the run_* functions will all handle them both
+# automatically. But for use cases that need to deal with the exact list of
+# Targets that will be used, get_targets() will return that.
+type Boltlib::TargetSpec = Variant[String[1], Target, Array[Boltlib::TargetSpec]]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 0.16.1
+  version: 0.16.2
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-09 00:00:00.000000000 Z
+date: 2018-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -341,12 +341,8 @@ files:
 - lib/bolt/inventory.rb
 - lib/bolt/inventory/group.rb
 - lib/bolt/logger.rb
-- lib/bolt/node.rb
 - lib/bolt/node/errors.rb
-- lib/bolt/node/orch.rb
 - lib/bolt/node/output.rb
-- lib/bolt/node/ssh.rb
-- lib/bolt/node/winrm.rb
 - lib/bolt/notifier.rb
 - lib/bolt/outputter.rb
 - lib/bolt/outputter/human.rb
@@ -355,6 +351,12 @@ files:
 - lib/bolt/result.rb
 - lib/bolt/result_set.rb
 - lib/bolt/target.rb
+- lib/bolt/transport/base.rb
+- lib/bolt/transport/orch.rb
+- lib/bolt/transport/ssh.rb
+- lib/bolt/transport/ssh/connection.rb
+- lib/bolt/transport/winrm.rb
+- lib/bolt/transport/winrm/connection.rb
 - lib/bolt/util.rb
 - lib/bolt/version.rb
 - modules/boltlib/lib/puppet/datatypes/result.rb
@@ -362,10 +364,12 @@ files:
 - modules/boltlib/lib/puppet/datatypes/target.rb
 - modules/boltlib/lib/puppet/functions/fail_plan.rb
 - modules/boltlib/lib/puppet/functions/file_upload.rb
+- modules/boltlib/lib/puppet/functions/get_targets.rb
 - modules/boltlib/lib/puppet/functions/run_command.rb
 - modules/boltlib/lib/puppet/functions/run_plan.rb
 - modules/boltlib/lib/puppet/functions/run_script.rb
 - modules/boltlib/lib/puppet/functions/run_task.rb
+- modules/boltlib/types/targetspec.pp
 - vendored/facter/lib/facter.rb
 - vendored/facter/lib/facter/Cfkey.rb
 - vendored/facter/lib/facter/application.rb

data/lib/bolt/node.rb

@@ -1,76 +0,0 @@
-require 'bolt/result'
-require 'bolt/config'
-require 'bolt/target'
-require 'logging'
-
-module Bolt
-  class Node
-    STDIN_METHODS       = %w[both stdin].freeze
-    ENVIRONMENT_METHODS = %w[both environment].freeze
-
-    def self.from_target(target)
-      klass = case target.protocol
-              when 'winrm'
-                Bolt::WinRM
-              when 'pcp'
-                Bolt::Orch
-              else
-                Bolt::SSH
-              end
-      klass.new(target)
-    end
-
-    def self.initialize_transport(_logger); end
-
-    attr_reader :logger, :user, :password, :connect_timeout, :target, :run_as
-
-    def initialize(target)
-      @target = target
-
-      transport_conf = target.options
-      @user = @target.user
-      @password = @target.password
-      @key = transport_conf[:key]
-      @cacert = transport_conf[:cacert]
-      @tty = transport_conf[:tty]
-      @host_key_check = transport_conf[:host_key_check]
-      @ssl = transport_conf[:ssl]
-      @connect_timeout = transport_conf[:connect_timeout]
-      @sudo_password = transport_conf[:sudo_password]
-      @run_as = transport_conf[:run_as]
-      @conf_run_as = transport_conf[:run_as]
-      @tmpdir = transport_conf[:tmpdir]
-      @service_url = transport_conf[:service_url]
-      @token_file = transport_conf[:token_file]
-      @orch_task_environment = transport_conf[:orch_task_environment]
-      @extensions = transport_conf[:extensions]
-
-      @logger = Logging.logger[@target.host]
-    end
-
-    def uri
-      @target.uri
-    end
-
-    def upload(_source, _destination, _options = nil)
-      raise NotImplementedError, 'transports must implement upload(source, destination, options = nil)'
-    end
-
-    def run_command(_command, _options = nil)
-      raise NotImplementedError, 'transports must implement run_command(command, options = nil)'
-    end
-
-    def run_script(_script, _arguments, _options = nil)
-      raise NotImplementedError, 'transports must implement run_script(script, arguments, options = nil)'
-    end
-
-    def run_task(_task, _input_method, _arguments, _options = nil)
-      raise NotImplementedError, 'transports must implement run_task(task, input_method, arguments, options = nil)'
-    end
-  end
-end
-
-require 'bolt/node/errors'
-require 'bolt/node/ssh'
-require 'bolt/node/winrm'
-require 'bolt/node/orch'

data/lib/bolt/node/orch.rb

@@ -1,126 +0,0 @@
-require 'base64'
-require 'json'
-require 'orchestrator_client'
-
-module Bolt
-  class Orch < Node
-    CONF_FILE = File.expand_path('~/.puppetlabs/client-tools/orchestrator.conf')
-    BOLT_MOCK_FILE = 'bolt/tasks/init'.freeze
-
-    def connect; end
-
-    def disconnect; end
-
-    def protocol
-      'pcp'
-    end
-
-    def make_client
-      opts = {}
-      opts["service-url"] = @service_url if @service_url
-      opts["token-file"] = @token_file if @token_file
-      opts["cacert"] = @cacert if @cacert
-      OrchestratorClient.new(opts, true)
-    end
-
-    def client
-      @client ||= make_client
-    end
-
-    # This avoids a refactor to pass more task data around
-    def task_name_from_path(path)
-      path = File.absolute_path(path)
-      parts = path.split(File::Separator)
-      if parts.length < 3 || parts[-2] != 'tasks'
-        raise ArgumentError, "Task path was not inside a module."
-      end
-      mod = parts[-3]
-      name = File.basename(path).split('.')[0]
-      if name == 'init'
-        mod
-      else
-        "#{mod}::#{name}"
-      end
-    end
-
-    def run_task(task, _input_method, arguments, _options = nil)
-      body = { task: task_name_from_path(task),
-               environment: @orch_task_environment,
-               noop: arguments['_noop'],
-               params: arguments.reject { |k, _| k == '_noop' },
-               scope: {
-                 nodes: [@target.host]
-               } }
-      # Should we handle errors here or let them propagate?
-      results = client.run_task(body)
-      node_result = results[0]
-      state = node_result['state']
-      result = node_result['result']
-
-      # If it's finished or already has a proper error simply pass it to the
-      # the result otherwise make sure an error is generated
-      if state == 'finished' || result['_error']
-        Bolt::Result.new(@target, value: result)
-      elsif state == 'skipped'
-        Bolt::Result.new(
-          @target,
-          value: { '_error' => {
-            'kind' => 'puppetlabs.tasks/skipped-node',
-            'msg' => "Node #{@target.host} was skipped",
-            'details' => {}
-          } }
-        )
-      else
-        # Make a generic error with a unkown exit_code
-        Bolt::Result.for_task(@target, result.to_json, '', 'unknown')
-      end
-    end
-
-    # run_task generates a result that makes sense for a generic task which
-    # needs to be unwrapped to extract stdout/stderr/exitcode.
-    #
-    def unwrap_bolt_result(result)
-      if result.error_hash
-        # something went wrong return the failure
-        return result
-      end
-
-      Bolt::Result.for_command(@target, result.value['stdout'], result.value['stderr'], result.value['exit_code'])
-    end
-
-    def run_command(command, _options = nil)
-      result = run_task(BOLT_MOCK_FILE,
-                        'stdin',
-                        action: 'command',
-                        command: command,
-                        options: {})
-      unwrap_bolt_result(result)
-    end
-
-    def upload(source, destination)
-      content = File.open(source, &:read)
-      content = Base64.encode64(content)
-      mode = File.stat(source).mode
-      params = {
-        action: 'upload',
-        path: destination,
-        content: content,
-        mode: mode
-      }
-      result = run_task(BOLT_MOCK_FILE, 'stdin', params)
-      result = Bolt::Result.for_upload(@target, source, destination) unless result.error_hash
-      result
-    end
-
-    def run_script(script, arguments, _options = nil)
-      content = File.open(script, &:read)
-      content = Base64.encode64(content)
-      params = {
-        action: 'script',
-        content: content,
-        arguments: arguments
-      }
-      unwrap_bolt_result(run_task(BOLT_MOCK_FILE, 'stdin', params))
-    end
-  end
-end