puppet 0.9.2

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

@@ -0,0 +1,131 @@
+# 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
+    class State
+        class PFileMode < Puppet::State
+            require 'etc'
+            @doc = "Mode the file should be.  Currently relatively limited:
+                you must specify the exact mode the file should be."
+            @name = :mode
+            @event = :inode_changed
+
+            # Our modes are octal, so make sure they print correctly.  Other
+            # valid values are symbols, basically
+            def is_to_s
+                case @is
+                when Integer
+                    return "%o" % @is
+                when Symbol
+                    return @is
+                else
+                    raise Puppet::DevError, "Invalid 'is' value for mode: %s" %
+                        @is.inspect
+                end
+            end
+
+            def should_to_s
+                case self.should
+                when Integer
+                    return "%o" % self.should
+                when Symbol
+                    return self.should
+                else
+                    raise Puppet::DevError, "Invalid 'should' value for mode: %s" %
+                        self.should.inspect
+                end
+            end
+
+            def shouldprocess(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 =~ /^[0-9]+$/
+                        raise Puppet::Error, "File modes can only be numbers"
+                    end
+                    unless value =~ /^0/
+                        value = "0" + value
+                    end
+                    begin
+                        value = Integer(value)
+                    rescue ArgumentError => detail
+                        raise Puppet::DevError, "Could not convert %s to integer" %
+                            value.inspect
+                    end
+                end
+
+                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?(@parent.name)
+                    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
+
+            def retrieve
+                if stat = @parent.stat(true)
+                    self.is = stat.mode & 007777
+                    unless defined? @fixed
+                        if defined? @should and @should
+                            @should = @should.collect { |s| self.dirmask(s) }
+                        end
+                    end
+                else
+                    self.is = :notfound
+                end
+
+                #self.debug "chmod state is %o" % self.is
+            end
+
+            def sync
+                if @is == :notfound
+                    @parent.stat(true)
+                    self.retrieve
+                    #self.debug "%s: after refresh, is '%s'" % [self.class.name,@is]
+                    if @is == :notfound
+                        self.info "File does not exist; cannot set mode" %
+                            @parent.name
+                        return nil
+                    end
+
+                    if self.insync?
+                        # we're already in sync
+                        return nil
+                    end
+                end
+
+                mode = self.should
+
+                if mode == :notfound
+                    # This is really only valid for create states...
+                    return nil
+                end
+
+                begin
+                    File.chmod(mode,@parent[:path])
+                rescue => detail
+                    error = Puppet::Error.new("failed to chmod %s: %s" %
+                        [@parent.name, detail.message])
+                    raise error
+                end
+                return :inode_changed
+            end
+        end
+    end
+end
+
+# $Id: mode.rb 740 2005-11-01 20:22:19Z luke $

data/lib/puppet/type/pfile/source.rb

@@ -0,0 +1,264 @@
+module Puppet
+    class State
+        # Copy files from a local or remote source.
+        class PFileSource < Puppet::State
+            attr_accessor :source, :local
+            @doc = "Copy a file over the current file.  Uses `checksum` to
+                determine when a file should be copied.  Valid values are either
+                fully qualified paths to files, or URIs.  Currently supported URI
+                types are *puppet* and *file*."
+            @name = :source
+
+            # Ask the file server to describe our file.
+            def describe(source)
+                sourceobj, path = @parent.uri2obj(source)
+                server = sourceobj.server
+
+                begin
+                    desc = server.describe(path)
+                rescue NetworkClientError => detail
+                    self.err "Could not describe %s: %s" %
+                        [path, detail]
+                    return nil
+                end
+
+                args = {}
+                Puppet::Type::PFile::PINPARAMS.zip(
+                    desc.split("\t")
+                ).each { |param, value|
+                    if value =~ /^[0-9]+$/
+                        value = value.to_i
+                    end
+                    unless value.nil?
+                        args[param] = value
+                    end
+                }
+
+                # we can't manage ownership as root, so don't even try
+                unless Process.uid == 0
+                    args.delete(:owner)
+                end
+
+                if args.empty?
+                    return nil
+                else
+                    return args
+                end
+            end
+
+            # This basically calls describe() on our file, and then sets all
+            # of the local states appropriately.  If the remote file is a normal
+            # file then we set it to copy; if it's a directory, then we just mark
+            # that the local directory should be created.
+            def retrieve
+                sum = nil
+
+                unless defined? @shouldorig
+                    raise Puppet::DevError, "No sources defined for %s" %
+                        @parent.name
+                end
+
+                @source = nil
+                
+                # Find the first source that exists.  @shouldorig contains
+                # the sources as specified by the user.
+                @shouldorig.each { |source|
+                    if @stats = self.describe(source)
+                        @source = source
+                        break
+                    end
+                }
+
+                if @stats.nil? or @stats[:type].nil?
+                    @is = :notdescribed
+                    @source = nil
+                    return nil
+                end
+
+                # Take each of the stats and set them as states on the local file
+                # if a value has not already been provided.
+                @stats.each { |stat, value|
+                    next if stat == :checksum
+                    next if stat == :type
+
+                    # was the stat already specified, or should the value
+                    # be inherited from the source?
+                    unless @parent.argument?(stat)
+                        if state = @parent.state(stat)
+                            state.should = value
+                        else
+                            @parent[stat] = value
+                        end
+                    end
+                }
+
+                # If we're a normal file, then set things up to copy the file down.
+                case @stats[:type]
+                when "file":
+                    if sum = @parent.state(:checksum)
+                        if sum.is
+                            if sum.is == :notfound
+                                sum.retrieve
+                            end
+                            @is = sum.is
+                        else
+                            @is = :notfound
+                        end
+                    else
+                        self.info "File does not have checksum"
+                        @is = :notfound
+                    end
+
+                    @should = [@stats[:checksum]]
+
+                    if state = @parent.state(:create)
+                        unless state.should == "file"
+                            self.notice(
+                                "File %s had both create and source enabled" %
+                                    @parent.name
+                            )
+                            @parent.delete(:create)
+                        end
+                    end
+                # If we're a directory, then do not copy anything, and instead just
+                # create the directory using the 'create' state.
+                when "directory":
+                    if state = @parent.state(:create)
+                        unless state.should == "directory"
+                            state.should = "directory"
+                        end
+                    else
+                        @parent[:create] = "directory"
+                        @parent.state(:create).retrieve
+                    end
+                    # we'll let the :create state do our work
+                    @should.clear
+                    @is = true
+                # FIXME We should at least support symlinks, I would think...
+                else
+                    self.err "Cannot use files of type %s as sources" %
+                        @stats[:type]
+                    @should = nil
+                    @is = true
+                end
+            end
+
+            # The special thing here is that we need to make sure that 'should'
+            # is only set for files, not directories.  The processing we're doing
+            # here doesn't really matter, because the @should values will be
+            # overridden when we 'retrieve'.
+            def shouldprocess(source)
+                unless @parent.uri2obj(source)
+                    raise Puppet::Error, "Invalid source %s" % source
+                end
+
+                if ! defined? @stats or @stats.nil?
+                    # stupid hack for now; it'll get overriden
+                    return source
+                else
+                    if @stats[:type] == "directory"
+                        @is = true
+                        return nil
+                    else
+                        return source
+                    end
+                end
+            end
+
+            def sync
+                if @is == :notdescribed
+                    self.retrieve # try again
+                    if @is == :notdescribed
+                        @parent.log "Could not retreive information on %s" %
+                            @parent.name
+                        return nil
+                    end
+                    if @is == @should
+                        return nil
+                    end
+                end
+
+                unless @stats[:type] == "file"
+                    if @stats[:type] == "directory"
+                            [@parent.name, @is.inspect, @should.inspect]
+                    end
+                    raise Puppet::DevError, "Got told to copy non-file %s" %
+                        @parent.name
+                end
+
+                unless defined? @source
+                    raise Puppet::DevError, "Somehow source is still undefined"
+                end
+
+                sourceobj, path = @parent.uri2obj(@source)
+
+                begin
+                    contents = sourceobj.server.retrieve(path)
+                rescue NetworkClientError => detail
+                    self.err "Could not retrieve %s: %s" %
+                        [path, detail]
+                    return nil
+                end
+
+                # FIXME It's stupid that this isn't taken care of in the
+                # protocol.
+                unless sourceobj.server.local
+                    contents = CGI.unescape(contents)
+                end
+
+                if contents == ""
+                    self.notice "Could not retrieve contents for %s" %
+                        @source
+                end
+
+                if FileTest.exists?(@parent.name)
+                    # this makes sure we have a copy for posterity
+                    @backed = @parent.handlebackup
+                end
+
+                # create the file in a tmp location
+                args = [@parent.name + ".puppettmp", 
+                    File::CREAT | File::WRONLY | File::TRUNC]
+
+                # try to create it with the correct modes to start
+                # we should also be changing our effective uid/gid, but...
+                if @parent.should(:mode) and @parent.should(:mode) != :notfound
+                    args.push @parent.should(:mode)
+                end
+
+                # FIXME we should also change our effective user and group id
+
+                begin
+                    File.open(*args) { |f|
+                        f.print contents
+                    }
+                rescue => detail
+                    # since they said they want a backup, let's error out
+                    # if we couldn't make one
+                    raise Puppet::Error, "Could not create %s to %s: %s" %
+                        [@source, @parent.name, detail.message]
+                end
+
+                if FileTest.exists?(@parent.name)
+                    begin
+                        File.unlink(@parent.name)
+                    rescue => detail
+                        self.err "Could not remove %s for replacing: %s" %
+                            [@parent.name, detail]
+                    end
+                end
+
+                begin
+                    File.rename(@parent.name + ".puppettmp", @parent.name)
+                rescue => detail
+                    self.err "Could not rename tmp %s for replacing: %s" %
+                        [@parent.name, detail]
+                end
+
+                return :file_changed
+            end
+        end
+    end
+end
+
+# $Id: source.rb 745 2005-11-16 22:17:29Z luke $

data/lib/puppet/type/pfile/type.rb

@@ -0,0 +1,31 @@
+module Puppet
+    class State
+        class PFileType < Puppet::State
+            require 'etc'
+            @doc = "A read-only state to check the file type."
+            @name = :type
+
+            def shouldprocess(value)
+                raise Puppet::Error, ":type is read-only"
+            end
+            
+            def retrieve
+                if stat = @parent.stat(true)
+                    @is = stat.ftype
+                else
+                    @is = :notfound
+                end
+
+                # so this state is never marked out of sync
+                @should = [@is]
+            end
+
+
+            def sync
+                raise Puppet::Error, ":type is read-only"
+            end
+        end
+    end
+end
+
+# $Id: type.rb 713 2005-10-02 01:56:38Z luke $

data/lib/puppet/type/pfile/uid.rb

@@ -0,0 +1,166 @@
+module Puppet
+    class State
+        class PFileUID < Puppet::State
+            require 'etc'
+            @doc = "To whom the file should belong.  Argument can be user name or
+                user ID."
+            @name = :owner
+            @event = :inode_changed
+
+            def id2name(id)
+                if id.is_a?(Symbol)
+                    return id.to_s
+                end
+                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 name2id(value)
+                if value.is_a?(Symbol)
+                    return value.to_s
+                end
+                begin
+                    user = Etc.getpwnam(value)
+                    if user.uid == ""
+                        return nil
+                    end
+                    return user.uid
+                rescue ArgumentError => detail
+                    return nil
+                end
+            end
+
+            # Determine if the user is valid, and if so, return the UID
+            def validuser?(value)
+                if value =~ /^\d+$/
+                    value = value.to_i
+                end
+
+                if value.is_a?(Integer)
+                    # verify the user is a valid user
+                    if tmp = id2name(value)
+                        return value
+                    else
+                        return false
+                    end
+                else
+                    if tmp = name2id(value)
+                        return tmp
+                    else
+                        return false
+                    end
+                end
+            end
+
+            # We want to print names, not numbers
+            def is_to_s
+                id2name(@is) || @is
+            end
+
+            def should_to_s
+                case self.should
+                when Symbol
+                    self.should.to_s
+                when Integer
+                    id2name(self.should) || self.should
+                when String
+                    self.should
+                else
+                    raise Puppet::DevError, "Invalid uid type %s(%s)" %
+                        [self.should.class, self.should]
+                end
+            end
+
+            def retrieve
+                unless stat = @parent.stat(true)
+                    @is = :notfound
+                    return
+                end
+
+                self.is = 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 @is > 120000
+                    self.warning "current state is silly: %s" % @is
+                    @is = :notfound
+                end
+            end
+
+            # If we're not root, we can check the values but we cannot change
+            # them.  We can't really do any processing here, because users
+            # might not exist yet.  FIXME There's still a bit of a problem here
+            # if the user's UID changes at run time, but we're just going to
+            # have to be okay with that for now, unfortunately.
+            def shouldprocess(value)
+                if tmp = self.validuser?(value)
+                    return tmp
+                else
+                    return value
+                end
+            end
+
+            def sync
+                unless Process.uid == 0
+                    unless defined? @@notifieduid
+                        self.notice "Cannot manage ownership unless running as root"
+                        #@parent.delete(self.name)
+                        @@notifieduid = true
+                    end
+                    return nil
+                end
+
+                user = nil
+                unless user = self.validuser?(self.should)
+                    tmp = self.should
+                    unless defined? @@usermissing
+                        @@usermissing = {}
+                    end
+
+                    if @@usermissing.include?(tmp)
+                        @@usermissing[tmp] += 1
+                    else
+                        self.notice "user %s does not exist" % tmp
+                        @@usermissing[tmp] = 1
+                        return nil
+                    end
+                end
+
+                if @is == :notfound
+                    @parent.stat(true)
+                    self.retrieve
+                    if @is == :notfound
+                        self.info "File does not exist; cannot set owner"
+                        return nil
+                    end
+                    if self.insync?
+                        return nil
+                    end
+                    #self.debug "%s: after refresh, is '%s'" % [self.class.name,@is]
+                end
+
+                begin
+                    File.chown(user, nil, @parent[:path])
+                rescue => detail
+                    raise Puppet::Error, "Failed to set owner to '%s': %s" %
+                        [user, detail]
+                end
+
+                return :inode_changed
+            end
+        end
+    end
+end
+
+# $Id: uid.rb 749 2005-11-22 05:33:42Z luke $