puppet-retrospec 0.12.2 → 1.0.0

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

@@ -1,241 +0,0 @@
-require 'net/http'
-require 'uri'
-require 'tempfile'
-
-require 'puppet/util/checksums'
-require 'puppet/network/http'
-require 'puppet/network/http/compression'
-
-module Puppet
-  Puppet::Type.type(:file).newproperty(:content) do
-    include Puppet::Util::Diff
-    include Puppet::Util::Checksums
-    include Puppet::Network::HTTP::Compression.module
-
-    attr_reader :actual_content
-
-    desc <<-'EOT'
-      The desired contents of a file, as a string. This attribute is mutually
-      exclusive with `source` and `target`.
-
-      Newlines and tabs can be specified in double-quoted strings using
-      standard escaped syntax --- \n for a newline, and \t for a tab.
-
-      With very small files, you can construct content strings directly in
-      the manifest...
-
-          define resolve(nameserver1, nameserver2, domain, search) {
-              $str = "search $search
-                  domain $domain
-                  nameserver $nameserver1
-                  nameserver $nameserver2
-                  "
-
-              file { "/etc/resolv.conf":
-                content => "$str",
-              }
-          }
-
-      ...but for larger files, this attribute is more useful when combined with the
-      [template](http://docs.puppetlabs.com/references/latest/function.html#template)
-      or [file](http://docs.puppetlabs.com/references/latest/function.html#file)
-      function.
-    EOT
-
-    # Store a checksum as the value, rather than the actual content.
-    # Simplifies everything.
-    munge do |value|
-      if value == :absent
-        value
-      elsif checksum?(value)
-        # XXX This is potentially dangerous because it means users can't write a file whose
-        # entire contents are a plain checksum
-        value
-      else
-        @actual_content = value
-        resource.parameter(:checksum).sum(value)
-      end
-    end
-
-    # Checksums need to invert how changes are printed.
-    def change_to_s(currentvalue, newvalue)
-      # Our "new" checksum value is provided by the source.
-      if source = resource.parameter(:source) and tmp = source.checksum
-        newvalue = tmp
-      end
-      if currentvalue == :absent
-        return "defined content as '#{newvalue}'"
-      elsif newvalue == :absent
-        return "undefined content from '#{currentvalue}'"
-      else
-        return "content changed '#{currentvalue}' to '#{newvalue}'"
-      end
-    end
-
-    def checksum_type
-      if source = resource.parameter(:source)
-        result = source.checksum
-      else
-        result = resource[:checksum]
-      end
-      if result =~ /^\{(\w+)\}.+/
-        return $1.to_sym
-      else
-        return result
-      end
-    end
-
-    def length
-      (actual_content and actual_content.length) || 0
-    end
-
-    def content
-      self.should
-    end
-
-    # Override this method to provide diffs if asked for.
-    # Also, fix #872: when content is used, and replace is true, the file
-    # should be insync when it exists
-    def insync?(is)
-      if resource.should_be_file?
-        return false if is == :absent
-      else
-        if resource[:ensure] == :present and resource[:content] and s = resource.stat
-          resource.warning "Ensure set to :present but file type is #{s.ftype} so no content will be synced"
-        end
-        return true
-      end
-
-      return true if ! @resource.replace?
-
-      result = super
-
-      if ! result and Puppet[:show_diff] and resource.show_diff?
-        write_temporarily do |path|
-          send @resource[:loglevel], "\n" + diff(@resource[:path], path)
-        end
-      end
-      result
-    end
-
-    def retrieve
-      return :absent unless stat = @resource.stat
-      ftype = stat.ftype
-      # Don't even try to manage the content on directories or links
-      return nil if ["directory","link"].include?(ftype)
-
-      begin
-        resource.parameter(:checksum).sum_file(resource[:path])
-      rescue => detail
-        raise Puppet::Error, "Could not read #{ftype} #{@resource.title}: #{detail}", detail.backtrace
-      end
-    end
-
-    # Make sure we're also managing the checksum property.
-    def should=(value)
-      # treat the value as a bytestring, in Ruby versions that support it, regardless of the encoding
-      # in which it has been supplied
-      value = value.clone.force_encoding(Encoding::ASCII_8BIT) if value.respond_to?(:force_encoding)
-      @resource.newattr(:checksum) unless @resource.parameter(:checksum)
-      super
-    end
-
-    # Just write our content out to disk.
-    def sync
-      return_event = @resource.stat ? :file_changed : :file_created
-
-      # We're safe not testing for the 'source' if there's no 'should'
-      # because we wouldn't have gotten this far if there weren't at least
-      # one valid value somewhere.
-      @resource.write(:content)
-
-      return_event
-    end
-
-    def write_temporarily
-      tempfile = Tempfile.new("puppet-file")
-      tempfile.open
-
-      write(tempfile)
-
-      tempfile.close
-
-      yield tempfile.path
-
-      tempfile.delete
-    end
-
-    def write(file)
-      resource.parameter(:checksum).sum_stream { |sum|
-        each_chunk_from(actual_content || resource.parameter(:source)) { |chunk|
-          sum << chunk
-          file.print chunk
-        }
-      }
-    end
-
-    # the content is munged so if it's a checksum source_or_content is nil
-    # unless the checksum indirectly comes from source
-    def each_chunk_from(source_or_content)
-      if source_or_content.is_a?(String)
-        yield source_or_content
-      elsif content_is_really_a_checksum? && source_or_content.nil?
-        yield read_file_from_filebucket
-      elsif source_or_content.nil?
-        yield ''
-      elsif Puppet[:default_file_terminus] == :file_server
-        yield source_or_content.content
-      elsif source_or_content.local?
-        chunk_file_from_disk(source_or_content) { |chunk| yield chunk }
-      else
-        chunk_file_from_source(source_or_content) { |chunk| yield chunk }
-      end
-    end
-
-    private
-
-    def content_is_really_a_checksum?
-      checksum?(should)
-    end
-
-    def chunk_file_from_disk(source_or_content)
-      File.open(source_or_content.full_path, "rb") do |src|
-        while chunk = src.read(8192)
-          yield chunk
-        end
-      end
-    end
-
-    def get_from_source(source_or_content, &block)
-      source = source_or_content.metadata.source
-      request = Puppet::Indirector::Request.new(:file_content, :find, source, nil, :environment => resource.catalog.environment)
-
-      request.do_request(:fileserver) do |req|
-        connection = Puppet::Network::HttpPool.http_instance(req.server, req.port)
-        connection.request_get(Puppet::Network::HTTP::API::V1.indirection2uri(req), add_accept_encoding({"Accept" => "raw"}), &block)
-      end
-    end
-
-
-    def chunk_file_from_source(source_or_content)
-      get_from_source(source_or_content) do |response|
-        case response.code
-        when /^2/;  uncompress(response) { |uncompressor| response.read_body { |chunk| yield uncompressor.uncompress(chunk) } }
-        else
-          # Raise the http error if we didn't get a 'success' of some kind.
-          message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
-          raise Net::HTTPError.new(message, response)
-        end
-      end
-    end
-
-    def read_file_from_filebucket
-      raise "Could not get filebucket from file" unless dipper = resource.bucket
-      sum = should.sub(/\{\w+\}/, '')
-
-      dipper.getfile(sum)
-    rescue => detail
-      self.fail Puppet::Error, "Could not retrieve content for #{should} from filebucket: #{detail}", detail
-    end
-  end
-end

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

@@ -1,189 +0,0 @@
-
-module Puppet
-  Puppet::Type.type(:file).ensurable do
-    require 'etc'
-    require 'puppet/util/symbolic_file_mode'
-    include Puppet::Util::SymbolicFileMode
-
-    desc <<-EOT
-      Whether the file should exist, and if so what kind of file it should be.
-      Possible values are `present`, `absent`, `file`, `directory`, and `link`.
-
-      * `present` will accept any form of file existence, and will create a
-        normal file if the file is missing. (The file will have no content
-        unless the `content` or `source` attribute is used.)
-      * `absent` will make sure the file doesn't exist, deleting it
-        if necessary.
-      * `file` will make sure it's a normal file, and enables use of the
-        `content` or `source` attribute.
-      * `directory` will make sure it's a directory, and enables use of the
-        `source`, `recurse`, `recurselimit`, `ignore`, and `purge` attributes.
-      * `link` will make sure the file is a symlink, and **requires** that you
-        also set the `target` attribute. Symlinks are supported on all Posix
-        systems and on Windows Vista / 2008 and higher. On Windows, managing
-        symlinks requires puppet agent's user account to have the "Create
-        Symbolic Links" privilege; this can be configured in the "User Rights
-        Assignment" section in the Windows policy editor. By default, puppet
-        agent runs as the Administrator account, which does have this privilege.
-
-      Puppet avoids destroying directories unless the `force` attribute is set
-      to `true`. This means that if a file is currently a directory, setting
-      `ensure` to anything but `directory` or `present` will cause Puppet to
-      skip managing the resource and log either a notice or an error.
-
-      There is one other non-standard value for `ensure`. If you specify the
-      path to another file as the ensure value, it is equivalent to specifying
-      `link` and using that path as the `target`:
-
-          # Equivalent resources:
-
-          file { "/etc/inetd.conf":
-            ensure => "/etc/inet/inetd.conf",
-          }
-
-          file { "/etc/inetd.conf":
-            ensure => link,
-            target => "/etc/inet/inetd.conf",
-          }
-
-      However, we recommend using `link` and `target` explicitly, since this
-      behavior can be harder to read.
-    EOT
-
-    # Most 'ensure' properties have a default, but with files we, um, don't.
-    nodefault
-
-    newvalue(:absent) do
-      Puppet::FileSystem.unlink(@resource[:path])
-    end
-
-    aliasvalue(:false, :absent)
-
-    newvalue(:file, :event => :file_created) do
-      # Make sure we're not managing the content some other way
-      if property = @resource.property(:content)
-        property.sync
-      else
-        @resource.write(:ensure)
-        @resource.should(:mode)
-      end
-    end
-
-    #aliasvalue(:present, :file)
-    newvalue(:present, :event => :file_created) do
-      # Make a file if they want something, but this will match almost
-      # anything.
-      set_file
-    end
-
-    newvalue(:directory, :event => :directory_created) do
-      mode = @resource.should(:mode)
-      parent = File.dirname(@resource[:path])
-      unless Puppet::FileSystem.exist? parent
-        raise Puppet::Error,
-          "Cannot create #{@resource[:path]}; parent directory #{parent} does not exist"
-      end
-      if mode
-        Puppet::Util.withumask(000) do
-          Dir.mkdir(@resource[:path], symbolic_mode_to_int(mode, 0755, true))
-        end
-      else
-        Dir.mkdir(@resource[:path])
-      end
-      @resource.send(:property_fix)
-      return :directory_created
-    end
-
-
-    newvalue(:link, :event => :link_created, :required_features => :manages_symlinks) do
-      fail "Cannot create a symlink without a target" unless property = resource.property(:target)
-      property.retrieve
-      property.mklink
-    end
-
-    # Symlinks.
-    newvalue(/./) do
-      # This code never gets executed.  We need the regex to support
-      # specifying it, but the work is done in the 'symlink' code block.
-    end
-
-    munge do |value|
-      value = super(value)
-      value,resource[:target] = :link,value unless value.is_a? Symbol
-      resource[:links] = :manage if value == :link and resource[:links] != :follow
-      value
-    end
-
-    def change_to_s(currentvalue, newvalue)
-      return super unless newvalue.to_s == "file"
-
-      return super unless property = @resource.property(:content)
-
-      # We know that content is out of sync if we're here, because
-      # it's essentially equivalent to 'ensure' in the transaction.
-      if source = @resource.parameter(:source)
-        should = source.checksum
-      else
-        should = property.should
-      end
-      if should == :absent
-        is = property.retrieve
-      else
-        is = :absent
-      end
-
-      property.change_to_s(is, should)
-    end
-
-    # Check that we can actually create anything
-    def check
-      basedir = File.dirname(@resource[:path])
-
-      if ! Puppet::FileSystem.exist?(basedir)
-        raise Puppet::Error,
-          "Can not create #{@resource.title}; parent directory does not exist"
-      elsif ! FileTest.directory?(basedir)
-        raise Puppet::Error,
-          "Can not create #{@resource.title}; #{dirname} is not a directory"
-      end
-    end
-
-    # We have to treat :present specially, because it works with any
-    # type of file.
-    def insync?(currentvalue)
-      unless currentvalue == :absent or resource.replace?
-        return true
-      end
-
-      if self.should == :present
-        return !(currentvalue.nil? or currentvalue == :absent)
-      else
-        return super(currentvalue)
-      end
-    end
-
-    def retrieve
-      if stat = @resource.stat
-        return stat.ftype.intern
-      else
-        if self.should == :false
-          return :false
-        else
-          return :absent
-        end
-      end
-    end
-
-    def sync
-      @resource.remove_existing(self.should)
-      if self.should == :absent
-        return :file_removed
-      end
-
-      event = super
-
-      event
-    end
-  end
-end
-

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

@@ -1,168 +0,0 @@
-# Manage file modes.  This state should support different formats
-# for specification (e.g., u+rwx, or -0011), but for now only supports
-# specifying the full mode.
-
-
-module Puppet
-  Puppet::Type.type(:file).newproperty(:mode) do
-    require 'puppet/util/symbolic_file_mode'
-    include Puppet::Util::SymbolicFileMode
-
-    desc <<-'EOT'
-      The desired permissions mode for the file, in symbolic or numeric
-      notation. This value should be specified as a quoted string; do not use
-      un-quoted numbers to represent file modes.
-
-      The `file` type uses traditional Unix permission schemes and translates
-      them to equivalent permissions for systems which represent permissions
-      differently, including Windows. For detailed ACL controls on Windows,
-      you can leave `mode` unmanaged and use
-      [the puppetlabs/acl module.](https://forge.puppetlabs.com/puppetlabs/acl)
-
-      Numeric modes should use the standard four-digit octal notation of
-      `<setuid/setgid/sticky><owner><group><other>` (e.g. 0644). Each of the
-      "owner," "group," and "other" digits should be a sum of the
-      permissions for that class of users, where read = 4, write = 2, and
-      execute/search = 1. When setting numeric permissions for
-      directories, Puppet sets the search permission wherever the read
-      permission is set.
-
-      Symbolic modes should be represented as a string of comma-separated
-      permission clauses, in the form `<who><op><perm>`:
-
-      * "Who" should be u (user), g (group), o (other), and/or a (all)
-      * "Op" should be = (set exact permissions), + (add select permissions),
-        or - (remove select permissions)
-      * "Perm" should be one or more of:
-          * r (read)
-          * w (write)
-          * x (execute/search)
-          * t (sticky)
-          * s (setuid/setgid)
-          * X (execute/search if directory or if any one user can execute)
-          * u (user's current permissions)
-          * g (group's current permissions)
-          * o (other's current permissions)
-
-      Thus, mode `0664` could be represented symbolically as either `a=r,ug+w`
-      or `ug=rw,o=r`.  However, symbolic modes are more expressive than numeric
-      modes: a mode only affects the specified bits, so `mode => 'ug+w'` will
-      set the user and group write bits, without affecting any other bits.
-
-      See the manual page for GNU or BSD `chmod` for more details
-      on numeric and symbolic modes.
-
-      On Windows, permissions are translated as follows:
-
-      * Owner and group names are mapped to Windows SIDs
-      * The "other" class of users maps to the "Everyone" SID
-      * The read/write/execute permissions map to the `FILE_GENERIC_READ`,
-        `FILE_GENERIC_WRITE`, and `FILE_GENERIC_EXECUTE` access rights; a
-        file's owner always has the `FULL_CONTROL` right
-      * "Other" users can't have any permissions a file's group lacks,
-        and its group can't have any permissions its owner lacks; that is, 0644
-        is an acceptable mode, but 0464 is not.
-    EOT
-
-    validate do |value|
-      if !value.is_a?(String)
-        Puppet.deprecation_warning("Non-string values for the file mode property are deprecated. It must be a string, " \
-          "either a symbolic mode like 'o+w,a+r' or an octal representation like '0644' or '755'.")
-      end
-      unless value.nil? or valid_symbolic_mode?(value)
-        raise Puppet::Error, "The file mode specification is invalid: #{value.inspect}"
-      end
-    end
-
-    munge do |value|
-      return nil if value.nil?
-
-      unless valid_symbolic_mode?(value)
-        raise Puppet::Error, "The file mode specification is invalid: #{value.inspect}"
-      end
-
-      normalize_symbolic_mode(value)
-    end
-
-    def desired_mode_from_current(desired, current)
-      current = current.to_i(8) if current.is_a? String
-      is_a_directory = @resource.stat && @resource.stat.directory?
-      symbolic_mode_to_int(desired, current, is_a_directory)
-    end
-
-    # If we're a directory, we need to be executable for all cases
-    # that are readable.  This should probably be selectable, but eh.
-    def dirmask(value)
-      if FileTest.directory?(resource[:path]) and value =~ /^\d+$/ then
-        value = value.to_i(8)
-        value |= 0100 if value & 0400 != 0
-        value |= 010 if value & 040 != 0
-        value |= 01 if value & 04 != 0
-        value = value.to_s(8)
-      end
-
-      value
-    end
-
-    # If we're not following links and we're a link, then we just turn
-    # off mode management entirely.
-    def insync?(currentvalue)
-      if stat = @resource.stat and stat.ftype == "link" and @resource[:links] != :follow
-        self.debug "Not managing symlink mode"
-        return true
-      else
-        return super(currentvalue)
-      end
-    end
-
-    def property_matches?(current, desired)
-      return false unless current
-      current_bits = normalize_symbolic_mode(current)
-      desired_bits = desired_mode_from_current(desired, current).to_s(8)
-      current_bits == desired_bits
-    end
-
-    # Ideally, dirmask'ing could be done at munge time, but we don't know if 'ensure'
-    # will eventually be a directory or something else. And unfortunately, that logic
-    # depends on the ensure, source, and target properties. So rather than duplicate
-    # that logic, and get it wrong, we do dirmask during retrieve, after 'ensure' has
-    # been synced.
-    def retrieve
-      if @resource.stat
-        @should &&= @should.collect { |s| self.dirmask(s) }
-      end
-
-      super
-    end
-
-    # Finally, when we sync the mode out we need to transform it; since we
-    # don't have access to the calculated "desired" value here, or the
-    # "current" value, only the "should" value we need to retrieve again.
-    def sync
-      current = @resource.stat ? @resource.stat.mode : 0644
-      set(desired_mode_from_current(@should[0], current).to_s(8))
-    end
-
-    def change_to_s(old_value, desired)
-      return super if desired =~ /^\d+$/
-
-      old_bits = normalize_symbolic_mode(old_value)
-      new_bits = normalize_symbolic_mode(desired_mode_from_current(desired, old_bits))
-      super(old_bits, new_bits) + " (#{desired})"
-    end
-
-    def should_to_s(should_value)
-      should_value.rjust(4, "0")
-    end
-
-    def is_to_s(currentvalue)
-      if currentvalue == :absent
-        # This can occur during audits---if a file is transitioning from
-        # present to absent the mode will have a value of `:absent`.
-        super
-      else
-        currentvalue.rjust(4, "0")
-      end
-    end
-  end
-end