bolt 0.0.1 → 0.5.0

data/vendored/puppet/lib/puppet/functions/run_plan.rb

@@ -0,0 +1,40 @@
+# Runs the `plan` referenced by its name passing giving arguments to it given as a hash of name to value mappings
+# A plan is autoloaded from under <root>/plans if not already defined.
+#
+# @example defining and running a plan
+#   plan myplan($x) { 
+#     # do things with tasks
+#     notice "plan done with param x = ${x}"
+#   }
+#   run_plan('myplan', {x => 'testing' }
+#
+# @since > 5.2 TODO: change this when known
+#
+Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction) do
+  dispatch :run_plan do
+    scope_param
+    param 'String', :plan_name
+    optional_param 'Hash', :named_args
+  end
+
+  def run_plan(scope, plan_name, named_args = {})
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+        {:operation => 'run_plan'})
+    end
+
+    loaders = closure_scope.compiler.loaders
+    # The perspective of the environment is wanted here (for now) to not have to require modules
+    # to have dependencies defined in meta data.
+    loader = loaders.private_environment_loader
+    if loader && func = loader.load(:plan, plan_name)
+      # TODO: Add profiling around this
+        return func.class.dispatcher.dispatchers[0].call_by_name_with_scope(scope, named_args, true)
+    end
+    # Could not find plan
+    raise ArgumentError, "Function #{self.class.name}(): Unknown plan: '#{plan_name}'"
+  end
+
+end
+

data/vendored/puppet/lib/puppet/functions/run_script.rb

@@ -0,0 +1,50 @@
+# Uploads the given script to the given set of nodes and returns the result of having each node execute the script.
+#
+# * This function does nothing if the list of nodes is empty.
+# * It is possible to run on the node 'localhost'
+# * A node is a String with a node's hostname or a URI that also describes how to connect and run the task on that node
+#   including "user" and "password" parts of a URI.
+# * The returned value contains information about the result per node. TODO: needs mapping to a runtime Pcore Object to be useful
+#
+#
+# Since > 5.4.0 TODO: Update when version is known
+#
+Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFunction) do
+  local_types do
+    type 'NodeOrNodes = Variant[String[1], Array[NodeOrNodes]]'
+  end
+
+  dispatch :run_script do
+    scope_param
+    param 'String[1]', :script
+    repeated_param 'NodeOrNodes', :nodes
+  end
+
+  def run_script(scope, script, *nodes)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+        {:operation => 'run_script'})
+    end
+
+    unless Puppet.features.bolt?
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::TASK_MISSING_BOLT, :action => _('run a script'))
+    end
+
+    found = Puppet::Parser::Files.find_file(script, scope.compiler.environment)
+    unless found && Puppet::FileSystem.exist?(found)
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, {:file => script})
+    end
+    unless Puppet::FileSystem.file?(found)
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::NOT_A_FILE, {:file => script})
+    end
+
+    hosts = nodes.flatten
+    if hosts.empty?
+      call_function('debug', "Simulating run_script of '#{found}' - no hosts given - no action taken")
+      Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
+    else
+      Puppet::Pops::Types::ExecutionResult.from_bolt(Bolt::Executor.from_uris(hosts).run_script(found))
+    end
+  end
+end

data/vendored/puppet/lib/puppet/functions/run_task.rb

@@ -0,0 +1,73 @@
+# Runs a given instance of a `Task` on the given set of nodes and returns the result from each.
+#
+# * This function does nothing if the list of nodes is empty.
+# * It is possible to run on the node 'localhost'
+# * A node is a String with a node's hostname or a URI that also describes how to connect and run the task on that node
+#   including "user" and "password" parts of a URI.
+# * The returned value contains information about the result per node. TODO: needs mapping to a runtime Pcore Object to be useful
+#
+#
+# Since > 5.4.0 TODO: Update when version is known
+#
+Puppet::Functions.create_function(:run_task) do
+  local_types do
+    type 'NodeOrNodes = Variant[String[1], Array[NodeOrNodes]]'
+  end
+
+  dispatch :run_task_type do
+    param 'Type[Task]', :task_type
+    param 'NodeOrNodes', :nodes
+    optional_param 'Hash[String[1], Any]', :task_args
+  end
+
+  dispatch :run_named_task do
+    param 'String[1]', :task_type
+    param 'NodeOrNodes', :nodes
+    optional_param 'Hash[String[1], Any]', :task_args
+  end
+
+  dispatch :run_task_instance do
+    param 'Task', :task
+    repeated_param 'NodeOrNodes', :nodes
+  end
+
+  def run_task_type(task_type, nodes, task_args = nil)
+    use_args = task_args.nil? ? {} : task_args
+    task_instance = call_function('new', task_type, use_args)
+    run_task_instance(task_instance, nodes)
+  end
+
+  def run_named_task(task_name, nodes, task_args = nil)
+    task_type = Puppet.lookup(:loaders).private_environment_loader.load(:type, task_name)
+    if task_type.nil?
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::UNKNOWN_TASK, :type_name => task_name)
+    end
+    use_args = task_args.nil? ? {} : task_args
+    task_instance = call_function('new', task_type, use_args)
+    run_task_instance(task_instance, nodes)
+  end
+
+  def run_task_instance(task, *nodes)
+    hosts = nodes.flatten
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+        {:operation => 'run_task'})
+    end
+
+    unless Puppet.features.bolt?
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(Puppet::Pops::Issues::TASK_MISSING_BOLT, :action => _('run a task'))
+    end
+
+    if hosts.empty?
+      call_function('debug', "Simulating run of task #{task._pcore_type.name} - no hosts given - no action taken")
+      Puppet::Pops::Types::ExecutionResult::EMPTY_RESULT
+    else
+      # TODO: separate handling of default since it's platform specific
+      input_method = task._pcore_type['input_method'].value
+
+      arguments = task.task_args
+      Puppet::Pops::Types::ExecutionResult.from_bolt(Bolt::Executor.from_uris(hosts).run_task(task.executable_path, input_method, arguments))
+    end
+  end
+end

data/vendored/puppet/lib/puppet/functions/scanf.rb

@@ -0,0 +1,44 @@
+# Scans a string and returns an array of one or more converted values based on the given format string.
+# See the documentation of Ruby's String#scanf method for details about the supported formats (which
+# are similar but not identical to the formats used in Puppet's `sprintf` function.)
+#
+# This function takes two mandatory arguments: the first is the string to convert, and the second is
+# the format string. The result of the scan is an array, with each successfully scanned and transformed value.
+# The scanning stops if a scan is unsuccessful, and the scanned result up to that point is returned. If there
+# was no successful scan, the result is an empty array.
+#
+#    "42".scanf("%i")
+#
+# You can also optionally pass a lambda to scanf, to do additional validation or processing.
+#
+#
+#     "42".scanf("%i") |$x| {
+#       unless $x[0] =~ Integer {
+#         fail "Expected a well formed integer value, got '$x[0]'"
+#       }
+#       $x[0]
+#     }
+#
+#
+#
+#
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:scanf) do
+  require 'scanf'
+
+  dispatch :scanf do
+    param 'String', :data
+    param 'String', :format
+    optional_block_param
+  end
+
+  def scanf(data, format)
+    result = data.scanf(format)
+    if block_given?
+      result = yield(result)
+    end
+    result
+  end
+end

data/vendored/puppet/lib/puppet/functions/slice.rb

@@ -0,0 +1,111 @@
+# This function takes two mandatory arguments: the first should be an array or hash, and the second specifies
+# the number of elements to include in each slice.
+#
+# When the first argument is a hash, each key value pair is counted as one. For example, a slice size of 2 will produce
+# an array of two arrays with key, and value.
+#
+#     $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
+#     $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
+#
+# The function produces a concatenated result of the slices.
+#
+#     slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
+#     slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
+#     slice(4,2)              # produces [[0,1], [2,3]]
+#     slice('hello',2)        # produces [[h, e], [l, l], [o]]
+#
+#
+# You can also optionally pass a lambda to slice.
+#
+#     $a.slice($n) |$x| { ... }
+#     slice($a) |$x| { ... }
+#
+# The lambda should have either one parameter (receiving an array with the slice), or the same number
+# of parameters as specified by the slice size (each parameter receiving its part of the slice).
+# If there are fewer remaining elements than the slice size for the last slice, it will contain the remaining
+# elements. If the lambda has multiple parameters, excess parameters are set to undef for an array, or
+# to empty arrays for a hash.
+#
+#     $a.slice(2) |$first, $second| { ... }
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:slice) do
+  dispatch :slice_Hash do
+    param 'Hash[Any, Any]', :hash
+    param 'Integer[1, default]', :slice_size
+    optional_block_param
+  end
+
+  dispatch :slice_Enumerable do
+    param 'Iterable', :enumerable
+    param 'Integer[1, default]', :slice_size
+    optional_block_param
+  end
+
+  def slice_Hash(hash, slice_size, &pblock)
+    result = slice_Common(hash, slice_size, [], block_given? ? pblock : nil)
+    block_given? ? hash : result
+  end
+
+  def slice_Enumerable(enumerable, slice_size, &pblock)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    result = slice_Common(enum, slice_size, nil, block_given? ? pblock : nil)
+    block_given? ? enumerable : result
+  end
+
+  def slice_Common(o, slice_size, filler, pblock)
+    serving_size = asserted_slice_serving_size(pblock, slice_size)
+
+    enumerator = o.each_slice(slice_size)
+    result = []
+    if serving_size == 1
+      begin
+        if pblock
+          loop do
+            pblock.call(enumerator.next)
+          end
+        else
+          loop do
+            result << enumerator.next
+          end
+        end
+      rescue StopIteration
+      end
+    else
+      begin
+        loop do
+          a = enumerator.next
+          if a.size < serving_size
+            a = a.dup.fill(filler, a.length...serving_size)
+          end
+          pblock.call(*a)
+        end
+      rescue StopIteration
+      end
+    end
+    if pblock
+      o
+    else
+      result
+    end
+  end
+
+  def asserted_slice_serving_size(pblock, slice_size)
+    if pblock
+      arity = pblock.arity
+      serving_size = arity < 0 ? slice_size : arity
+    else
+      serving_size = 1
+    end
+    if serving_size == 0
+      raise ArgumentError, _("slice(): block must define at least one parameter. Block has 0.")
+    end
+    unless serving_size == 1 || serving_size == slice_size
+      raise ArgumentError, _("slice(): block must define one parameter, or ") +
+        _("the same number of parameters as the given size of the slice (%{slice_size}). Block has %{serving_size}; ") % { slice_size: slice_size, serving_size: serving_size }+
+      pblock.parameter_names.join(', ')
+    end
+    serving_size
+  end
+end

data/vendored/puppet/lib/puppet/functions/split.rb

@@ -0,0 +1,47 @@
+# Split a string variable into an array using the specified pattern.
+# The pattern can be a string, regexp or regexp type.
+#
+# @example
+#
+#     $string     = 'v1.v2:v3.v4'
+#     $array_var1 = split($string, /:/)
+#     $array_var2 = split($string, '[.]')
+#     $array_var3 = split($string, Regexp['[.:]'])
+#
+# `$array_var1` now holds the result `['v1.v2', 'v3.v4']`,
+# while `$array_var2` holds `['v1', 'v2:v3', 'v4']`, and
+# `$array_var3` holds `['v1', 'v2', 'v3', 'v4']`.
+#
+# Note that in the second example, we split on a literal string that contains
+# a regexp meta-character (.), which must be escaped.  A simple
+# way to do that for a single character is to enclose it in square
+# brackets; a backslash will also escape a single character.
+#
+Puppet::Functions.create_function(:split) do
+  dispatch :split_String do
+    param 'String', :str
+    param 'String', :pattern
+  end
+
+  dispatch :split_Regexp do
+    param 'String', :str
+    param 'Regexp', :pattern
+  end
+
+  dispatch :split_RegexpType do
+    param 'String', :str
+    param 'Type[Regexp]', :pattern
+  end
+
+  def split_String(str, pattern)
+    str.split(Regexp.compile(pattern))
+  end
+
+  def split_Regexp(str, pattern)
+    str.split(pattern)
+  end
+
+  def split_RegexpType(str, pattern)
+    str.split(pattern.regexp)
+  end
+end

data/vendored/puppet/lib/puppet/functions/step.rb

@@ -0,0 +1,26 @@
+# (Documentation in 3.x stub)
+#
+# @since 4.4.0
+#
+Puppet::Functions.create_function(:step) do
+  dispatch :step do
+    param 'Iterable', :iterable
+    param 'Integer[1]', :step
+  end
+
+  dispatch :step_block do
+    param 'Iterable', :iterable
+    param 'Integer[1]', :step
+    block_param 'Callable[1,1]', :block
+  end
+
+  def step(iterable, step)
+    # produces an Iterable
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step)
+  end
+
+  def step_block(iterable, step, &block)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step, &block)
+    nil
+  end
+end

data/vendored/puppet/lib/puppet/functions/strftime.rb

@@ -0,0 +1,43 @@
+# (Documentation in 3.x stub)
+#
+# @since 4.8.0
+#
+Puppet::Functions.create_function(:strftime) do
+  dispatch :format_timespan do
+    param 'Timespan', :time_object
+    param 'String', :format
+  end
+
+  dispatch :format_timestamp do
+    param 'Timestamp', :time_object
+    param 'String', :format
+    optional_param 'String', :timezone
+  end
+
+  dispatch :legacy_strftime do
+    param 'String', :format
+    optional_param 'String', :timezone
+  end
+
+  def format_timespan(time_object, format)
+    time_object.format(format)
+  end
+
+  def format_timestamp(time_object, format, timezone = nil)
+    time_object.format(format, timezone)
+  end
+
+  def legacy_strftime(format, timezone = nil)
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+    Puppet.warn_once('deprecations', 'legacy#strftime',
+      _('The argument signature (String format, [String timezone]) is deprecated for #strfime. See #strftime documentation and Timespan type for more info'),
+      file, line)
+    Puppet::Pops::Time::Timestamp.format_time(format, Time.now.utc, timezone)
+  end
+end

data/vendored/puppet/lib/puppet/functions/then.rb

@@ -0,0 +1,14 @@
+# (Documented in 3.x stub)
+# @since 4.5.0
+#
+Puppet::Functions.create_function(:then) do
+  dispatch :then do
+    param 'Any', :arg
+    block_param 'Callable[1,1]', :block
+  end
+
+  def then(arg)
+    return nil if arg.nil?
+    yield(arg)
+  end
+end