openvox 8.19.0

data/lib/puppet/type/filebucket.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Puppet
+  require_relative '../../puppet/file_bucket/dipper'
+
+  Type.newtype(:filebucket) do
+    @doc = <<-EOT
+      A repository for storing and retrieving file content by cryptographic checksum. Can
+      be local to each agent node, or centralized on a primary Puppet server. All
+      puppet servers provide a filebucket service that agent nodes can access
+      via HTTP, but you must declare a filebucket resource before any agents
+      will do so.
+
+      Filebuckets are used for the following features:
+
+      - **Content backups.** If the `file` type's `backup` attribute is set to
+        the name of a filebucket, Puppet will back up the _old_ content whenever
+        it rewrites a file; see the documentation for the `file` type for more
+        details. These backups can be used for manual recovery of content, but
+        are more commonly used to display changes and differences in a tool like
+        Puppet Dashboard.
+
+      To use a central filebucket for backups, you will usually want to declare
+      a filebucket resource and a resource default for the `backup` attribute
+      in site.pp:
+
+          # /etc/puppetlabs/puppet/manifests/site.pp
+          filebucket { 'main':
+            path   => false,                # This is required for remote filebuckets.
+            server => 'puppet.example.com', # Optional; defaults to the configured primary server.
+          }
+
+          File { backup => main, }
+
+      Puppet Servers automatically provide the filebucket service, so
+      this will work in a default configuration. If you have a heavily
+      restricted Puppet Server `auth.conf` file, you may need to allow access to the
+      `file_bucket_file` endpoint.
+    EOT
+
+    newparam(:name) do
+      desc "The name of the filebucket."
+      isnamevar
+    end
+
+    newparam(:server) do
+      desc "The server providing the remote filebucket service.
+
+        This setting is _only_ consulted if the `path` attribute is set to `false`.
+
+        If this attribute is not specified, the first entry in the `server_list`
+        configuration setting is used, followed by the value of the `server` setting
+        if `server_list` is not set."
+    end
+
+    newparam(:port) do
+      desc "The port on which the remote server is listening.
+
+        This setting is _only_ consulted if the `path` attribute is set to `false`.
+
+        If this attribute is not specified, the first entry in the `server_list`
+        configuration setting is used, followed by the value of the `serverport`
+        setting if `server_list` is not set."
+    end
+
+    newparam(:path) do
+      desc "The path to the _local_ filebucket; defaults to the value of the
+        `clientbucketdir` setting.  To use a remote filebucket, you _must_ set
+        this attribute to `false`."
+
+      defaultto { Puppet[:clientbucketdir] }
+
+      validate do |value|
+        if value.is_a? Array
+          raise ArgumentError, _("You can only have one filebucket path")
+        end
+
+        if value.is_a? String and !Puppet::Util.absolute_path?(value)
+          raise ArgumentError, _("Filebucket paths must be absolute")
+        end
+
+        true
+      end
+    end
+
+    # Create a default filebucket.
+    def self.mkdefaultbucket
+      new(:name => "puppet", :path => Puppet[:clientbucketdir])
+    end
+
+    def bucket
+      mkbucket unless defined?(@bucket)
+      @bucket
+    end
+
+    private
+
+    def mkbucket
+      # Default is a local filebucket, if no server is given.
+      # If the default path has been removed, too, then
+      # the puppetmaster is used as default server
+
+      type = "local"
+      args = {}
+      if self[:path]
+        args[:Path] = self[:path]
+      else
+        args[:Server] = self[:server]
+        args[:Port] = self[:port]
+      end
+
+      begin
+        @bucket = Puppet::FileBucket::Dipper.new(args)
+      rescue => detail
+        message = _("Could not create %{type} filebucket: %{detail}") % { type: type, detail: detail }
+        log_exception(detail, message)
+        self.fail(message)
+      end
+
+      @bucket.name = name
+    end
+  end
+end

data/lib/puppet/type/group.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'etc'
+require_relative '../../puppet/property/keyvalue'
+require_relative '../../puppet/parameter/boolean'
+
+module Puppet
+  Type.newtype(:group) do
+    @doc = "Manage groups. On most platforms this can only create groups.
+      Group membership must be managed on individual users.
+
+      On some platforms such as OS X, group membership is managed as an
+      attribute of the group, not the user record. Providers must have
+      the feature 'manages_members' to manage the 'members' property of
+      a group record."
+
+    feature :manages_members,
+            "For directories where membership is an attribute of groups not users."
+
+    feature :manages_aix_lam,
+            "The provider can manage AIX Loadable Authentication Module (LAM) system."
+
+    feature :system_groups,
+            "The provider allows you to create system groups with lower GIDs."
+
+    feature :manages_local_users_and_groups,
+            "Allows local groups to be managed on systems that also use some other
+       remote Name Switch Service (NSS) method of managing accounts."
+
+    ensurable do
+      desc "Create or remove the group."
+
+      newvalue(:present) do
+        provider.create
+      end
+
+      newvalue(:absent) do
+        provider.delete
+      end
+
+      defaultto :present
+    end
+
+    newproperty(:gid) do
+      desc "The group ID.  Must be specified numerically.  If no group ID is
+        specified when creating a new group, then one will be chosen
+        automatically according to local system standards. This will likely
+        result in the same group having different GIDs on different systems,
+        which is not recommended.
+
+        On Windows, this property is read-only and will return the group's security
+        identifier (SID)."
+
+      def retrieve
+        provider.gid
+      end
+
+      def sync
+        if should == :absent
+          raise Puppet::DevError, _("GID cannot be deleted")
+        else
+          provider.gid = should
+        end
+      end
+
+      munge do |gid|
+        case gid
+        when String
+          if gid =~ /^[-0-9]+$/
+            gid = Integer(gid)
+          else
+            self.fail _("Invalid GID %{gid}") % { gid: gid }
+          end
+        when Symbol
+          unless gid == :absent
+            devfail "Invalid GID #{gid}"
+          end
+        end
+
+        return gid
+      end
+    end
+
+    newproperty(:members, :array_matching => :all, :required_features => :manages_members) do
+      desc "The members of the group. For platforms or directory services where group
+        membership is stored in the group objects, not the users. This parameter's
+        behavior can be configured with `auth_membership`."
+
+      def change_to_s(currentvalue, newvalue)
+        newvalue = actual_should(currentvalue, newvalue)
+
+        currentvalue = currentvalue.join(",") if currentvalue != :absent
+        newvalue = newvalue.join(",")
+        super(currentvalue, newvalue)
+      end
+
+      def insync?(current)
+        if provider.respond_to?(:members_insync?)
+          return provider.members_insync?(current, @should)
+        end
+
+        super(current)
+      end
+
+      def is_to_s(currentvalue) # rubocop:disable Naming/PredicateName
+        if provider.respond_to?(:members_to_s)
+          currentvalue = '' if currentvalue.nil?
+          currentvalue = currentvalue.is_a?(Array) ? currentvalue : currentvalue.split(',')
+
+          return provider.members_to_s(currentvalue)
+        end
+
+        super(currentvalue)
+      end
+
+      def should_to_s(newvalue)
+        is_to_s(actual_should(retrieve, newvalue))
+      end
+
+      # Calculates the actual should value given the current and
+      # new values. This is only used in should_to_s and change_to_s
+      # to fix the change notification issue reported in PUP-6542.
+      def actual_should(currentvalue, newvalue)
+        currentvalue = munge_members_value(currentvalue)
+        newvalue = munge_members_value(newvalue)
+
+        if @resource[:auth_membership]
+          newvalue.uniq.sort
+        else
+          (currentvalue + newvalue).uniq.sort
+        end
+      end
+
+      # Useful helper to handle the possible property value types that we can
+      # both pass-in and return. It munges the value into an array
+      def munge_members_value(value)
+        return [] if value == :absent
+        return value.split(',') if value.is_a?(String)
+
+        value
+      end
+
+      validate do |value|
+        if provider.respond_to?(:member_valid?)
+          return provider.member_valid?(value)
+        end
+      end
+    end
+
+    newparam(:auth_membership, :boolean => true, :parent => Puppet::Parameter::Boolean) do
+      desc "Configures the behavior of the `members` parameter.
+
+        * `false` (default) --- The provided list of group members is partial,
+          and Puppet **ignores** any members that aren't listed there.
+        * `true` --- The provided list of of group members is comprehensive, and
+          Puppet **purges** any members that aren't listed there."
+      defaultto false
+    end
+
+    newparam(:name) do
+      desc "The group name. While naming limitations vary by operating system,
+        it is advisable to restrict names to the lowest common denominator,
+        which is a maximum of 8 characters beginning with a letter.
+
+        Note that Puppet considers group names to be case-sensitive, regardless
+        of the platform's own rules; be sure to always use the same case when
+        referring to a given group."
+      isnamevar
+    end
+
+    newparam(:allowdupe, :boolean => true, :parent => Puppet::Parameter::Boolean) do
+      desc "Whether to allow duplicate GIDs."
+
+      defaultto false
+    end
+
+    newparam(:ia_load_module, :required_features => :manages_aix_lam) do
+      desc "The name of the I&A module to use to manage this group.
+        This should be set to `files` if managing local groups."
+    end
+
+    newproperty(:attributes, :parent => Puppet::Property::KeyValue, :required_features => :manages_aix_lam) do
+      desc "Specify group AIX attributes, as an array of `'key=value'` strings. This
+        parameter's behavior can be configured with `attribute_membership`."
+
+      self.log_only_changed_or_new_keys = true
+
+      def membership
+        :attribute_membership
+      end
+
+      def delimiter
+        " "
+      end
+    end
+
+    newparam(:attribute_membership) do
+      desc "AIX only. Configures the behavior of the `attributes` parameter.
+
+        * `minimum` (default) --- The provided list of attributes is partial, and Puppet
+          **ignores** any attributes that aren't listed there.
+        * `inclusive` --- The provided list of attributes is comprehensive, and
+          Puppet **purges** any attributes that aren't listed there."
+
+      newvalues(:inclusive, :minimum)
+
+      defaultto :minimum
+    end
+
+    newparam(:system, :boolean => true, :parent => Puppet::Parameter::Boolean) do
+      desc "Whether the group is a system group with lower GID."
+
+      defaultto false
+    end
+
+    newparam(:forcelocal, :boolean => true,
+                          :required_features => :manages_local_users_and_groups,
+                          :parent => Puppet::Parameter::Boolean) do
+      desc "Forces the management of local accounts when accounts are also
+            being managed by some other Name Switch Service (NSS). For AIX, refer to the `ia_load_module` parameter.
+
+            This option relies on your operating system's implementation of `luser*` commands, such as `luseradd` , `lgroupadd`, and `lusermod`. The `forcelocal` option could behave unpredictably in some circumstances. If the tools it depends on are not available, it might have no effect at all."
+      defaultto false
+    end
+
+    # This method has been exposed for puppet to manage users and groups of
+    # files in its settings and should not be considered available outside of
+    # puppet.
+    #
+    # (see Puppet::Settings#service_group_available?)
+    #
+    # @return [Boolean] if the group exists on the system
+    # @api private
+    def exists?
+      provider.exists?
+    end
+  end
+end

data/lib/puppet/type/notify.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+#
+# Simple module for logging messages on the client-side
+
+module Puppet
+  Type.newtype(:notify) do
+    @doc = "Sends an arbitrary message, specified as a string, to the agent run-time log. It's important to note that the notify resource type is not idempotent. As a result, notifications are shown as a change on every Puppet run."
+
+    apply_to_all
+
+    newproperty(:message, :idempotent => false) do
+      desc "The message to be sent to the log. Note that the value specified must be a string."
+      def sync
+        message = @sensitive ? 'Sensitive [value redacted]' : should
+        case @resource["withpath"]
+        when :true
+          send(@resource[:loglevel], message)
+        else
+          Puppet.send(@resource[:loglevel], message)
+        end
+        nil
+      end
+
+      def retrieve
+        :absent
+      end
+
+      def insync?(is)
+        false
+      end
+
+      defaultto { @resource[:name] }
+    end
+
+    newparam(:withpath) do
+      desc "Whether to show the full object path."
+      defaultto :false
+
+      newvalues(:true, :false)
+    end
+
+    newparam(:name) do
+      desc "An arbitrary tag for your own reference; the name of the message."
+      isnamevar
+    end
+  end
+end