puppet 0.9.2

data/lib/puppet/type/tidy.rb

@@ -0,0 +1,183 @@
+#!/usr/local/bin/ruby -w
+
+# $Id: tidy.rb 731 2005-10-26 04:44:25Z luke $
+
+require 'etc'
+require 'puppet/type/state'
+require 'puppet/type/pfile'
+
+module Puppet
+    # okay, how do we deal with parameters that don't have operations
+    # associated with them?
+    class State
+        class TidyUp < Puppet::State
+            require 'etc'
+
+            @nodoc = true
+            @name = :tidyup
+
+            def age(stat)
+                type = nil
+                if stat.ftype == "directory"
+                    type = :mtime
+                else
+                    type = @parent[:type] || :atime
+                end
+                
+                return Integer(Time.now - stat.send(type))
+            end
+
+            def retrieve
+                stat = nil
+                unless stat = @parent.stat
+                    @is = :unknown
+                    return
+                end
+
+                @is = [:age, :size].collect { |param|
+                    if @parent[param]
+                        self.send(param, stat)
+                    end
+                }.reject { |p| p == false or p.nil? }
+            end
+
+            def size(stat)
+                return stat.size
+            end
+
+            def sync
+                file = @parent[:path]
+                case File.lstat(file).ftype
+                when "directory":
+                    if @parent[:rmdirs]
+                        subs = Dir.entries(@parent[:path]).reject { |d|
+                            d == "." or d == ".."
+                        }.length
+                        if subs > 0
+                            self.info "%s has %s children; not tidying" %
+                                [@parent[:path], subs]
+                            self.info Dir.entries(@parent[:path]).inspect
+                        else
+                            Dir.rmdir(@parent[:path])
+                        end
+                    else
+                        self.debug "Not tidying directories"
+                        return nil
+                    end
+                when "file":
+                    @parent.handlebackup(file)
+                    File.unlink(file)
+                when "symlink":     File.unlink(file)
+                else
+                    raise Puppet::Error, "Cannot tidy files of type %s" %
+                        File.lstat(file).ftype
+                end
+
+                return :file_tidied
+            end
+        end
+    end
+
+    class Type
+        class Tidy < PFile
+
+            # class instance variable
+            @states = [
+                Puppet::State::TidyUp
+            ]
+
+            @parameters = [
+                :path,
+                :age,
+                :size,
+                :type,
+                :backup,
+                :rmdirs,
+                :recurse
+            ]
+
+            @paramdoc[:age] = "Tidy files whose age is equal to or greater than
+                the specified number of days."
+            @paramdoc[:size] = "Tidy files whose size is equal to or greater than
+                the specified size.  Unqualified values are in kilobytes, but
+                *b*, *k*, and *m* can be appended to specify *bytes*, *kilobytes*,
+                and *megabytes*, respectively.  Only the first character is
+                significant, so the full word can also be used."
+            @paramdoc[:type] = "Set the mechanism for determining age.  Access
+                time is the default mechanism, but modification."
+            @paramdoc[:recurse] = "If target is a directory, recursively descend
+                into the directory looking for files to tidy."
+            @paramdoc[:rmdirs] = "Tidy directories in addition to files."
+            @doc = "Remove unwanted files based on specific criteria."
+            @name = :tidy
+            @namevar = :path
+
+            @depthfirst = true
+
+            def initialize(hash)
+                super
+
+                unless  @parameters.include?(:age) or
+                        @parameters.include?(:size)
+                    unless FileTest.directory?(self[:path])
+                        # don't do size comparisons for directories
+                        raise Puppet::Error, "Tidy must specify size, age, or both"
+                    end
+                end
+
+                # only allow backing up into filebuckets
+                unless self[:backup].is_a? Puppet::Client::Dipper
+                    self[:backup] = false
+                end
+                self[:tidyup] = [:age, :size].collect { |param|
+                    @parameters[param]
+                }.reject { |p| p == false }
+            end
+
+            def paramage=(age)
+                @parameters[:age] = age
+                case age
+                when /^[0-9]+$/, /^[0-9]+[dD]/:
+                    @parameters[:age] = Integer(age.gsub(/[^0-9]+/,'')) *
+                        60 * 60 * 24
+                when /^[0-9]+$/, /^[0-9]+[hH]/:
+                    @parameters[:age] = Integer(age.gsub(/[^0-9]+/,'')) * 60 * 60
+                when /^[0-9]+[mM]/:
+                    @parameters[:age] = Integer(age.gsub(/[^0-9]+/,'')) * 60
+                when /^[0-9]+[sS]/:
+                    @parameters[:age] = Integer(age.gsub(/[^0-9]+/,''))
+                else
+                    raise Puppet::Error.new("Invalid tidy age %s" % age)
+                end
+            end
+
+            def paramsize=(size)
+                if FileTest.directory?(self[:path])
+                    # don't do size comparisons for directories
+                    return
+                end
+                case size
+                when /^[0-9]+$/, /^[0-9]+[kK]/:
+                    @parameters[:size] = Integer(size.gsub(/[^0-9]+/,'')) * 1024
+                when /^[0-9]+[bB]/:
+                    @parameters[:size] = Integer(size.gsub(/[^0-9]+/,''))
+                when /^[0-9]+[mM]/:
+                    @parameters[:size] = Integer(size.gsub(/[^0-9]+/,'')) *
+                        1024 * 1024
+                else
+                    raise Puppet::Error.new("Invalid tidy size %s" % size)
+                end
+            end
+
+            def paramtype=(type)
+                case type
+                when "atime", "mtime", "ctime":
+                    @parameters[:type] = type.intern
+                else
+                    raise Puppet::Error.new("Invalid tidy type %s" % type)
+                end
+            end
+
+        end # Puppet::Type::Symlink
+    end # Puppet::Type
+end

data/lib/puppet/type/typegen.rb

@@ -0,0 +1,149 @@
+#!/usr/local/bin/ruby -w
+
+# $Id: typegen.rb 576 2005-08-23 16:09:14Z luke $
+
+# parse and write configuration files using objects with minimal parsing abilities
+
+require 'etc'
+require 'puppet/type'
+
+module Puppet
+    class Type
+class TypeGenerator < Puppet::Type
+    include Enumerable
+
+    @doc = "..."
+    @namevar = :name
+    @name = :typegen
+    @abstract = true
+
+    @parameters = [:name]
+    @states = []
+
+    @paramdoc[:name] = "..."
+
+    #---------------------------------------------------------------
+    def TypeGenerator.[](name)
+        return @subclasses[name]
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def TypeGenerator.inherited(subclass)
+        #subclass.initvars
+        super(subclass)
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    # we don't need to 'super' here because type.rb already runs initvars
+    # in Type#inherited
+    def TypeGenerator.initvars
+        @subclasses = Hash.new(nil)
+        super
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def TypeGenerator.name
+        return @name
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def TypeGenerator.name=(name)
+        @name = name
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def TypeGenerator.namevar
+        return @namevar || :name
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def TypeGenerator.namevar=(namevar)
+        debug "Setting namevar for %s to %s" % [self,namevar]
+        unless namevar.is_a? Symbol
+            namevar = namevar.intern
+        end
+        @namevar = namevar
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def TypeGenerator.newtype(arghash)
+        unless defined? @parameters
+            raise "Type %s is set up incorrectly" % self
+        end
+
+        arghash.each { |key,value|
+            if key.class != Symbol
+                # convert to a symbol
+                arghash[key.intern] = value
+                arghash.delete key
+                key = key.intern
+            end
+            unless @parameters.include?(key)
+                raise "Invalid argument %s on class %s" %
+                    [key,self]
+            end
+
+        }
+
+        # turn off automatically checking all arguments
+        #@parameters.each { |option|
+        #    unless arghash.include?(option)
+        #        p arghash
+        #        raise "Must pass %s to class %s" %
+        #            [option,self]
+        #    end
+        #}
+
+        if @subclasses.include?(arghash[:name])
+            raise "File type %s already exists" % arghash[:name]
+        end
+
+        klassname = arghash[:name].capitalize
+
+        # create the file type
+        Puppet::Type.module_eval "
+            class %s < %s
+            end" % [klassname,self]
+        klass = eval(klassname)
+        klass.name = arghash[:name]
+
+        @subclasses[arghash[:name]] = klass
+
+        arghash.each { |option,value|
+            method = option.id2name + "="
+            if klass.respond_to?(method)
+                #debug "Setting %s on %s to '%s'" % [option,klass,arghash[option]]
+                klass.send(method,arghash[option])
+            else
+                debug "%s does not respond to %s" % [klass,method]
+            end
+        }
+
+        # i couldn't get the method definition stuff to work
+        # oh well
+        # probably wouldn't want it in the end anyway
+        #@parameters.each { |option|
+        #    writer = option.id2name + "="
+        #    readproc = proc { eval("@" + option.id2name) }
+        #    klass.send(:define_method,option,readproc)
+        #    writeproc = proc { |value| module_eval("@" + option.id2name) = value }
+        #    klass.send(:define_method,writer,writeproc)
+        #    klass.send(writer,hash[option])
+        #}
+
+        #Puppet::Type.inherited(klass)
+        Puppet::Type.buildtypehash
+        return klass
+    end
+    #---------------------------------------------------------------
+end
+#---------------------------------------------------------------
+end
+end

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

@@ -0,0 +1,243 @@
+#!/usr/local/bin/ruby -w
+
+# $Id: filerecord.rb 576 2005-08-23 16:09:14Z luke $
+
+# parse and write configuration files using objects with minimal parsing abilities
+
+require 'etc'
+require 'puppet/type'
+require 'puppet/type/typegen'
+
+#---------------------------------------------------------------
+class Puppet::Type::FileRecord < Puppet::Type::TypeGenerator
+    attr_accessor :fields, :namevar, :splitchar, :object
+
+    @parameters = [:name, :splitchar, :fields, :namevar, :filetype, :regex, :joinchar]
+    @abstract = true
+    @metaclass = true
+
+    @namevar = :name
+    @name = :filerecord
+
+    #---------------------------------------------------------------
+    def FileRecord.newtype(hash)
+        #shortname = hash[:name]
+        #hash[:name] = hash[:filetype].name.capitalize + hash[:name].capitalize
+        klass = super(hash)
+        #klass.name = shortname
+        klass.parameters = hash[:fields]
+        #klass.namevar = hash[:namevar]
+        klass.filetype = hash[:filetype]
+        hash.delete(:fields)
+        hash.delete(:namevar)
+        return klass
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.fields=(ary)
+        @fields = ary
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.fields
+        return @fields
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.filetype
+        @filetype
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.filetype=(filetype)
+        if filetype.is_a?(String)
+            @filetype = Puppet::Type::FileType[filetype]
+        elsif filetype.is_a?(Puppet::Type::FileType)
+            @filetype = filetype
+        else
+            raise "Cannot use objects of type %s as filetypes" % filetype 
+        end
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.joinchar=(char)
+        @joinchar = char
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.joinchar
+        unless defined? @joinchar
+            @joinchar = nil
+        end
+        @joinchar
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.match(object,line)
+        matchobj = nil
+        begin
+            matchobj = self.regex.match(line)
+        rescue RegexpError => detail
+            raise
+        end
+
+        if matchobj.nil?
+            return nil
+        else
+            child = self.new(object)
+            child.match = matchobj
+            return child
+        end
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.regex=(regex)
+        @regex = regex
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.regex
+        # the only time @regex is allowed to be nil is if @splitchar is defined
+        if @regex.nil?
+            if @splitchar.nil?
+                raise "%s defined incorrectly -- splitchar or regex must be specified" %
+                    self
+            else
+                ary = []
+                text = @fields.collect { |field|
+                    "([^%s]*)" % @splitchar
+                }.join(@splitchar)
+                begin
+                    @regex = Regexp.new(text)
+                rescue RegexpError => detail
+                    raise "Could not create splitregex from %s" % @splitchar
+                end
+                debug("Created regexp %s" % @regex)
+            end
+        elsif @regex.is_a?(String)
+            begin
+                @regex = Regexp.new(@regex)
+            rescue RegexpError => detail
+                raise "Could not create splitregex from %s" % @regex
+            end
+        end
+        return @regex
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.splitchar=(char)
+        @splitchar = char
+        #@regex = %r{#{char}}
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def FileRecord.splitchar
+        return @splitchar
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    #def [](field)
+    #    @parameters[field]
+    #end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    #def []=(field,value)
+    #    @parameters[field] = value
+    #end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def ==(other)
+        unless self.class == other.class
+            return false
+        end
+
+        unless self.name == other.name
+            return false
+        end
+        @parameters.keys { |field|
+            unless self[field] == other[field]
+                debug("%s -> %s has changed" % [self.name, field])
+                return false
+            end
+        }
+        return true
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def initialize(hash)
+        if self.class == Puppet::Type::FileRecord
+            self.class.newtype(hash)
+            return
+        end
+        @parameters = {}
+        #if block_given?
+        #    yield self
+        #end
+        super(hash)
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def match=(matchobj)
+        @match = matchobj
+        #puts "captures are [%s]" % [matchobj.captures]
+        self.class.fields.zip(matchobj.captures) { |field,value|
+            @parameters[field] = value
+            #puts "%s => %s" % [field,@parameters[field]]
+        }
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def record=(record)
+        begin
+            ary = record.split(self.class.regex)
+        rescue RegexpError=> detail
+            raise RegexpError.new(detail)
+        end
+        self.class.fields.each { |field|
+            @parameters[field] = ary.shift
+            #puts "%s => %s" % [field,@parameters[field]]
+        }
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def name
+        if @parameters.include?(self.class.namevar)
+            return @parameters[self.class.namevar]
+        else
+            raise "No namevar '%s' for objects of type %s" %
+                [self.class.namevar,self.class.to_s]
+        end
+    end
+    #---------------------------------------------------------------
+
+    #---------------------------------------------------------------
+    def to_s
+        ary = self.class.fields.collect { |field|
+            if ! @parameters.include?(field)
+                raise "Object %s is missing field %s" % [self.name,field]
+            else
+                @parameters[field]
+            end
+        }.join(self.class.joinchar || self.class.splitchar)
+    end
+    #---------------------------------------------------------------
+end
+#---------------------------------------------------------------