puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/type/file/target.rb

@@ -0,0 +1,87 @@
+module Puppet
+  Puppet::Type.type(:file).newproperty(:target) do
+    desc "The target for creating a link.  Currently, symlinks are the
+      only type supported. This attribute is mutually exclusive with `source`
+      and `content`.
+
+      Symlink targets can be relative, as well as absolute:
+
+          # (Useful on Solaris)
+          file { \"/etc/inetd.conf\":
+            ensure => link,
+            target => \"inet/inetd.conf\",
+          }
+
+      Directories of symlinks can be served recursively by instead using the
+      `source` attribute, setting `ensure` to `directory`, and setting the
+      `links` attribute to `manage`."
+
+    newvalue(:notlink) do
+      # We do nothing if the value is absent
+      return :nochange
+    end
+
+    # Anything else, basically
+    newvalue(/./) do
+      @resource[:ensure] = :link if ! @resource.should(:ensure)
+
+      # Only call mklink if ensure didn't call us in the first place.
+      currentensure  = @resource.property(:ensure).retrieve
+      mklink if @resource.property(:ensure).safe_insync?(currentensure)
+    end
+
+    # Create our link.
+    def mklink
+      raise Puppet::Error, "Cannot symlink on this platform version" if !provider.feature?(:manages_symlinks)
+
+      target = self.should
+
+      # Clean up any existing objects.  The argument is just for logging,
+      # it doesn't determine what's removed.
+      @resource.remove_existing(target)
+
+      raise Puppet::Error, "Could not remove existing file" if Puppet::FileSystem.exist?(@resource[:path])
+
+      Dir.chdir(File.dirname(@resource[:path])) do
+        Puppet::Util::SUIDManager.asuser(@resource.asuser) do
+          mode = @resource.should(:mode)
+          if mode
+            Puppet::Util.withumask(000) do
+              Puppet::FileSystem.symlink(target, @resource[:path])
+            end
+          else
+            Puppet::FileSystem.symlink(target, @resource[:path])
+          end
+        end
+
+        @resource.send(:property_fix)
+
+        :link_created
+      end
+    end
+
+    def insync?(currentvalue)
+      if [:nochange, :notlink].include?(self.should) or @resource.recurse?
+        return true
+      elsif ! @resource.replace? and Puppet::FileSystem.exist?(@resource[:path])
+        return true
+      else
+        return super(currentvalue)
+      end
+    end
+
+
+    def retrieve
+      if stat = @resource.stat
+        if stat.ftype == "link"
+          return Puppet::FileSystem.readlink(@resource[:path])
+        else
+          return :notlink
+        end
+      else
+        return :absent
+      end
+    end
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/type/file/type.rb

@@ -0,0 +1,19 @@
+module Puppet
+  Puppet::Type.type(:file).newproperty(:type) do
+    require 'etc'
+    desc "A read-only state to check the file type."
+
+    def retrieve
+      current_value = :absent
+      if stat = @resource.stat
+        current_value = stat.ftype
+      end
+      current_value
+    end
+
+    validate do |val|
+      fail "type is read-only"
+    end
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/type/filebucket.rb

@@ -0,0 +1,122 @@
+module Puppet
+  require 'puppet/file_bucket/dipper'
+
+  newtype(:filebucket) do
+    @doc = <<-EOT
+      A repository for storing and retrieving file content by MD5 checksum. Can
+      be local to each agent node, or centralized on a puppet master server. All
+      puppet masters 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.
+      - **Content distribution.** The optional static compiler populates the
+        puppet master's filebucket with the _desired_ content for each file,
+        then instructs the agent to retrieve the content for a specific
+        checksum. For more details,
+        [see the `static_compiler` section in the catalog indirection docs](http://docs.puppetlabs.com/references/latest/indirection.html#catalog).
+
+      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/puppet/manifests/site.pp
+          filebucket { 'main':
+            path   => false,                # This is required for remote filebuckets.
+            server => 'puppet.example.com', # Optional; defaults to the configured puppet master.
+          }
+
+          File { backup => main, }
+
+      Puppet master servers automatically provide the filebucket service, so
+      this will work in a default configuration. If you have a heavily
+      restricted `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. Defaults to the
+        value of the `server` setting (that is, the currently configured
+        puppet master server).
+
+        This setting is _only_ consulted if the `path` attribute is set to `false`."
+      defaultto { Puppet[:server] }
+    end
+
+    newparam(:port) do
+      desc "The port on which the remote server is listening. Defaults to the
+        value of the `masterport` setting, which is usually %s." % Puppet[:masterport]
+
+      defaultto { Puppet[:masterport] }
+    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 not 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}"
+        self.log_exception(detail, message)
+        self.fail(message)
+      end
+
+      @bucket.name = self.name
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/type/group.rb

@@ -0,0 +1,188 @@
+require 'etc'
+require 'facter'
+require 'puppet/property/keyvalue'
+require 'puppet/parameter/boolean'
+
+module Puppet
+  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 :libuser,
+      "Allows local groups to be managed on systems that also use some other
+       remote 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
+    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 self.should == :absent
+          raise Puppet::DevError, "GID cannot be deleted"
+        else
+          provider.gid = self.should
+        end
+      end
+
+      munge do |gid|
+        case gid
+        when String
+          if gid =~ /^[-0-9]+$/
+            gid = Integer(gid)
+          else
+            self.fail "Invalid GID #{gid}"
+          end
+        when Symbol
+          unless gid == :absent
+            self.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 directory services where group
+      membership is stored in the group objects, not the users."
+
+      def change_to_s(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)
+        if provider.respond_to?(:members_to_s)
+          currentvalue = '' if currentvalue.nil?
+          return provider.members_to_s(currentvalue.split(','))
+        end
+
+        super(currentvalue)
+      end
+      alias :should_to_s :is_to_s
+    end
+
+    newparam(:auth_membership) do
+      desc "whether the provider is authoritative for group membership."
+      defaultto true
+    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. Defaults to `false`."
+
+      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 user"
+    end
+
+    newproperty(:attributes, :parent => Puppet::Property::KeyValue, :required_features => :manages_aix_lam) do
+      desc "Specify group AIX attributes in an array of `key=value` pairs."
+
+      def membership
+        :attribute_membership
+      end
+
+      def delimiter
+        " "
+      end
+
+      validate do |value|
+        raise ArgumentError, "Attributes value pairs must be separated by an =" unless value.include?("=")
+      end
+    end
+
+    newparam(:attribute_membership) do
+      desc "Whether specified attribute value pairs should be treated as the only attributes
+        of the user or whether they should merely
+        be treated as the minimum list."
+
+      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 => :libuser,
+             :parent => Puppet::Parameter::Boolean) do
+      desc "Forces the management of local accounts when accounts are also
+            being managed by some other NSS"
+      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/vendor/gems/puppet-3.7.3/lib/puppet/type/host.rb

@@ -0,0 +1,86 @@
+require 'puppet/property/ordered_list'
+
+module Puppet
+  newtype(:host) do
+    ensurable
+
+    newproperty(:ip) do
+      desc "The host's IP address, IPv4 or IPv6."
+
+
+      def valid_v4?(addr)
+        if /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/ =~ addr
+          return $~.captures.all? {|i| i = i.to_i; i >= 0 and i <= 255 }
+        end
+        return false
+      end
+
+      def valid_v6?(addr)
+        # http://forums.dartware.com/viewtopic.php?t=452
+        # ...and, yes, it is this hard.  Doing it programatically is harder.
+        return true if addr =~ /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/
+
+        return false
+      end
+
+      validate do |value|
+        return true if valid_v4?(value) or valid_v6?(value)
+        raise Puppet::Error, "Invalid IP address #{value.inspect}"
+      end
+    end
+
+    # for now we use OrderedList to indicate that the order does matter.
+    newproperty(:host_aliases, :parent => Puppet::Property::OrderedList) do
+      desc "Any aliases the host might have.  Multiple values must be
+        specified as an array."
+
+      def delimiter
+        " "
+      end
+
+      def inclusive?
+        true
+      end
+
+      validate do |value|
+        raise Puppet::Error, "Host aliases cannot include whitespace" if value =~ /\s/
+        raise Puppet::Error, "Host alias cannot be an empty string. Use an empty array to delete all host_aliases " if value =~ /^\s*$/
+      end
+
+    end
+
+    newproperty(:comment) do
+      desc "A comment that will be attached to the line with a # character."
+    end
+
+    newproperty(:target) do
+      desc "The file in which to store service information.  Only used by
+        those providers that write to disk. On most systems this defaults to `/etc/hosts`."
+
+      defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
+        @resource.class.defaultprovider.default_target
+        else
+          nil
+        end
+      }
+    end
+
+    newparam(:name) do
+      desc "The host name."
+
+      isnamevar
+
+      validate do |value|
+        value.split('.').each do |hostpart|
+          unless hostpart =~ /^([\d\w]+|[\d\w][\d\w\-]+[\d\w])$/
+            raise Puppet::Error, "Invalid host name"
+          end
+        end
+      end
+    end
+
+    @doc = "Installs and manages host entries.  For most systems, these
+      entries will just be in `/etc/hosts`, but some systems (notably OS X)
+      will have different solutions."
+  end
+end