openbolt 5.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4b185096a836ebb48610140607f7cf3d9271f5ac4b849be866ba860bfb9bf39c
+  data.tar.gz: 7012bd8a0ef497bb28941fe60ce248a02ea0d6b521f72610258193ec352be3eb
+SHA512:
+  metadata.gz: 4ca129817353a9743ce4c2fe6252c155a7180f76f7a8520b3ff4262a5b3888598f7c2c1bc2f56825d22ead5329d6461b5e41004569335f55c7363f9b1e5e2f5a
+  data.tar.gz: 81ed93b16ff9acf1edb58604222d21e8ff37922d324df8083e89cf81201bf6782cbd3b62431cb85c8ecf924f26fb9a9cca89b21b2b8402c8a16fd5cc94644a8a

data/Puppetfile

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+forge 'https://forge.puppetlabs.com'
+
+moduledir File.join(File.dirname(__FILE__), 'modules')
+
+# Core modules used by 'apply'
+mod 'puppetlabs-service', '3.0.0'
+mod 'puppetlabs-puppet_agent', '4.21.0'
+mod 'puppetlabs-facts', '1.6.0'
+
+# Core types and providers for Puppet 6
+mod 'puppetlabs-augeas_core', '1.5.0'
+mod 'puppetlabs-host_core', '1.3.0'
+mod 'puppetlabs-scheduled_task', '4.0.0'
+mod 'puppetlabs-sshkeys_core', '2.5.0'
+mod 'puppetlabs-zfs_core', '1.6.1'
+mod 'puppetlabs-cron_core', '1.3.0'
+mod 'puppetlabs-mount_core', '1.3.0'
+mod 'puppetlabs-selinux_core', '1.4.0'
+mod 'puppetlabs-yumrepo_core', '2.1.0'
+mod 'puppetlabs-zone_core', '1.2.0'
+
+# Useful additional modules
+mod 'puppetlabs-package', '3.0.1'
+mod 'puppetlabs-puppet_conf', '2.0.0'
+mod 'puppetlabs-reboot', '5.0.0'
+mod 'puppetlabs-stdlib', '9.6.0'
+
+# Task helpers
+mod 'puppetlabs-powershell_task_helper', '0.1.0'
+mod 'puppetlabs-ruby_task_helper', '0.6.1'
+mod 'puppetlabs-ruby_plugin_helper', '0.2.0'
+mod 'puppetlabs-python_task_helper', '0.5.0'
+mod 'puppetlabs-bash_task_helper', '2.1.1'
+
+# Plugin modules
+mod 'puppetlabs-aws_inventory', '0.7.0'
+mod 'puppetlabs-azure_inventory', '0.5.0'
+mod 'puppetlabs-gcloud_inventory', '0.3.0'
+mod 'puppetlabs-http_request', '0.3.1'
+mod 'puppetlabs-pkcs7', '0.1.2'
+mod 'puppetlabs-secure_env_vars', '0.2.0'
+mod 'puppetlabs-terraform', '0.7.1'
+mod 'puppetlabs-vault', '0.4.0'
+mod 'puppetlabs-yaml', '0.2.0'
+
+# If we don't list these modules explicitly, r10k will purge them
+mod 'canary', local: true
+mod 'aggregate', local: true
+mod 'puppetdb_fact', local: true
+mod 'puppet_connect', local: true

data/bolt-modules/boltlib/lib/puppet/datatypes/applyresult.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# An [apply action](applying_manifest_blocks.md#return-value-of-apply-action)
+# returns an `ApplyResult`. An `ApplyResult` is part of a `ResultSet` object and
+# contains information about the apply action.
+#
+# @param report
+#   The Puppet report from the apply action. Equivalent to calling `ApplyResult.value['report']`.
+#   The report is a hash representation of the [`Puppet::Transaction::Report`
+#   object](https://puppet.com/docs/puppet/latest/format_report.html), where each property
+#   corresponds to a key in the report hash. For more information, see [Result
+#   keys](applying_manifest_blocks.md#result-keys).
+# @param target
+#   The target the result is from.
+# @param error
+#   An Error object constructed from the `_error` field of the result's value.
+# @param catalog
+#   The Puppet catalog used to configure the target. The catalog describes the
+#   desired state of the target. The catalog is masked with the `Sensitive` data
+#   type to protect any sensitive information in the catalog from being printed
+#   to the console or logs. Using this function automatically unwraps the
+#   catalog. For more information about catalogs and the catalog compilation
+#   process, see [Catalog
+#   compilation](https://puppet.com/docs/puppet/latest/subsystem_catalog_compilation.html).
+
+#
+# @!method action
+#   The action performed. `ApplyResult.action` always returns the string `apply`.
+# @!method message
+#   The `_output` field of the result's value.
+# @!method ok
+#   Whether the result was successful.
+# @!method to_data
+#   A serialized representation of `ApplyResult`.
+# @!method value
+#   A hash including the Puppet report from the apply action under a `report` key.
+#
+Puppet::DataTypes.create_type('ApplyResult') do
+  interface <<-PUPPET
+    attributes => {
+      'report' => Hash[String[1], Data],
+      'target' => Target,
+      'error' => Optional[Error],
+      'catalog' => Optional[Hash]
+    },
+    functions => {
+      ok => Callable[[], Boolean],
+      message => Callable[[], Optional[String]],
+      action => Callable[[], String],
+      to_data => Callable[[], Hash],
+      value => Callable[[], Hash]
+    }
+  PUPPET
+
+  load_file('bolt/apply_result')
+
+  # Needed for Puppet to recognize Bolt::ApplyResult as a Puppet object when deserializing
+  Bolt::ApplyResult.include(Puppet::Pops::Types::PuppetObject)
+  implementation_class Bolt::ApplyResult
+end

data/bolt-modules/boltlib/lib/puppet/datatypes/containerresult.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# The [run_container](plan_functions.md#run_container) plan function returns a
+# `ContainerResult` object. A `ContainerResult` is a standalone object (not part
+# of a `ResultSet`) that includes either the `stdout` and `stderr` values from
+# running the container, or an `_error` object if the container exited with a
+# nonzero exit code.
+#
+# @param value
+#   A hash including the `stdout`, `stderr`, and `exit_code` received from the
+#   container.
+#
+# @!method []
+#   Accesses the value hash directly and returns the value for the key. This
+#   function does not use dot notation. Call the function directly on the
+#   `ContainerResult`. For example, `$result[key]`.
+# @!method error
+#   An object constructed from the `_error` field of the result's value.
+# @!method ok
+#   Whether the result was successful.
+# @!method status
+#   Either `success` if the result was successful or `failure`.
+# @!method stdout
+#   The value of 'stdout' output by the container.
+# @!method stderr
+#   The value of 'stderr' output by the container.
+# @!method to_data
+#   A serialized representation of `ContainerResult`.
+#
+Puppet::DataTypes.create_type('ContainerResult') do
+  interface <<-PUPPET
+    attributes => {
+      'value' => Hash[String[1], Data],
+    },
+    functions => {
+      '[]' => Callable[[String[1]], Data],
+      error => Callable[[], Optional[Error]],
+      ok => Callable[[], Boolean],
+      status => Callable[[], String],
+      stdout => Callable[[], String],
+      stderr => Callable[[], String],
+      to_data => Callable[[], Hash]
+    }
+  PUPPET
+
+  load_file('bolt/container_result')
+
+  # Needed for Puppet to recognize Bolt::ContainerResult as a Puppet object when deserializing
+  Bolt::ContainerResult.include(Puppet::Pops::Types::PuppetObject)
+  implementation_class Bolt::ContainerResult
+end

data/bolt-modules/boltlib/lib/puppet/datatypes/future.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# The [`background()` plan function](plan_functions.md#background) returns a
+# `Future` object, which can be passed to the [`wait()` plan
+# function](plan_functions.md#wait) to block on the result of the backgrounded
+# code block.
+#
+# @!method state
+#   Either 'running' if the Future is still executing, 'done' if the Future
+#   finished successfully, or 'error' if the Future finished with an error.
+#
+Puppet::DataTypes.create_type('Future') do
+  interface <<-PUPPET
+    attributes => {},
+    functions => {
+      state => Callable[[], Enum['running', 'done', 'error']],
+    }
+  PUPPET
+
+  load_file('bolt/plan_future')
+
+  # Needed for Puppet to recognize Bolt::Result as a Puppet object when deserializing
+  Bolt::PlanFuture.include(Puppet::Pops::Types::PuppetObject)
+  implementation_class Bolt::PlanFuture
+end

data/bolt-modules/boltlib/lib/puppet/datatypes/resourceinstance.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# `ResourceInstance` objects are used to store the observed and desired state of a
+# target's resource and to track events for the resource. These objects do not
+# modify or interact with a target's resources.
+#
+# > The `ResourceInstance` data type is experimental and might change in a future
+# > release. You can learn more about this data type and how to use it in the
+# > [experimental features
+# > documentation](experimental_features.md#resourceinstance-data-type).
+#
+# @param events
+#   Events for the resource.
+# @param desired_state
+#   [Attributes](https://puppet.com/docs/puppet/latest/lang_resources.html#attributes) describing
+#   the desired state of the resource.
+# @param state
+#   [Attributes](https://puppet.com/docs/puppet/latest/lang_resources.html#attributes) describing
+#   the observed state of the resource.
+# @param target
+#   The resource's target.
+# @param title
+#   The [resource title](https://puppet.com/docs/puppet/latest/lang_resources.html#title).
+# @param type
+#   The [resource type](https://puppet.com/docs/puppet/latest/lang_resources.html#resource-types).
+#
+# @!method []
+#   Accesses the `state` hash directly and returns the value for the specified
+#   attribute. This function does not use dot noation. Call the function directly
+#   on the `ResourceInstance`. For example, `$resource['ensure']`.
+# @!method add_event(event)
+#   Add an event for the resource.
+# @!method overwrite_desired_state(desired_state)
+#   Overwrites the desired state of the resource.
+# @!method overwrite_state(state)
+#   Overwrites the observed state of the resource.
+# @!method set_desired_state(desired_state)
+#   Sets attributes describing the desired state of the resource. Performs a shallow
+#   merge with existing desired state.
+# @!method set_state(state)
+#   Sets attributes describing the observed state of the resource. Performs a shallow
+#   merge with existing state.
+# @!method reference
+#   The resources reference string. For example, `File[/etc/puppetlabs]`.
+#
+Puppet::DataTypes.create_type('ResourceInstance') do
+  interface <<-PUPPET
+    attributes => {
+      'target'        => Target,
+      'type'          => Variant[String[1], Type[Resource]],
+      'title'         => String[1],
+      'state'         => Optional[Hash[String[1], Data]],
+      'desired_state' => Optional[Hash[String[1], Data]],
+      'events'        => Optional[Array[Hash[String[1], Data]]]
+    },
+    functions => {
+      add_event               => Callable[[Hash[String[1], Data]], Array[Hash[String[1], Data]]],
+      set_state               => Callable[[Hash[String[1], Data]], Hash[String[1], Data]],
+      overwrite_state         => Callable[[Hash[String[1], Data]], Hash[String[1], Data]],
+      set_desired_state       => Callable[[Hash[String[1], Data]], Hash[String[1], Data]],
+      overwrite_desired_state => Callable[[Hash[String[1], Data]], Hash[String[1], Data]],
+      reference               => Callable[[], String],
+      '[]'                    => Callable[[String[1]], Data]
+    }
+  PUPPET
+
+  load_file('bolt/resource_instance')
+  # Needed for Puppet to recognize Bolt::ResourceInstance as a Puppet object when deserializing
+  Bolt::ResourceInstance.include(Puppet::Pops::Types::PuppetObject)
+  implementation_class Bolt::ResourceInstance
+end

data/bolt-modules/boltlib/lib/puppet/datatypes/result.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# For each target that you execute an action on, Bolt returns a `Result` object
+# and adds the `Result` to a `ResultSet` object. A `Result` object contains
+# information about the action you executed on the target.
+#
+# @param target
+#   The target the result is from.
+# @param value
+#   The output or return of executing on the target.
+#
+# @!method []
+#   Accesses the `value` hash directly and returns the value for the key. This
+#   function does not use dot notation. Call the function directly on the `Result`.
+#   For example, `$result['key']`.
+# @!method action
+#   The type of result. For example, `task` or `command`.
+# @!method error
+#   An object constructed from the `_error` field of the result's `value`.
+# @!method message
+#   The `_output` field of the result's value.
+# @!method ok
+#   Whether the result was successful.
+# @!method sensitive
+#   The `_sensitive` field of the result's value, wrapped in a `Sensitive` object.
+#   Call `unwrap()` to extract the value.
+# @!method status
+#   Either `success` if the result was successful or `failure`.
+# @!method to_data
+#   A serialized representation of `Result`.
+#
+Puppet::DataTypes.create_type('Result') do
+  interface <<-PUPPET
+    attributes => {
+      'value' => Hash[String[1], Data],
+      'target' => Target
+    },
+    functions => {
+      error => Callable[[], Optional[Error]],
+      message => Callable[[], Optional[String]],
+      sensitive => Callable[[], Optional[Sensitive[Data]]],
+      action => Callable[[], String],
+      status => Callable[[], String],
+      to_data => Callable[[], Hash],
+      ok => Callable[[], Boolean],
+      '[]' => Callable[[String[1]], Variant[Data, Sensitive[Data]]]
+    }
+  PUPPET
+
+  load_file('bolt/result')
+
+  # Needed for Puppet to recognize Bolt::Result as a Puppet object when deserializing
+  Bolt::Result.include(Puppet::Pops::Types::PuppetObject)
+  implementation_class Bolt::Result
+end

data/bolt-modules/boltlib/lib/puppet/datatypes/resultset.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# For each target that you execute an action on, Bolt returns a `Result` object
+# and adds the `Result` to a `ResultSet` object. In the case of [apply
+# actions](applying_manifest_blocks.md), Bolt returns a `ResultSet` with one or
+# more `ApplyResult` objects.
+#
+# @param results
+#   All results in the set.
+#
+# @!method []
+#   The accessed results. This function does not use dot notation. Call the
+#   function directly on the `ResultSet`. For example, `$results[0]`.
+# @!method count
+#   The number of results in the set.
+# @!method empty
+#   Whether the set is empty.
+# @!method error_set
+#   The set of failing results.
+# @!method filter_set
+#   Filters a set of results by the contents of the block.
+# @!method find(target_name)
+#   Retrieves a result for a specified target.
+# @!method first
+#   The first result in the set. Useful for unwrapping single results.
+# @!method names
+#   The names of all targets that have a `Result` in the set.
+# @!method ok
+#   Whether all results were successful. Equivalent to `$results.error_set.empty`.
+# @!method ok_set
+#   The set of successful results.
+# @!method targets
+#   The list of targets that have results in the set.
+# @!method to_data
+#   An array of serialized representations of each result in the set.
+#
+Puppet::DataTypes.create_type('ResultSet') do
+  interface <<-PUPPET
+    attributes => {
+      'results' => Array[Variant[Result, ApplyResult]],
+    },
+    functions => {
+      count => Callable[[], Integer],
+      empty => Callable[[], Boolean],
+      error_set => Callable[[], ResultSet],
+      filter_set => Callable[[Callable], ResultSet],
+      find => Callable[[String[1]], Optional[Variant[Result, ApplyResult]]],
+      first => Callable[[], Optional[Variant[Result, ApplyResult]]],
+      names => Callable[[], Array[String[1]]],
+      ok => Callable[[], Boolean],
+      ok_set => Callable[[], ResultSet],
+      targets => Callable[[], Array[Target]],
+      to_data => Callable[[], Array[Hash]],
+      '[]' => Variant[Callable[[Integer], Optional[Variant[Result, ApplyResult, Array[Variant[Result, ApplyResult]]]]],
+                      Callable[[Integer, Integer], Optional[Variant[Result, ApplyResult, Array[Variant[Result, ApplyResult]]]]]
+                     ]
+    }
+  PUPPET
+
+  load_file('bolt/result_set')
+
+  # Needed for Puppet to recognize Bolt::ResultSet as a Puppet object when deserializing
+  Bolt::ResultSet.include(Puppet::Pops::Types::PuppetObject)
+  implementation_class Bolt::ResultSet
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# The `Target` object represents a target and its specific connection options.
+#
+# @param config
+#   The inventory configuration for the target. This function returns the
+#   configuration set directly on the target in `inventory.yaml` or set in
+#   a plan using `Target.new` or `set_config()`. It does not return default
+#   configuration values or configuration set in Bolt configuration files.
+# @param facts
+#   The target's facts. This function does not look up facts for a target and
+#   only returns the facts specified in an `inventory.yaml` file or set on a
+#   target during a plan run. To retrieve facts for a target and set them in
+#   inventory, run the [facts](writing_plans.md#collect-facts-from-targets)
+#   plan or [puppetdb_fact](writing_plans.md#collect-facts-from-puppetdb)
+#   plan.
+# @param features
+#   The target's features.
+# @param name
+#   The target's human-readable name, or its URI if a name was not given.
+# @param plugin_hooks
+#   The target's `plugin_hooks` [configuration
+#   options](bolt_inventory_reference.md#plugin-hooks-1).
+# @param resources
+#   The target's resources. This function does not look up resources for a
+#   target and only returns resources set on a target during a plan run.
+# @param safe_name
+#   The target's safe name. Equivalent to `name` if a name was given, or the
+#   target's `uri` with any password omitted.
+# @param target_alias
+#   The target's aliases.
+# @param uri
+#   The target's URI.
+# @param vars
+#   The target's variables.
+#
+# @!method host
+#   The target's hostname.
+# @!method password
+#   The password to use when connecting to the target.
+# @!method port
+#   The target's connection port.
+# @!method protocol
+#   The protocol used to connect to the target. This is equivalent to the target's
+#   `transport`, expect for targets using the `remote` transport. For example,
+#   a target with the URI `http://example.com` using the `remote` transport would
+#   return `http` for the `protocol`.
+# @!method transport
+#   The transport used to connect to the target.
+# @!method transport_config
+#   The merged configuration for the target's `transport`. This function returns
+#   configuration that includes defaults set by Bolt, configuration set in
+#   `inventory.yaml`, configuration set in `bolt-defaults.yaml`, and configuration
+#   set in a plan using `set_config()`.
+# @!method user
+#   The user to connect to the target.
+#
+Puppet::DataTypes.create_type('Target') do
+  begin
+    inventory = Puppet.lookup(:bolt_inventory)
+    target_implementation_class = inventory.target_implementation_class
+  rescue Puppet::Context::UndefinedBindingError
+    target_implementation_class = Bolt::Target
+  end
+
+  interface <<-PUPPET
+    attributes => {
+      uri => { type => Optional[String[1]], kind => given_or_derived },
+      name => { type => Optional[String[1]] , kind => given_or_derived },
+      safe_name => { type =>  Optional[String[1]], kind => given_or_derived },
+      target_alias => { type => Optional[Variant[String[1], Array[String[1]]]], kind => given_or_derived },
+      config => { type => Optional[Hash[String[1], Data]], kind => given_or_derived },
+      vars => { type => Optional[Hash[String[1], Data]], kind => given_or_derived },
+      facts => { type => Optional[Hash[String[1], Data]], kind => given_or_derived },
+      features => { type => Optional[Array[String[1]]], kind => given_or_derived },
+      plugin_hooks => { type => Optional[Hash[String[1], Data]], kind => given_or_derived },
+      resources => { type => Optional[Hash[String[1], ResourceInstance]], kind => given_or_derived }
+    },
+    functions => {
+      host => Callable[[], Optional[String]],
+      password => Callable[[], Optional[String[1]]],
+      port => Callable[[], Optional[Integer]],
+      protocol => Callable[[], Optional[String[1]]],
+      transport => Callable[[], String[1]],
+      transport_config => Callable[[], Hash[String[1], Data]],
+      user => Callable[[], Optional[String[1]]]
+    }
+  PUPPET
+
+  # Needed for Puppet to recognize targets as Puppet objects when deserializing
+  target_implementation_class.include(Puppet::Pops::Types::PuppetObject)
+  implementation_class target_implementation_class
+end

data/bolt-modules/boltlib/lib/puppet/functions/add_facts.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Deep merges a hash of facts with the existing facts on a target.
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:add_facts) do
+  # @param target A target.
+  # @param facts A hash of fact names to values that can include structured facts.
+  # @return A `Target` object.
+  # @example Adding facts to a target
+  #   add_facts($target, { 'os' => { 'family' => 'windows', 'name' => 'windows' } })
+  dispatch :add_facts do
+    param 'Target', :target
+    param 'Hash', :facts
+    return_type 'Target'
+  end
+
+  def add_facts(target, facts)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'add_facts')
+    end
+
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    # Send Analytics Report
+    executor.report_function_call(self.class.name)
+
+    inventory.add_facts(target, facts)
+  end
+end

data/bolt-modules/boltlib/lib/puppet/functions/add_to_group.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Adds a target to specified inventory group.
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:add_to_group) do
+  # @param targets A pattern or array of patterns identifying a set of targets.
+  # @param group The name of the group to add targets to.
+  # @return [Array[Target]] The targets.
+  # @example Add new Target to group.
+  #   Target.new('foo@example.com', 'password' => 'secret').add_to_group('group1')
+  # @example Add new target to group by name.
+  #   add_to_group('bolt:bolt@web.com', 'group1')
+  # @example Add an array of targets to group by name.
+  #   add_to_group(['host1', 'group1', 'winrm://host2:54321'], 'group1')
+  # @example Add a comma separated list list of targets to group by name.
+  #   add_to_group('foo,bar,baz', 'group1')
+  dispatch :add_to_group do
+    param 'Boltlib::TargetSpec', :targets
+    param 'String[1]', :group
+  end
+
+  def add_to_group(targets, group)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'add_to_group')
+    end
+
+    inventory = Puppet.lookup(:bolt_inventory)
+    executor = Puppet.lookup(:bolt_executor)
+    # Send Analytics Report
+    executor.report_function_call(self.class.name)
+
+    inventory.add_to_group(inventory.get_targets(targets), group)
+  end
+end