puppet 0.9.2 → 0.13.0

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

@@ -1,316 +0,0 @@
-#!/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/test/other/state.rb

@@ -1,106 +0,0 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../../../../language/trunk"
-end
-
-require 'puppet'
-require 'puppettest'
-require 'puppet/storage'
-require 'test/unit'
-
-# $Id: state.rb 724 2005-10-22 22:27:20Z luke $
-
-class StorageTestingClass
-end
-
-class TestStorage < Test::Unit::TestCase
-	include TestPuppet
-    def disabled_setup
-        Puppet[:loglevel] = :debug if __FILE__ == $0
-        Puppet[:checksumfile] = "/var/tmp/puppetteststate"
-
-        @oldconf = Puppet[:puppetconf]
-        Puppet[:puppetconf] = "/tmp/storagetesting"
-        @oldvar = Puppet[:puppetvar]
-        Puppet[:puppetvar] = "/tmp/storagetesting"
-
-        @@tmpfiles << "/tmp/storagetesting"
-    end
-
-    def teardown
-        #system("rm -f %s" % Puppet[:checksumfile])
-        Puppet::Storage.clear
-
-        #Puppet[:puppetconf] = @oldconf
-        #Puppet[:puppetvar] = @oldvar
-        super
-    end
-
-    def test_simple
-        state = nil
-        assert_nothing_raised {
-            Puppet::Storage.load
-        }
-        assert_nothing_raised {
-            state = Puppet::Storage.state(Puppet::Type)
-        }
-        assert(state)
-        state["/etc/passwd"] = ["md5","9ebebe0c02445c40b9dc6871b64ee416"]
-        assert_nothing_raised {
-            Puppet::Storage.store
-        }
-
-        # clear the memory, so we're sure we're hitting the state file
-        assert_nothing_raised {
-            Puppet::Storage.clear
-            Puppet::Storage.init
-        }
-        assert_nothing_raised {
-            Puppet::Storage.load
-        }
-        assert_equal(
-            ["md5","9ebebe0c02445c40b9dc6871b64ee416"],
-            Puppet::Storage.state(Puppet::Type)["/etc/passwd"]
-        )
-    end
-
-    def test_instance
-        file = nil
-        state = nil
-        assert_nothing_raised {
-            file = Puppet::Type::PFile.create(
-                :path => "/etc/passwd"
-            )
-        }
-        assert_nothing_raised {
-            Puppet::Storage.load
-        }
-        assert_nothing_raised {
-            state = Puppet::Storage.state(file)
-        }
-        assert(state)
-    end
-
-    def test_update
-        state = Puppet::Storage.state(StorageTestingClass)
-        state["testing"] = "yayness"
-        Puppet::Storage.store
-        assert(FileTest.exists?(Puppet[:checksumfile]))
-    end
-
-    def test_hashstorage
-        state = Puppet::Storage.state(StorageTestingClass)
-        hash = {
-            :yay => "boo",
-            :rah => "foo"
-        }
-        state["testing"] = hash
-        Puppet::Storage.store
-        Puppet::Storage.clear
-        Puppet::Storage.init
-        Puppet::Storage.load
-        state = Puppet::Storage.state(StorageTestingClass)
-        assert_equal(hash, state["testing"])
-    end
-end