puppet 0.25.5 → 2.6.0

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

@@ -1,174 +1,170 @@
 module Puppet
-    Puppet::Type.type(:file).ensurable do
-        require 'etc'
-        desc "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 (and directory if recurse => true).
-
-            Anything other than those values will be considered to be a symlink.
-            For instance, the following text creates a link::
-
-                # Useful on solaris
-                file { \"/etc/inetd.conf\":
-                    ensure => \"/etc/inet/inetd.conf\"
-                }
-
-            You can make relative links::
-
-                # Useful on solaris
-                file { \"/etc/inetd.conf\":
-                    ensure => \"inet/inetd.conf\"
-                }
-
-            If you need to make a relative link to a file named the same
-            as one of the valid values, you must prefix it with ``./`` or
-            something similar.
-
-            You can also make recursive symlinks, which will create a
-            directory structure that maps to the target directory,
-            with directories corresponding to each directory
-            and links corresponding to each file."
-
-        # 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) do
-            # Make sure we're not managing the content some other way
-            if property = (@resource.property(:content) || @resource.property(:source))
-                property.sync
-            else
-                @resource.write("", :ensure)
-                mode = @resource.should(:mode)
-            end
-            return :file_created
-        end
-
-        #aliasvalue(:present, :file)
-        newvalue(:present) do
-            # Make a file if they want something, but this will match almost
-            # anything.
-            set_file
-        end
+  Puppet::Type.type(:file).ensurable do
+    require 'etc'
+    desc "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 (and directory if recurse => true).
+
+      Anything other than those values will be considered to be a symlink.
+      For instance, the following text creates a link::
+
+        # Useful on solaris
+        file { \"/etc/inetd.conf\":
+          ensure => \"/etc/inet/inetd.conf\"
+        }
+
+      You can make relative links::
+
+        # Useful on solaris
+        file { \"/etc/inetd.conf\":
+          ensure => \"inet/inetd.conf\"
+        }
+
+      If you need to make a relative link to a file named the same
+      as one of the valid values, you must prefix it with ``./`` or
+      something similar.
+
+      You can also make recursive symlinks, which will create a
+      directory structure that maps to the target directory,
+      with directories corresponding to each directory
+      and links corresponding to each file."
+
+    # Most 'ensure' properties have a default, but with files we, um, don't.
+    nodefault
+
+    newvalue(:absent) do
+      File.unlink(@resource[:path])
+    end
 
-        newvalue(:directory) do
-            mode = @resource.should(:mode)
-            parent = File.dirname(@resource[:path])
-            unless FileTest.exists? parent
-                raise Puppet::Error,
-                    "Cannot create %s; parent directory %s does not exist" %
-                        [@resource[:path], parent]
-            end
-            if mode
-                Puppet::Util.withumask(000) do
-                    Dir.mkdir(@resource[:path],mode)
-                end
-            else
-                Dir.mkdir(@resource[:path])
-            end
-            @resource.send(:property_fix)
-            @resource.setchecksum
-            return :directory_created
-        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
 
-        newvalue(:link) do
-            fail "Cannot create a symlink without a target" unless property = resource.property(:target)
-            property.retrieve
-            property.mklink
-        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
 
-        # 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.
+    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],mode)
         end
+      else
+        Dir.mkdir(@resource[:path])
+      end
+      @resource.send(:property_fix)
+      return :directory_created
+    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"
+    newvalue(:link, :event => :link_created) do
+      fail "Cannot create a symlink without a target" unless property = resource.property(:target)
+      property.retrieve
+      property.mklink
+    end
 
-            return super unless property = @resource.property(:content)
+    # 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
 
-            # 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
+    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
 
-            return property.change_to_s(property.retrieve, should)
-        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 %s; parent directory does not exist" %
-                    @resource.title
-            elsif ! FileTest.directory?(basedir)
-                raise Puppet::Error,
-                    "Can not create %s; %s is not a directory" %
-                    [@resource.title, dirname]
-            end
-        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
-                if currentvalue.nil? or currentvalue == :absent
-                    return false
-                else
-                    return true
-                end
-            else
-                return super(currentvalue)
-            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(false)
-                return stat.ftype.intern
-            else
-                if self.should == :false
-                    return :false
-                else
-                    return :absent
-                end
-            end
+    def retrieve
+      if stat = @resource.stat(false)
+        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
+    def sync
+      @resource.remove_existing(self.should)
+      if self.should == :absent
+        return :file_removed
+      end
 
-            event = super
+      event = super
 
-            return event
-        end
+      event
     end
+  end
 end
 

data/lib/puppet/type/file/group.rb

@@ -2,122 +2,112 @@ require 'puppet/util/posix'
 
 # Manage file group ownership.
 module Puppet
-    Puppet::Type.type(:file).newproperty(:group) do
-        include Puppet::Util::POSIX
+  Puppet::Type.type(:file).newproperty(:group) do
+    include Puppet::Util::POSIX
 
-        require 'etc'
-        desc "Which group should own the file.  Argument can be either group
-            name or group ID."
-        @event = :file_changed
+    require 'etc'
+    desc "Which group should own the file.  Argument can be either group
+      name or group ID."
+    @event = :file_changed
 
-        validate do |group|
-            raise(Puppet::Error, "Invalid group name '%s'" % group.inspect) unless group and group != ""
-        end
+    validate do |group|
+      raise(Puppet::Error, "Invalid group name '#{group.inspect}'") unless group and group != ""
+    end
 
-        def id2name(id)
-            return id.to_s if id.is_a?(Symbol)
-            return nil if id > Puppet[:maximum_uid].to_i
-            begin
-                group = Etc.getgrgid(id)
-            rescue ArgumentError
-                return nil
-            end
-            if group.gid == ""
-                return nil
-            else
-                return group.name
-            end
-        end
+    def id2name(id)
+      return id.to_s if id.is_a?(Symbol)
+      return nil if id > Puppet[:maximum_uid].to_i
+      begin
+        group = Etc.getgrgid(id)
+      rescue ArgumentError
+        return nil
+      end
+      if group.gid == ""
+        return nil
+      else
+        return group.name
+      end
+    end
 
-        # We want to print names, not numbers
-        def is_to_s(currentvalue)
-            if currentvalue.is_a? Integer
-                id2name(currentvalue) || currentvalue
-            else
-                return currentvalue.to_s
-            end
-        end
+    # We want to print names, not numbers
+    def is_to_s(currentvalue)
+      if currentvalue.is_a? Integer
+        id2name(currentvalue) || currentvalue
+      else
+        return currentvalue.to_s
+      end
+    end
 
-        def should_to_s(newvalue = @should)
-            if newvalue.is_a? Integer
-                id2name(newvalue) || newvalue
-            else
-                return newvalue.to_s
-            end
-        end
+    def should_to_s(newvalue = @should)
+      if newvalue.is_a? Integer
+        id2name(newvalue) || newvalue
+      else
+        return newvalue.to_s
+      end
+    end
 
-        def insync?(current)
-            @should.each do |value|
-                if value =~ /^\d+$/
-                    gid = Integer(value)
-                elsif value.is_a?(String)
-                    fail "Could not find group %s" % value unless gid = gid(value)
-                else
-                    gid = value
-                end
-
-                return true if gid == current
-            end
-            return false
+    def insync?(current)
+      @should.each do |value|
+        if value =~ /^\d+$/
+          gid = Integer(value)
+        elsif value.is_a?(String)
+          fail "Could not find group #{value}" unless gid = gid(value)
+        else
+          gid = value
         end
 
-        def retrieve
-            return :absent unless stat = resource.stat(false)
+        return true if gid == current
+      end
+      false
+    end
 
-            currentvalue = stat.gid
+    def retrieve
+      return :absent unless stat = resource.stat(false)
 
-            # On OS X, files that are owned by -2 get returned as really
-            # large GIDs instead of negative ones.  This isn't a Ruby bug,
-            # it's an OS X bug, since it shows up in perl, too.
-            if currentvalue > Puppet[:maximum_uid].to_i
-                self.warning "Apparently using negative GID (%s) on a platform that does not consistently handle them" % currentvalue
-                currentvalue = :silly
-            end
+      currentvalue = stat.gid
 
-            return currentvalue
-        end
+      # On OS X, files that are owned by -2 get returned as really
+      # large GIDs instead of negative ones.  This isn't a Ruby bug,
+      # it's an OS X bug, since it shows up in perl, too.
+      if currentvalue > Puppet[:maximum_uid].to_i
+        self.warning "Apparently using negative GID (#{currentvalue}) on a platform that does not consistently handle them"
+        currentvalue = :silly
+      end
 
-        # Determine if the group is valid, and if so, return the GID
-        def validgroup?(value)
-            begin
-                number = Integer(value)
-                return number
-            rescue ArgumentError
-                number = nil
-            end
-            if number = gid(value)
-                return number
-            else
-                return false
-            end
-        end
+      currentvalue
+    end
 
-        # Normal users will only be able to manage certain groups.  Right now,
-        # we'll just let it fail, but we should probably set things up so
-        # that users get warned if they try to change to an unacceptable group.
-        def sync
-            # Set our method appropriately, depending on links.
-            if resource[:links] == :manage
-                method = :lchown
-            else
-                method = :chown
-            end
-
-            gid = nil
-            @should.each do |group|
-                break if gid = validgroup?(group)
-            end
-
-            raise Puppet::Error, "Could not find group(s) %s" % @should.join(",") unless gid
-
-            begin
-                # set owner to nil so it's ignored
-                File.send(method, nil, gid, resource[:path])
-            rescue => detail
-                error = Puppet::Error.new( "failed to chgrp %s to %s: %s" % [resource[:path], gid, detail.message])
-                raise error
-            end
-            return :file_changed
-        end
+    # Determine if the group is valid, and if so, return the GID
+    def validgroup?(value)
+      Integer(value) rescue gid(value) || false
+    end
+
+    # Normal users will only be able to manage certain groups.  Right now,
+    # we'll just let it fail, but we should probably set things up so
+    # that users get warned if they try to change to an unacceptable group.
+    def sync
+      # Set our method appropriately, depending on links.
+      if resource[:links] == :manage
+        method = :lchown
+      else
+        method = :chown
+      end
+
+      gid = nil
+      @should.each do |group|
+        break if gid = validgroup?(group)
+      end
+
+      raise Puppet::Error, "Could not find group(s) #{@should.join(",")}" unless gid
+
+      begin
+        # set owner to nil so it's ignored
+        File.send(method, nil, gid, resource[:path])
+      rescue => detail
+        error = Puppet::Error.new( "failed to chgrp #{resource[:path]} to #{gid}: #{detail.message}")
+        raise error
+      end
+      :file_changed
     end
+  end
 end