puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/type/file/content.rb

@@ -0,0 +1,230 @@
+require 'net/http'
+require 'uri'
+require 'tempfile'
+
+require 'puppet/util/checksums'
+require 'puppet/network/http/api/v1'
+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::API::V1
+    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)
+      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 checksum = resource.parameter(:checksum)
+        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
+        return true
+      end
+
+      return true if ! @resource.replace?
+
+      result = super
+
+      if ! result and Puppet[:show_diff]
+        write_temporarily do |path|
+          notice "\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}"
+      end
+    end
+
+    # Make sure we're also managing the checksum property.
+    def should=(value)
+      @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
+
+    def self.standalone?
+      Puppet.settings[:name] == "apply"
+    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 self.class.standalone?
+        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 chunk_file_from_source(source_or_content)
+      request = Puppet::Indirector::Request.new(:file_content, :find, source_or_content.full_path.sub(/^\//,''))
+      connection = Puppet::Network::HttpPool.http_instance(source_or_content.server, source_or_content.port)
+      connection.request_get(indirection2uri(request), add_accept_encoding({"Accept" => "raw"})) 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
+      fail "Could not retrieve content for #{should} from filebucket: #{detail}"
+    end
+  end
+end

data/lib/vendor/puppet/type/file/ctime.rb

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

data/lib/vendor/puppet/type/file/ensure.rb

@@ -0,0 +1,172 @@
+
+module Puppet
+  Puppet::Type.type(:file).ensurable do
+    require 'etc'
+    require 'puppet/util/symbolic_file_mode'
+    include Puppet::Util::SymbolicFileMode
+
+    desc <<-'EOT'
+      Whether to create files that don't currently exist.
+      Possible values are *absent*, *present*, *file*, and *directory*.
+      Specifying `present` will match any form of file existence, and
+      if the file is missing will create an empty file. Specifying
+      `absent` will delete the file (or directory, if `recurse => true`).
+
+      Anything other than the above values will create a symlink; note that
+      symlinks cannot be managed on Windows. In the interest of readability
+      and clarity, symlinks should be created by setting `ensure => link` and
+      explicitly specifying a target; however, if a `target` attribute isn't
+      provided, the value of the `ensure` attribute will be used as the
+      symlink target. The following two declarations are equivalent:
+
+          # (Useful on Solaris)
+
+          # Less maintainable:
+          file { "/etc/inetd.conf":
+            ensure => "/etc/inet/inetd.conf",
+          }
+
+          # More maintainable:
+          file { "/etc/inetd.conf":
+            ensure => link,
+            target => "/etc/inet/inetd.conf",
+          }
+    EOT
+
+    # Most 'ensure' properties have a default, but with files we, um, don't.
+    nodefault
+
+    newvalue(:absent) do
+      File.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)
+        mode = @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 FileTest.exists? 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, 755, true))
+        end
+      else
+        Dir.mkdir(@resource[:path])
+      end
+      @resource.send(:property_fix)
+      return :directory_created
+    end
+
+
+    newvalue(:link, :event => :link_created) 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 ! FileTest.exists?(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/lib/vendor/puppet/type/file/group.rb

@@ -0,0 +1,41 @@
+require 'puppet/util/posix'
+
+# Manage file group ownership.
+module Puppet
+  Puppet::Type.type(:file).newproperty(:group) do
+    desc <<-EOT
+      Which group should own the file.  Argument can be either a group
+      name or a group ID.
+
+      On Windows, a user (such as "Administrator") can be set as a file's group
+      and a group (such as "Administrators") can be set as a file's owner;
+      however, a file's owner and group shouldn't be the same. (If the owner
+      is also the group, files with modes like `0640` will cause log churn, as
+      they will always appear out of sync.)
+    EOT
+
+    validate do |group|
+      raise(Puppet::Error, "Invalid group name '#{group.inspect}'") unless group and group != ""
+    end
+
+    def insync?(current)
+      # We don't want to validate/munge groups until we actually start to
+      # evaluate this property, because they might be added during the catalog
+      # apply.
+      @should.map! do |val|
+        provider.name2gid(val) or raise "Could not find group #{val}"
+      end
+
+      @should.include?(current)
+    end
+
+    # We want to print names, not numbers
+    def is_to_s(currentvalue)
+      provider.gid2name(currentvalue) || currentvalue
+    end
+
+    def should_to_s(newvalue)
+      provider.gid2name(newvalue) || newvalue
+    end
+  end
+end

data/lib/vendor/puppet/type/file/mode.rb

@@ -0,0 +1,148 @@
+# 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. Puppet uses traditional Unix permission schemes and translates
+      them to equivalent permissions for systems which represent permissions
+      differently, including Windows.
+
+      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`. 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|
+      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 and @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)
+      orig = 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)
+      currentvalue.rjust(4, "0")
+    end
+  end
+end

data/lib/vendor/puppet/type/file/mtime.rb

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

data/lib/vendor/puppet/type/file/owner.rb

@@ -0,0 +1,44 @@
+module Puppet
+  Puppet::Type.type(:file).newproperty(:owner) do
+    include Puppet::Util::Warnings
+
+    desc <<-EOT
+      The user to whom the file should belong.  Argument can be a user name or a
+      user ID.
+
+      On Windows, a group (such as "Administrators") can be set as a file's owner
+      and a user (such as "Administrator") can be set as a file's group; however,
+      a file's owner and group shouldn't be the same. (If the owner is also
+      the group, files with modes like `0640` will cause log churn, as they
+      will always appear out of sync.)
+    EOT
+
+    def insync?(current)
+      # We don't want to validate/munge users until we actually start to
+      # evaluate this property, because they might be added during the catalog
+      # apply.
+      @should.map! do |val|
+        provider.name2uid(val) or raise "Could not find user #{val}"
+      end
+
+      return true if @should.include?(current)
+
+      unless Puppet.features.root?
+        warnonce "Cannot manage ownership unless running as root"
+        return true
+      end
+
+      false
+    end
+
+    # We want to print names, not numbers
+    def is_to_s(currentvalue)
+      provider.uid2name(currentvalue) || currentvalue
+    end
+
+    def should_to_s(newvalue)
+      provider.uid2name(newvalue) || newvalue
+    end
+  end
+end
+