puppet 0.9.2

data/lib/puppet/type/typegen/filetype.rb

@@ -0,0 +1,316 @@
+#!/usr/local/bin/ruby -w
+
+# $Id: filetype.rb 576 2005-08-23 16:09:14Z luke $
+
+# parse and write configuration files using objects with minimal parsing abilities
+
+require 'puppet/type'
+require 'puppet/type/typegen'
+
+class Puppet::Type::FileType < Puppet::Type::TypeGenerator
+    attr_accessor :childtype
+
+    @parameters = [:name, :linesplit, :escapednewlines]
+    #@abstract = true
+    @metaclass = true
+
+    @namevar = :name
+    @name = :filetype
+
+    @modsystem = true
+
+    #---------------------------------------------------------------
+    def FileType.newtype(hash)
+        unless hash.include?(:linesplit)
+            hash[:linesplit] = "\n"
+        end
+
+        # i don't think there's any reason to 'super' this
+        #klass = Puppet::Type::TypeGenerator.newtype(hash)
+        klass = super(hash)
+
+        klass.escapednewlines = true
+        klass.namevar = :name
+        klass.parameters = [:name, :path, :complete]
+
+        #klass.childtype = Puppet::Type::FileRecord.newtype(
+        #    :name => hash[:name] + "_record",
+        #    :splitchar => hash[:recordsplit],
+        #    :fields => hash[:fields],
+        #    :namevar => hash[:namevar]
+        #)
+        #klass.addrecord(
+        #    :name => hash[:name] + "_record",
+        #    :splitchar => hash[:recordsplit],
+        #    :fields => hash[:fields],
+        #    :namevar => hash[:namevar]
+        #)
+
+        return klass
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # currently not used
+    def FileType.addrecord(hash)
+        unless defined? @records
+            @records = {}
+        end
+        hash[:filetype] = self
+        
+        # default to the naming field being the first field provided
+        unless hash.include?(:namevar)
+            hash[:namevar] = hash[:fields][0]
+        end
+
+        recordtype = Puppet::Type::FileRecord.newtype(hash)
+        @records[recordtype.name] = recordtype
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileType.records
+        return @records
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileType.escapednewlines=(value)
+        @escnlines = value
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileType.escapednewlines
+        if ! defined? @escnlines or @escnlines.nil?
+            return false
+        else
+            return @escnlines
+        end
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileType.childtype
+        unless defined? @childtype
+            @childtype = nil
+        end
+        return @childtype
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileType.childtype=(childtype)
+        @childtype = childtype
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileType.regex
+        return @regex
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileType.linesplit=(linesplit)
+        @regex = %r{#{linesplit}}
+        @linesplit = linesplit
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileType.linesplit
+        return @linesplit
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    #def [](name)
+    #    return @childhash[name]
+    #end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    #def []=(name,value)
+    #end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # we don't really have a 'less-than/greater-than' sense here
+    # so i'm sticking with 'equals' until those make sense
+    def ==(other)
+        unless self.children.length == other.children.length
+            debug("file has %s records instead of %s" %
+                [self.children.length, other.children.length])
+            return self.children.length == other.children.length
+        end
+        equal = true
+        self.zip(other.children) { |schild,ochild|
+            unless schild == ochild
+                debug("%s has changed in %s" %
+                    [schild.name,self.name])
+                equal = false
+                break
+            end
+        }
+
+        return equal
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # create a new record with a block
+    def add(type,&block)
+        obj = self.class.records[type].new(self,&block)
+        debug("adding %s" % obj.name)
+        @childary.push(obj)
+        @childhash[obj.name] = obj
+
+        return obj
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def children
+        return @childary
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # remove a record
+    def delete(name)
+        if @childhash.has_key?(name)
+            child = @childhash[name]
+
+            @childhash.delete(child)
+            @childary.delete(child)
+        else
+            raise "No such entry %s" % name
+        end
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def each
+        @childary.each { |child|
+            yield child
+        }
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # create a new file
+    def initialize(hash)
+        # if we are the FileType object itself, we create a new type
+        # otherwise, we create an instance of an existing type
+        # yes, this should be more straightforward
+        if self.class == Puppet::Type::FileType
+            self.class.newtype(hash)
+            return
+        end
+        debug "Creating new '%s' file with path '%s' and name '%s'" %
+            [self.class.name,hash["path"],hash[:name]]
+        debug hash.inspect
+        @file = hash["path"]
+
+        @childary = []
+        @childhash = {}
+        super
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # this is where we're pretty different from other objects
+    # we can choose to either reparse the existing file and compare
+    # the objects, or we can write our file out and do an
+    # text comparison
+    def insync?
+        tmp = self.class.new(@file)
+        tmp.retrieve
+
+        return self == tmp
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    #def name
+    #    return @file
+    #end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # read the whole file in and turn it into each of the appropriate
+    # objects
+    def retrieve
+        str = ""
+        ::File.open(@file) { |fname|
+            fname.each { |line|
+                str += line
+            }
+        }
+
+        if self.class.escapednewlines
+            endreg = %r{\\\n\s*}
+            str.gsub!(endreg,'')
+        end
+        @childary = str.split(self.class.regex).collect { |line|
+            childobj = nil
+            self.class.records.each { |name,recordtype|
+                if childobj = recordtype.match(self,line)
+                    break
+                end
+            }
+            if childobj.nil?
+                warning("%s: could not match %s" % [self.name,line])
+                #warning("could not match %s" % line)
+                next
+            end
+
+            begin
+                debug("got child: %s(%s)" % [childobj.class,childobj.to_s])
+            rescue NoMethodError
+                warning "Failed: %s" % childobj
+            end
+            childobj
+        }.reject { |child|
+            child.nil?
+        }
+
+        @childary.each { |child|
+            begin
+                @childhash[child.name] = child
+            rescue NoMethodError => detail
+                p child
+                p child.class
+                puts detail
+                exit
+            end
+        }
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def sync
+        #unless self.insync?
+            self.write
+        #end
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def to_s
+        return @childary.collect { |child|
+            child.to_s
+        }.join(self.class.linesplit) + self.class.linesplit
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def write
+        ::File.open(@file, "w") { |file|
+            file.write(self.to_s)
+        }
+    end
+    #---------------------------------------------------------------
+end
+#---------------------------------------------------------------

data/lib/puppet/type/user.rb

@@ -0,0 +1,290 @@
+require 'etc'
+require 'facter'
+require 'puppet/type/state'
+require 'puppet/type/nameservice'
+
+module Puppet
+    class State
+        module UserUID
+            def self.doc
+                "The user ID.  Must be specified numerically.  For new users
+                being created, if no user ID is specified then one will be
+                chosen automatically, which will likely result in the same user
+                having different IDs on different systems, which is not
+                recommended."
+            end
+
+            def self.name
+                :uid
+            end
+
+            def autogen
+                highest = 0
+                Etc.passwd { |user|
+                    if user.uid > highest
+                        unless user.uid > 65000
+                            highest = user.uid
+                        end
+                    end
+                }
+
+                return highest + 1
+            end
+
+            def shouldprocess(value)
+                case value
+                when String
+                    if value =~ /^[-0-9]+$/
+                        value = Integer(value)
+                    end
+                when Symbol
+                    unless value == :notfound or value == :auto
+                        raise Puppet::DevError, "Invalid UID %s" % value
+                    end
+
+                    if value == :auto
+                        value = autogen()
+                    end
+                end
+
+                return value
+            end
+        end
+
+        module UserGID
+            def self.doc
+                "The user's primary group.  Can be specified numerically or
+                by name."
+            end
+
+            def self.name
+                :gid
+            end
+
+            def shouldprocess(gid)
+                method = :getgrgid
+                case gid
+                when String
+                    if gid =~ /^[-0-9]+$/
+                        gid = Integer(gid)
+                    else
+                        method = :getgrnam
+                    end
+                when Symbol
+                    unless gid == :auto or gid == :notfound
+                        raise Puppet::DevError, "Invalid GID %s" % gid
+                    end
+                    # these are treated specially by sync()
+                    return gid
+                end
+
+                # FIXME this should really check to see if we already have a
+                # group ready to be managed; if so, then we should just mark it
+                # as a prereq
+                begin
+                    ginfo = Etc.send(method, gid)
+                rescue ArgumentError => detail
+                    raise Puppet::Error, "Could not find group %s: %s" %
+                        [gid, detail]
+                end
+
+                self.notice "setting gid to %s" % ginfo.gid.inspect
+                return ginfo.gid
+            end
+        end
+
+        module UserComment
+            def self.doc
+                "A description of the user.  Generally is a user's full name."
+            end
+
+            def self.name
+                :comment
+            end
+
+            def self.optional?
+                true
+            end
+
+            def self.posixmethod
+                :gecos
+            end
+        end
+
+        module UserHome
+            def self.doc
+                "The home directory of the user.  The directory must be created
+                separately and is not currently checked for existence."
+            end
+
+            def self.name
+                :home
+            end
+
+            def self.posixmethod
+                :dir
+            end
+        end
+
+        module UserShell
+            def self.doc
+                "The user's login shell.  The shell must exist and be
+                executable."
+            end
+
+            def self.name
+                :shell
+            end
+        end
+
+        # these three states are all implemented differently on each platform,
+        # so i'm disabling them for now
+
+        # FIXME Puppet::State::UserLocked is currently non-functional
+        module UserLocked 
+            def self.doc
+                "The expected return code.  An error will be returned if the
+                executed command returns something else."
+            end
+
+            def self.name
+                :locked
+            end
+        end
+
+        # FIXME Puppet::State::UserExpire is currently non-functional
+        module UserExpire 
+            def self.doc
+                "The expected return code.  An error will be returned if the
+                executed command returns something else."
+            end
+
+            def self.name; :expire; end
+        end
+
+        # FIXME Puppet::State::UserInactive is currently non-functional
+        module UserInactive 
+            def self.doc
+                "The expected return code.  An error will be returned if the
+                executed command returns something else."
+            end
+
+            def self.name; :inactive; end
+        end
+
+    end
+
+    class Type
+        class User < Type
+            statenames = [
+                "UserUID",
+                "UserGID",
+                "UserComment",
+                "UserHome",
+                "UserShell"
+            ]
+            @statemodule = nil
+            case Facter["operatingsystem"].value
+            when "Darwin":
+                @statemodule = Puppet::NameService::NetInfo
+            else
+                @statemodule = Puppet::NameService::ObjectAdd
+            end
+
+            class << self
+                attr_accessor :netinfodir
+                attr_accessor :statemodule
+            end
+
+            @states = []
+
+            @states = statenames.collect { |name|
+                fullname = @statemodule.to_s + "::" + name
+                begin
+                    eval(fullname)
+                rescue NameError
+                    raise Puppet::DevError, "Could not retrieve state class %s" %
+                        fullname
+                end
+            }.each { |klass|
+                klass.complete
+            }
+
+            @parameters = [
+                :name
+            ]
+
+            @paramdoc[:name] = "User name.  While limitations are determined for
+                each operating system, it is generally a good idea to keep to the
+                degenerate 8 characters, beginning with a letter."
+
+            @doc = "Manage users.  Currently can create and modify users, but
+                cannot delete them.  Theoretically all of the parameters are
+                optional, but if no parameters are specified the comment will
+                be set to the user name in order to make the internals work out
+                correctly."
+            @name = :user
+            @namevar = :name
+
+            @netinfodir = "users"
+
+            def exists?
+                self.class.statemodule.exists?(self)
+            end
+
+            def getinfo(refresh = false)
+                if @userinfo.nil? or refresh == true
+                    begin
+                        @userinfo = Etc.getpwnam(self[:name])
+                    rescue ArgumentError => detail
+                        @userinfo = nil
+                    end
+                end
+
+                @userinfo
+            end
+
+            def initialize(hash)
+                @userinfo = nil
+                super
+
+                # Verify that they have provided everything necessary, if we
+                # are trying to manage the user
+                if self.managed?
+                    self.class.states.each { |state|
+                        next if @states.include?(state.name)
+
+                        unless state.autogen? or state.optional?
+                            if state.method_defined?(:autogen)
+                                self[state.name] = :auto
+                            else
+                                raise Puppet::Error,
+                                    "Users require a value for %s" % state.name
+                            end
+                        end
+                    }
+
+                    if @states.empty?
+                        self[:comment] = self[:name]
+                    end
+                end
+            end
+
+            def retrieve
+                info = self.getinfo(true)
+
+                if info.nil?
+                    # the user does not exist
+                    @states.each { |name, state|
+                        state.is = :notfound
+                    }
+                    return
+                else
+                    super
+                end
+            end
+        end
+    end
+end
+
+# $Id: user.rb 731 2005-10-26 04:44:25Z luke $