puppet 0.25.5 → 2.6.0

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

@@ -2,136 +2,123 @@
 # 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 'etc'
-        desc "Mode the file should be.  Currently relatively limited:
-            you must specify the exact mode the file should be.
- 
-            Note that when you set the mode of a directory, Puppet always
-            sets the search/traverse (1) bit anywhere the read (4) bit is set. 
-            This is almost always what you want: read allows you to list the
-            entries in a directory, and search/traverse allows you to access 
-            (read/write/execute) those entries.)  Because of this feature, you 
-            can recursively make a directory and all of the files in it 
-            world-readable by setting e.g.::
-
-                file { '/some/dir':
-                  mode => 644,
-                  recurse => true,
-                }
-
-            In this case all of the files underneath ``/some/dir`` will have 
-            mode 644, and all of the directories will have mode 755."
-
-        @event = :file_changed
-
-        # Our modes are octal, so make sure they print correctly.  Other
-        # valid values are symbols, basically
-        def is_to_s(currentvalue)
-            case currentvalue
-            when Integer
-                return "%o" % currentvalue
-            when Symbol
-                return currentvalue
-            else
-                raise Puppet::DevError, "Invalid current value for mode: %s" %
-                    currentvalue.inspect
-            end
-        end
+  Puppet::Type.type(:file).newproperty(:mode) do
+    require 'etc'
+    desc "Mode the file should be.  Currently relatively limited:
+      you must specify the exact mode the file should be.
 
-        def should_to_s(newvalue = @should)
-            case newvalue
-            when Integer
-                return "%o" % newvalue
-            when Symbol
-                return newvalue
-            else
-                raise Puppet::DevError, "Invalid 'should' value for mode: %s" %
-                    newvalue.inspect
-            end
-        end
+      Note that when you set the mode of a directory, Puppet always
+      sets the search/traverse (1) bit anywhere the read (4) bit is set.
+      This is almost always what you want: read allows you to list the
+      entries in a directory, and search/traverse allows you to access
+      (read/write/execute) those entries.)  Because of this feature, you
+      can recursively make a directory and all of the files in it
+      world-readable by setting e.g.::
 
-        munge do |should|
-            # this is pretty hackish, but i need to make sure the number is in
-            # octal, yet the number can only be specified as a string right now
-            value = should
-            if value.is_a?(String)
-                unless value =~ /^\d+$/
-                    raise Puppet::Error, "File modes can only be numbers, not %s" %
-                        value.inspect
-                end
-                # Make sure our number looks like octal.
-                unless value =~ /^0/
-                    value = "0" + value
-                end
-                old = value
-                begin
-                    value = Integer(value)
-                rescue ArgumentError => detail
-                    raise Puppet::DevError, "Could not convert %s to integer" %
-                        old.inspect
-                end
-            end
-
-            return value
-        end
+        file { '/some/dir':
+          mode => 644,
+          recurse => true,
+        }
 
-        # 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])
-                if value & 0400 != 0
-                    value |= 0100
-                end
-                if value & 040 != 0
-                    value |= 010
-                end
-                if value & 04 != 0
-                    value |= 01
-                end
-            end
-
-            return value
-        end
+      In this case all of the files underneath ``/some/dir`` will have
+      mode 644, and all of the directories will have mode 755."
 
-        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
+    @event = :file_changed
 
-        def retrieve
-            # If we're not following links and we're a link, then we just turn
-            # off mode management entirely.
-
-            if stat = @resource.stat(false)
-                unless defined? @fixed
-                    if defined? @should and @should
-                        @should = @should.collect { |s| self.dirmask(s) }
-                    end
-                end
-                return stat.mode & 007777
-            else
-                return :absent
-            end
+    # Our modes are octal, so make sure they print correctly.  Other
+    # valid values are symbols, basically
+    def is_to_s(currentvalue)
+      case currentvalue
+      when Integer
+        return "%o" % currentvalue
+      when Symbol
+        return currentvalue
+      else
+        raise Puppet::DevError, "Invalid current value for mode: #{currentvalue.inspect}"
+      end
+    end
+
+    def should_to_s(newvalue = @should)
+      case newvalue
+      when Integer
+        return "%o" % newvalue
+      when Symbol
+        return newvalue
+      else
+        raise Puppet::DevError, "Invalid 'should' value for mode: #{newvalue.inspect}"
+      end
+    end
+
+    munge do |should|
+      # this is pretty hackish, but i need to make sure the number is in
+      # octal, yet the number can only be specified as a string right now
+      value = should
+      if value.is_a?(String)
+        unless value =~ /^\d+$/
+          raise Puppet::Error, "File modes can only be numbers, not #{value.inspect}"
+        end
+        # Make sure our number looks like octal.
+        unless value =~ /^0/
+          value = "0#{value}"
+        end
+        old = value
+        begin
+          value = Integer(value)
+        rescue ArgumentError => detail
+          raise Puppet::DevError, "Could not convert #{old.inspect} to integer"
         end
+      end
 
-        def sync
-            mode = self.should
-
-            begin
-                File.chmod(mode, @resource[:path])
-            rescue => detail
-                error = Puppet::Error.new("failed to chmod %s: %s" %
-                    [@resource[:path], detail.message])
-                error.set_backtrace detail.backtrace
-                raise error
-            end
-            return :file_changed
+      return value
+    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])
+        value |= 0100 if value & 0400 != 0
+        value |= 010 if value & 040 != 0
+        value |= 01 if value & 04 != 0
+      end
+
+      value
+    end
+
+    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 retrieve
+      # If we're not following links and we're a link, then we just turn
+      # off mode management entirely.
+
+      if stat = @resource.stat(false)
+        unless defined?(@fixed)
+          @should &&= @should.collect { |s| self.dirmask(s) }
         end
+        return stat.mode & 007777
+      else
+        return :absent
+      end
+    end
+
+    def sync
+      mode = self.should
+
+      begin
+        File.chmod(mode, @resource[:path])
+      rescue => detail
+        error = Puppet::Error.new("failed to chmod #{@resource[:path]}: #{detail.message}")
+        error.set_backtrace detail.backtrace
+        raise error
+      end
+      :file_changed
     end
+  end
 end
 

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

@@ -1,144 +1,52 @@
 module Puppet
-    Puppet::Type.type(:file).newproperty(:owner) do
-        include Puppet::Util::POSIX
-        include Puppet::Util::Warnings
+  Puppet::Type.type(:file).newproperty(:owner) do
 
-        require 'etc'
-        desc "To whom the file should belong.  Argument can be user name or
-            user ID."
-        @event = :file_changed
+    desc "To whom the file should belong.  Argument can be user name or
+      user ID."
+    @event = :file_changed
 
-        def id2name(id)
-            return id.to_s if id.is_a?(Symbol)
-            return nil if id > Puppet[:maximum_uid].to_i
-
-            begin
-                user = Etc.getpwuid(id)
-            rescue TypeError
-                return nil
-            rescue ArgumentError
-                return nil
-            end
-
-            if user.uid == ""
-                return nil
-            else
-                return user.name
-            end
-        end
-
-        def insync?(current)
-            return true unless should
-
-            @should.each do |value|
-                if value =~ /^\d+$/
-                    uid = Integer(value)
-                elsif value.is_a?(String)
-                    fail "Could not find user %s" % value unless uid = uid(value)
-                else
-                    uid = value
-                end
-
-                return true if uid == current
-            end
-
-            unless Puppet::Util::SUIDManager.uid == 0
-                warnonce "Cannot manage ownership unless running as root"
-                return true
-            end
-
-            return false
-        end
+    def insync?(current)
+      provider.insync?(current, @should)
+    end
 
-        # Determine if the user is valid, and if so, return the UID
-        def validuser?(value)
-            begin
-                number = Integer(value)
-                return number
-            rescue ArgumentError
-                number = nil
-            end
-            if number = uid(value)
-                return number
-            else
-                return false
-            end
-        end
+    # We want to print names, not numbers
+    def is_to_s(currentvalue)
+      provider.id2name(currentvalue) || currentvalue
+    end
 
-        # We want to print names, not numbers
-        def is_to_s(currentvalue)
-            id2name(currentvalue) || currentvalue
-        end
+    def should_to_s(newvalue = @should)
+      case newvalue
+      when Symbol
+        newvalue.to_s
+      when Integer
+        provider.id2name(newvalue) || newvalue
+      when String
+        newvalue
+      else
+        raise Puppet::DevError, "Invalid uid type #{newvalue.class}(#{newvalue})"
+      end
+    end
 
-        def should_to_s(newvalue = @should)
-            case newvalue
-            when Symbol
-                newvalue.to_s
-            when Integer
-                id2name(newvalue) || newvalue
-            when String
-                newvalue
+    def retrieve
+      if self.should
+        @should = @should.collect do |val|
+          unless val.is_a?(Integer)
+            if tmp = provider.validuser?(val)
+              val = tmp
             else
-                raise Puppet::DevError, "Invalid uid type %s(%s)" %
-                    [newvalue.class, newvalue]
-            end
-        end
-
-        def retrieve
-            if self.should
-                @should = @should.collect do |val|
-                    unless val.is_a?(Integer)
-                        if tmp = validuser?(val)
-                            val = tmp
-                        else
-                            raise "Could not find user %s" % val
-                        end
-                    else
-                        val
-                    end
-                end
-            end
-
-            unless stat = @resource.stat(false)
-                return :absent
+              raise "Could not find user #{val}"
             end
-
-            currentvalue = stat.uid
-
-            # On OS X, files that are owned by -2 get returned as really
-            # large UIDs 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 UID (%s) on a platform that does not consistently handle them" % currentvalue
-                currentvalue = :silly
-            end
-
-            return currentvalue
+          else
+            val
+          end
         end
+      end
+      provider.retrieve(@resource)
+    end
 
-        def sync
-            # Set our method appropriately, depending on links.
-            if resource[:links] == :manage
-                method = :lchown
-            else
-                method = :chown
-            end
-
-            uid = nil
-            @should.each do |user|
-                break if uid = validuser?(user)
-            end
-
-            raise Puppet::Error, "Could not find user(s) %s" % @should.join(",") unless uid
-
-            begin
-                File.send(method, uid, nil, @resource[:path])
-            rescue => detail
-                raise Puppet::Error, "Failed to set owner to '%s': %s" % [uid, detail]
-            end
-
-            return :file_changed
-        end
+    def sync
+      provider.sync(resource[:path], resource[:links], @should)
     end
+  end
 end
 

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

@@ -20,88 +20,84 @@
 # See http://www.nsa.gov/selinux/ for complete docs on SELinux.
 
 module Puppet
-    require 'puppet/util/selinux'
-
-    class SELFileContext < Puppet::Property
-        include Puppet::Util::SELinux
-
-        def retrieve
-            unless @resource.stat(false)
-                return :absent
-            end
-            context = self.get_selinux_current_context(@resource[:path])
-            return parse_selinux_context(name, context)
-        end
-
-        def retrieve_default_context(property)
-            unless context = self.get_selinux_default_context(@resource[:path])
-                return nil
-            end
-            property_default = self.parse_selinux_context(property, context)
-            if not property_default.nil?
-                self.debug "Found #{property} default '#{property_default}' for #{@resource[:path]}"
-            end
-            return property_default
-        end
-
-        def insync?(value)
-            if not selinux_support?
-              debug("SELinux bindings not found. Ignoring parameter.")
-              return true
-            end
-            super
-        end
-
-        def sync
-            self.set_selinux_context(@resource[:path], @should, name)
-            return :file_changed
-        end
-    end
+  require 'puppet/util/selinux'
 
-    Puppet::Type.type(:file).newproperty(:seluser, :parent => Puppet::SELFileContext) do
-        desc "What the SELinux user component of the context of the file should be.
-            Any valid SELinux user component is accepted.  For example ``user_u``.
-            If not specified it defaults to the value returned by matchpathcon for
-            the file, if any exists.  Only valid on systems with SELinux support
-            enabled."
+  class SELFileContext < Puppet::Property
+    include Puppet::Util::SELinux
 
-        @event = :file_changed
-        defaultto { self.retrieve_default_context(:seluser) }
+    def retrieve
+      return :absent unless @resource.stat(false)
+      context = self.get_selinux_current_context(@resource[:path])
+      parse_selinux_context(name, context)
     end
 
-    Puppet::Type.type(:file).newproperty(:selrole, :parent => Puppet::SELFileContext) do
-        desc "What the SELinux role component of the context of the file should be.
-            Any valid SELinux role component is accepted.  For example ``role_r``.
-            If not specified it defaults to the value returned by matchpathcon for
-            the file, if any exists.  Only valid on systems with SELinux support
-            enabled."
-
-        @event = :file_changed
-        defaultto { self.retrieve_default_context(:selrole) }
+    def retrieve_default_context(property)
+      unless context = self.get_selinux_default_context(@resource[:path])
+        return nil
+      end
+      property_default = self.parse_selinux_context(property, context)
+      self.debug "Found #{property} default '#{property_default}' for #{@resource[:path]}" if not property_default.nil?
+      property_default
     end
 
-    Puppet::Type.type(:file).newproperty(:seltype, :parent => Puppet::SELFileContext) do
-        desc "What the SELinux type component of the context of the file should be.
-            Any valid SELinux type component is accepted.  For example ``tmp_t``.
-            If not specified it defaults to the value returned by matchpathcon for
-            the file, if any exists.  Only valid on systems with SELinux support
-            enabled."
-
-        @event = :file_changed
-        defaultto { self.retrieve_default_context(:seltype) }
+    def insync?(value)
+      if not selinux_support?
+        debug("SELinux bindings not found. Ignoring parameter.")
+        return true
+      end
+      super
     end
 
-    Puppet::Type.type(:file).newproperty(:selrange, :parent => Puppet::SELFileContext) do
-        desc "What the SELinux range component of the context of the file should be.
-            Any valid SELinux range component is accepted.  For example ``s0`` or
-            ``SystemHigh``.  If not specified it defaults to the value returned by
-            matchpathcon for the file, if any exists.  Only valid on systems with
-            SELinux support enabled and that have support for MCS (Multi-Category
-            Security)."
-
-        @event = :file_changed
-        defaultto { self.retrieve_default_context(:selrange) }
+    def sync
+      self.set_selinux_context(@resource[:path], @should, name)
+      :file_changed
     end
+  end
+
+  Puppet::Type.type(:file).newproperty(:seluser, :parent => Puppet::SELFileContext) do
+    desc "What the SELinux user component of the context of the file should be.
+      Any valid SELinux user component is accepted.  For example ``user_u``.
+      If not specified it defaults to the value returned by matchpathcon for
+      the file, if any exists.  Only valid on systems with SELinux support
+      enabled."
+
+    @event = :file_changed
+    defaultto { self.retrieve_default_context(:seluser) }
+  end
+
+  Puppet::Type.type(:file).newproperty(:selrole, :parent => Puppet::SELFileContext) do
+    desc "What the SELinux role component of the context of the file should be.
+      Any valid SELinux role component is accepted.  For example ``role_r``.
+      If not specified it defaults to the value returned by matchpathcon for
+      the file, if any exists.  Only valid on systems with SELinux support
+      enabled."
+
+    @event = :file_changed
+    defaultto { self.retrieve_default_context(:selrole) }
+  end
+
+  Puppet::Type.type(:file).newproperty(:seltype, :parent => Puppet::SELFileContext) do
+    desc "What the SELinux type component of the context of the file should be.
+      Any valid SELinux type component is accepted.  For example ``tmp_t``.
+      If not specified it defaults to the value returned by matchpathcon for
+      the file, if any exists.  Only valid on systems with SELinux support
+      enabled."
+
+    @event = :file_changed
+    defaultto { self.retrieve_default_context(:seltype) }
+  end
+
+  Puppet::Type.type(:file).newproperty(:selrange, :parent => Puppet::SELFileContext) do
+    desc "What the SELinux range component of the context of the file should be.
+      Any valid SELinux range component is accepted.  For example ``s0`` or
+      ``SystemHigh``.  If not specified it defaults to the value returned by
+      matchpathcon for the file, if any exists.  Only valid on systems with
+      SELinux support enabled and that have support for MCS (Multi-Category
+      Security)."
+
+    @event = :file_changed
+    defaultto { self.retrieve_default_context(:selrange) }
+  end
 
 end