puppet 0.18.4 → 0.22.4

data/lib/puppet/util/rails/collection_merger.rb

@@ -0,0 +1,42 @@
+module Puppet::Util::CollectionMerger
+    # Merge new values with the old list.  This is only necessary
+    # because deletion seems to mess things up on unsaved objects.
+    def collection_merge(collection, args)
+        remove = []
+        list = args[:existing] || send(collection)
+        hash = args[:updates]
+        list.each do |object|
+            name = object.name
+            if existing = hash[name]
+                hash.delete(name)
+                if existing.respond_to?(:to_rails)
+                    existing.to_rails(self, object)
+                elsif args.include?(:modify)
+                    args[:modify].call(object, name, existing)
+                else
+                    raise ArgumentError, "Must pass :modify or the new objects must respond to :to_rails"
+                end
+            else
+                remove << object
+            end
+        end
+
+        # Make a new rails object for the rest of them
+        hash.each do |name, object|
+            if object.respond_to?(:to_rails)
+                object.to_rails(self)
+            elsif args.include?(:create)
+                args[:create].call(name, object)
+            else
+                raise ArgumentError, "Must pass :create or the new objects must respond to :to_rails"
+            end
+        end
+
+        # Now remove anything necessary.
+        remove.each do |object|
+            send(collection).delete(object)
+        end
+    end
+end
+
+# $Id: collection_merger.rb 2350 2007-03-24 21:24:29Z luke $

data/lib/puppet/util/storage.rb

@@ -0,0 +1,103 @@
+require 'yaml'
+require 'sync'
+
+# a class for storing state
+class Puppet::Util::Storage
+    include Singleton
+    include Puppet::Util
+
+    def initialize
+        self.class.load
+    end
+
+    # Return a hash that will be stored to disk.  It's worth noting
+    # here that we use the object's full path, not just the name/type
+    # combination.  At the least, this is useful for those non-isomorphic
+    # types like exec, but it also means that if an object changes locations
+    # in the configuration it will lose its cache.
+    def self.cache(object)
+        if object.is_a? Puppet::Type
+            # We used to store things by path, now we store them by ref.
+            # In oscar(0.20.0) this changed to using the ref.
+            if @@state.include?(object.path)
+                @@state[object.ref] = @@state[object.path]
+                @@state.delete(object.path)
+            end
+            name = object.ref
+        elsif object.is_a?(Symbol)
+            name = object
+        else
+            raise ArgumentError, "You can only cache information for Types and symbols"
+        end
+
+        return @@state[name] ||= {}
+    end
+
+    def self.clear
+        @@state.clear
+        Storage.init
+    end
+
+    def self.init
+        @@state = {}
+        @@splitchar = "\t"
+    end
+
+    self.init
+
+    def self.load
+        Puppet.config.use(:puppet)
+
+        unless File.exists?(Puppet[:statefile])
+            unless defined? @@state and ! @@state.nil?
+                self.init
+            end
+            return
+        end
+        Puppet::Util.benchmark(:debug, "Loaded state") do
+            Puppet::Util.readlock(Puppet[:statefile]) do |file|
+                begin
+                    @@state = YAML.load(file)
+                rescue => detail
+                    Puppet.err "Checksumfile %s is corrupt (%s); replacing" %
+                        [Puppet[:statefile], detail]
+                    begin
+                        File.rename(Puppet[:statefile],
+                            Puppet[:statefile] + ".bad")
+                    rescue
+                        raise Puppet::Error,
+                            "Could not rename corrupt %s; remove manually" %
+                            Puppet[:statefile]
+                    end
+                end
+            end
+        end
+
+        unless @@state.is_a?(Hash)
+            Puppet.err "State got corrupted"
+            self.init
+        end
+
+        #Puppet.debug "Loaded state is %s" % @@state.inspect
+    end
+
+    def self.stateinspect
+        @@state.inspect
+    end
+
+    def self.store
+        Puppet.debug "Storing state"
+
+        unless FileTest.exist?(Puppet[:statefile])
+            Puppet.info "Creating state file %s" % Puppet[:statefile]
+        end
+
+        Puppet::Util.benchmark(:debug, "Stored state") do
+            Puppet::Util.writelock(Puppet[:statefile], 0660) do |file|
+                file.print YAML.dump(@@state)
+            end
+        end
+    end
+end
+
+# $Id: storage.rb 2178 2007-02-07 23:56:59Z luke $

data/lib/puppet/util/subclass_loader.rb

@@ -0,0 +1,83 @@
+# A module for loading subclasses into an array and retrieving
+# them by name.  Also sets up a method for each class so
+# that you can just do Klass.subclass, rather than Klass.subclass(:subclass).
+module Puppet::Util::SubclassLoader
+    attr_accessor :loader, :classloader
+
+    # Iterate over each of the subclasses.
+    def each
+        @subclasses ||= []
+        @subclasses.each { |c| yield c }
+    end
+
+    # The hook method that sets up subclass loading.  We need the name
+    # of the method to create and the path in which to look for them.
+    def handle_subclasses(name, path)
+        unless self.is_a?(Class)
+            raise ArgumentError, "Must be a class to use SubclassLoader"
+        end
+        @subclasses = []
+        @loader = Puppet::Util::Autoload.new(self,
+            path, :wrap => false
+        )
+
+        @subclassname = name
+
+        @classloader = self
+
+        # Now create a method for retrieving these subclasses by name.  Note
+        # that we're defining a class method here, not an instance.
+        meta_def(name) do |subname|
+            subname = subname.to_s.downcase
+        
+            unless c = @subclasses.find { |c| c.name.to_s.downcase == subname }
+                loader.load(subname)
+                c = @subclasses.find { |c| c.name.to_s.downcase == subname }
+
+                # Now make the method that returns this subclass.  This way we
+                # normally avoid the method_missing method.
+                if c and ! respond_to?(subname)
+                    define_method(subname) { c }
+                end
+            end
+            return c
+        end
+    end
+
+    # Add a new class to our list.  Note that this has to handle subclasses of
+    # subclasses, thus the reason we're keeping track of the @@classloader.
+    def inherited(sub)
+        @subclasses ||= []
+        @subclasses << sub
+        sub.classloader = self.classloader
+        if self.classloader == self
+            @subclasses << sub
+        else
+            @classloader.inherited(sub)
+        end
+    end
+
+    # See if we can load a class.
+    def method_missing(method, *args)
+        unless self == self.classloader
+            super
+        end
+        return nil unless defined? @subclassname
+        if c = self.send(@subclassname, method)
+            return c
+        else
+            return nil
+        end
+    end
+
+    # Retrieve or calculate a name.
+    def name
+        unless defined? @name
+            @name = self.to_s.sub(/.+::/, '').intern
+        end
+
+        return @name
+    end
+end
+
+# $Id: subclass_loader.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/util/suidmanager.rb

@@ -0,0 +1,86 @@
+require 'facter'
+require 'puppet/util/warnings'
+
+module Puppet::Util::SUIDManager
+    include Puppet::Util::Warnings
+
+    platform = Facter["kernel"].value
+    [:uid=, :gid=, :uid, :gid].each do |method|
+        define_method(method) do |*args|
+            # NOTE: 'method' is closed here.
+            newmethod = method
+
+            if platform == "Darwin" and (method == :uid= or method == :gid=)
+                Puppet::Util::Warnings.warnonce "Cannot change real UID on Darwin"
+                newmethod = ("e" + method.to_s).intern
+            end
+
+            return Process.send(newmethod, *args)
+        end
+        module_function method
+    end
+
+    [:euid=, :euid, :egid=, :egid].each do |method|
+        define_method(method) do |*args|
+            Process.send(method, *args)
+        end
+        module_function method
+    end
+
+    def asuser(new_euid=nil, new_egid=nil)
+        # Unless we're root, don't do a damn thing.
+        unless Process.uid == 0
+            return yield
+        end
+        old_egid = old_euid = nil
+        if new_egid
+            old_egid = self.egid
+            self.egid = convert_xid(:gid, new_egid)
+        end
+        if new_euid
+            old_euid = self.euid
+            self.euid = convert_xid(:uid, new_euid)
+        end
+
+        return yield
+    ensure
+        self.euid = old_euid if old_euid
+        self.egid = old_egid if old_egid
+    end
+    
+    # Make sure the passed argument is a number.
+    def convert_xid(type, id)
+        map = {:gid => :group, :uid => :user}
+        raise ArgumentError, "Invalid id type %s" % type unless map.include?(type)
+        ret = Puppet::Util.send(type, id)
+        if ret == nil
+          raise Puppet::Error, "Invalid %s: %s" % [map[type], id]
+        end
+        return ret
+    end
+
+    module_function :asuser, :convert_xid
+
+    def run_and_capture(command, new_uid=nil, new_gid=nil)
+        output = nil
+        
+        output = Puppet::Util.execute(command, :failonfail => false, :uid => new_uid, :gid => new_gid)
+
+        [output, $?.dup]
+    end
+
+    module_function :run_and_capture
+
+    def system(command, new_uid=nil, new_gid=nil)
+        status = nil
+        asuser(new_uid, new_gid) do
+            Kernel.system(command)
+            status = $?.dup
+        end
+        status
+    end
+            
+    module_function :system
+end
+
+# $Id: suidmanager.rb 2387 2007-04-04 21:35:00Z mccune $

data/lib/puppet/util/variables.rb

@@ -0,0 +1,39 @@
+module Puppet::Util::Variables
+    def inithooks
+        @instance_init_hooks.dup
+    end
+
+    def initvars
+        return unless defined? @class_init_hooks
+        self.inithooks.each do |var, value|
+            if value.is_a?(Class)
+                instance_variable_set("@" + var.to_s, value.new)
+            else
+                instance_variable_set("@" + var.to_s, value)
+            end
+        end
+    end
+
+    def instancevar(hash)
+        @instance_init_hooks ||= {}
+
+        unless method_defined?(:initvars)
+            define_method(:initvars) do
+                self.class.inithooks.each do |var, value|
+                    if value.is_a?(Class)
+                        instance_variable_set("@" + var.to_s, value.new)
+                    else
+                        instance_variable_set("@" + var.to_s, value)
+                    end
+                end
+            end
+        end
+        hash.each do |var, value|
+            raise("Already initializing %s" % var) if @instance_init_hooks[var]
+
+            @instance_init_hooks[var] = value
+        end
+    end
+end
+
+# $Id: variables.rb 1762 2006-10-10 20:59:10Z luke $

data/lib/puppet/util/warnings.rb

@@ -0,0 +1,15 @@
+# Methods to help with handling warnings.
+module Puppet::Util::Warnings
+    module_function
+
+    def warnonce(msg)
+        $stampwarnings ||= {}
+        $stampwarnings[self.class] ||= []
+        unless $stampwarnings[self.class].include? msg
+            Puppet.warning msg
+            $stampwarnings[self.class] << msg
+        end
+    end
+end
+
+# $Id: warnings.rb 1580 2006-09-13 16:48:56Z lutter $

data/test/Rakefile

@@ -0,0 +1,97 @@
+# let Emacs know it's -*- ruby -*-
+begin
+    require 'rake/testtask'
+rescue LoadError
+    $stderr.puts "You must have 'rake' installed to use this file"
+    exit(1)
+end
+
+require 'find'
+
+include Find
+include FileTest
+
+$exclusions = %W(lib data)
+$test_library_paths = %W(lib ../lib)
+
+$: << File.join(Dir.getwd, "lib")
+
+require 'rake/puppet_testtask'
+
+filemap = Hash.new { |hash, key| hash[key] = [] }
+
+allfiles = []
+
+# First collect the entire file list.
+find(".") do |f|
+    # Get rid of the leading ./
+    f = f.sub(/^\.\//, '')
+
+    file = File.basename(f)
+    dir = File.dirname(f)
+
+    # Prune . directories and excluded dirs
+    if (file =~ /^\./ and f != ".") or $exclusions.include?(File.basename(file))
+        prune
+        next
+    end
+    next if f == "."
+    next if dir == "."
+
+    # If we're a ruby script, then add it to the list of files for that dir
+    if file =~ /\.rb$/
+        allfiles << f
+        # Add it to all of the parent dirs, not just our own
+        parts = File.split(dir)
+        if parts[0] == "."
+            parts.shift
+        end
+        parts.each_with_index { |part, i|
+            path = File.join(parts[0..i])
+            filemap[path] << f
+        }
+    end
+end
+
+desc "Run the full test suite"
+Rake::PuppetTestTask.new :test do |t|
+    t.libs << $test_library_paths
+
+    # Add every file as a test file to run
+    t.test_files = allfiles
+    t.verbose = true
+end
+
+task :default => :test
+
+# Now create a task for every directory
+filemap.each do |dir, files|
+    ns = dir.gsub "/", ":"
+
+    # First create a separate task for each file in the namespace.
+    namespace ns do
+        files.each do |file|
+            Rake::PuppetTestTask.new File.basename(file, '.rb').to_sym do |t|
+                t.libs << $test_library_paths + ['..']
+                t.test_files = [ file ]
+                t.verbose = true 
+            end 
+        end
+    end
+
+    # Then create a task that matches the directory itself.
+    Rake::PuppetTestTask.new dir do |t|
+       t.libs << $test_library_paths
+       if ENV["TESTFILES"]
+           t.test_files = ENV["TESTFILES"].split(/\s+/)
+       else
+           t.test_files = files.sort
+       end
+       t.verbose = true
+    end
+
+    # And alias it with a slash on the end
+    task(dir + "/" => dir)
+end
+
+# $Id: Rakefile 2144 2007-02-01 01:20:20Z lutter $