puppet 0.13.1 → 0.13.2

data/lib/puppet/util.rb

@@ -21,7 +21,11 @@ module Util
             # The gid has to be changed first, because, well, otherwise we won't
             # be able to
             if group
-                gid = self.gid(group)
+                if group.is_a? Integer
+                    gid = group
+                else
+                    gid = self.gid(group)
+                end
 
                 if Process.gid != gid
                     oldgid = Process.gid
@@ -34,6 +38,11 @@ module Util
             end
 
             if user
+                if user.is_a? Integer
+                    uid = user
+                else
+                    uid = self.uid(user)
+                end
                 uid = self.uid(user)
                 # Now change the uid
                 if Process.uid != uid
@@ -126,22 +135,40 @@ module Util
         if group =~ /^\d+$/
             group = Integer(group)
         end
+        unless group
+            raise Puppet::DevError, "Invalid group %s" % group.inspect
+        end
         gid = nil
-        if group.is_a?(Integer)
-            gid = group
+        obj = nil
+
+        # We want to look the group up either way
+        if group.is_a?(Integer) 
+            # If this doesn't find anything
+            obj = Puppet.type(:group).find { |gobj|
+                gobj.should(:gid) == group ||
+                    gobj.is(:gid) == group
+            }
+
+            unless obj
+                begin
+                    gobj = Etc.getgrgid(group)
+                    gid = gobj.gid
+                rescue ArgumentError => detail
+                    # ignore it; we couldn't find the group
+                end
+            end
         else
             unless obj = Puppet.type(:group)[group]
                 obj = Puppet.type(:group).create(
                     :name => group,
                     :check => [:gid]
                 )
-            end
-            obj.retrieve
-            gid = obj.is(:gid)
-            unless gid.is_a?(Integer)
-                raise Puppet::Error, "Could not find group %s" % group
+                obj.retrieve
             end
         end
+        if obj
+            gid = obj.should(:gid) || obj.is(:gid)
+        end
 
         return gid
     end
@@ -152,8 +179,22 @@ module Util
         if user =~ /^\d+$/
             user = Integer(user)
         end
+
         if user.is_a?(Integer)
-            uid = user
+            # If this doesn't find anything
+            obj = Puppet.type(:user).find { |uobj|
+                uobj.should(:uid) == user ||
+                    uobj.is(:uid) == user
+            }
+
+            unless obj
+                begin
+                    uobj = Etc.getpwuid(user)
+                    uid = uobj.uid
+                rescue ArgumentError => detail
+                    # ignore it; we couldn't find the user
+                end
+            end
         else
             unless obj = Puppet.type(:user)[user]
                 obj = Puppet.type(:user).create(
@@ -161,63 +202,16 @@ module Util
                     :check => [:uid, :gid]
                 )
             end
+        end
+
+        if obj
             obj.retrieve
             uid = obj.is(:uid)
-            unless uid.is_a?(Integer)
-                raise Puppet::Error, "Could not find user %s" % user
-            end
         end
 
         return uid
     end
 
-    # Create a lock file while something is happening
-    def self.disabledlock(*opts)
-        lock = opts[0] + ".lock"
-        while File.exists?(lock)
-            stamp = File.stat(lock).mtime.to_i 
-            if Time.now.to_i - stamp > 5
-                Puppet.notice "Lock file %s is %s seconds old; removing" %
-                    [lock, Time.now.to_i - stamp]
-                File.delete(lock)
-                break
-            else
-                sleep 0.1
-            end
-            #Puppet.debug "%s is locked" % opts[0]
-        end
-        File.open(lock, "w") { |f| f.print " "; f.flush }
-        writing = false
-        if opts[1] == "w"
-            writing = true
-            tmp = opts[0] + ".tmp"
-            orig = opts[0]
-            opts[0] = tmp
-        end
-        begin
-            File.open(*opts) { |file| yield file }
-            begin
-                if writing
-                    Puppet.warning "opts were %s" % opts.inspect
-                    system("ls -l %s 2>/dev/null" % tmp)
-                    system("ls -l %s 2>/dev/null" % orig)
-                    File.rename(tmp, orig)
-                end
-            rescue => detail
-                Puppet.err "Could not replace %s: %s" % [orig, detail]
-                File.unlink(tmp)
-            end
-        rescue => detail
-            Puppet.err "Storage error: %s" % detail
-            raise
-        ensure
-            # I don't really understand how the lock file could disappear,
-            # but just in case...
-            if FileTest.exists?(lock)
-                File.delete(lock)
-            end
-        end
-    end
 
     # Create instance methods for each of the log levels.  This allows
     # the messages to be a little richer.  Most classes will be calling this
@@ -278,4 +272,4 @@ module Util
 end
 end
 
-# $Id: util.rb 898 2006-02-13 17:13:09Z luke $
+# $Id: util.rb 914 2006-02-15 21:04:14Z luke $

data/test/client/master.rb

@@ -0,0 +1,72 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/client'
+require 'puppet/server'
+require 'test/unit'
+require 'puppettest.rb'
+
+# $Id: master.rb 908 2006-02-14 00:14:56Z luke $
+
+class TestMasterClient < Test::Unit::TestCase
+	include ServerTest
+
+    def mkmaster(file)
+        master = nil
+        # create our master
+        assert_nothing_raised() {
+            # this is the default server setup
+            master = Puppet::Server::Master.new(
+                :File => file,
+                :UseNodes => false,
+                :Local => true
+            )
+        }
+        return master
+    end
+
+    def mkclient(master)
+        client = nil
+        assert_nothing_raised() {
+            client = Puppet::Client::MasterClient.new(
+                :Master => master
+            )
+        }
+
+        return client
+    end
+
+    def test_disable
+        manifest = mktestmanifest
+
+        master = mkmaster(manifest)
+
+        client = mkclient(master)
+
+        assert(! FileTest.exists?(@createdfile))
+
+        assert_nothing_raised {
+            client.disable
+        }
+
+        assert_nothing_raised {
+            client.run
+        }
+
+        assert(! FileTest.exists?(@createdfile), "Disabled client ran")
+
+        assert_nothing_raised {
+            client.enable
+        }
+
+        assert_nothing_raised {
+            client.run
+        }
+
+        assert(FileTest.exists?(@createdfile), "Enabled client did not run")
+    end
+end

data/test/language/interpreter.rb

@@ -68,4 +68,98 @@ class TestInterpreter < Test::Unit::TestCase
 
         assert(config != newconfig, "Configs are somehow the same")
     end
+
+    # Only test ldap stuff on luke's network, since that's the only place we
+    # have data for.
+    if Facter["domain"].value == "madstop.com"
+    begin
+        require 'ldap'
+        $haveldap = true
+    rescue LoadError
+        $stderr.puts "Missing ldap; skipping ldap source tests"
+        $haveldap = false
+    end
+    if $haveldap
+    def ldapconnect
+
+        @ldap = LDAP::Conn.new("ldap", 389)
+        @ldap.set_option( LDAP::LDAP_OPT_PROTOCOL_VERSION, 3 )
+        @ldap.simple_bind("", "")
+
+        return @ldap
+    end
+
+    def ldaphost(node)
+        parent = nil
+        classes = nil
+        @ldap.search( "ou=hosts, dc=madstop, dc=com", 2,
+            "(&(objectclass=puppetclient)(cn=%s))" % node
+        ) do |entry|
+            parent = entry.vals("parentnode").shift
+            classes = entry.vals("puppetclass")
+        end
+
+        return parent, classes
+    end
+
+    def test_ldapnodes
+        Puppet[:ldapbase] = "ou=hosts, dc=madstop, dc=com"
+
+        ldapconnect()
+        file = tempfile()
+        files = []
+        parentfile = tempfile() + "-parent"
+        files << parentfile
+        hostname = Facter["hostname"].value
+        lparent, lclasses = ldaphost(Facter["hostname"].value)
+        File.open(file, "w") { |f|
+            f.puts "node #{lparent} {
+    file { \"#{parentfile}\": ensure => file }
+}"
+
+            lclasses.each { |klass|
+                kfile = tempfile() + "-klass"
+                files << kfile
+                f.puts "class #{klass} { file { \"#{kfile}\": ensure => file } }"
+            }
+        }
+        interp = nil
+        assert_nothing_raised {
+            interp = Puppet::Parser::Interpreter.new(
+                :Manifest => file,
+                :NodeSources => [:ldap]
+            )
+        }
+
+        assert_nothing_raised {
+            interp.setup_ldap
+        }
+
+        parent = nil
+        classes = nil
+        assert_nothing_raised {
+            parent, classes = interp.nodesearch_ldap(hostname)
+        }
+
+        assert_equal(lparent, parent, "Parent node did not match")
+        assert_equal(lclasses, classes, "Class list did not match")
+
+        objects = nil
+        assert_nothing_raised {
+            objects = interp.run(hostname, Puppet::Client::MasterClient.facts)
+        }
+
+        comp = nil
+        assert_nothing_raised {
+            comp = objects.to_type
+        }
+
+        assert_apply(comp)
+        files.each { |cfile|
+            @@tmpfiles << cfile
+            assert(FileTest.exists?(cfile), "Did not make %s" % cfile)
+        }
+    end
+    end
+    end
 end

data/test/other/log.rb

@@ -9,14 +9,20 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: log.rb 873 2006-02-07 23:12:33Z luke $
+# $Id: log.rb 914 2006-02-15 21:04:14Z luke $
 
 class TestLog < Test::Unit::TestCase
     include TestPuppet
 
+    def setup
+        super
+        @oldloglevel = Puppet::Log.level
+    end
+
     def teardown
         super
         Puppet::Log.close
+        Puppet::Log.level = @oldloglevel
     end
 
     def getlevels
@@ -44,6 +50,7 @@ class TestLog < Test::Unit::TestCase
     def test_logfile
         fact = nil
         levels = nil
+        oldlevel = Puppet::Log.level
         Puppet::Log.level = :debug
         levels = getlevels
         logfile = tempfile()

data/test/puppet/utiltest.rb

@@ -43,6 +43,106 @@ class TestPuppetUtil < Test::Unit::TestCase
         threads.each { |th| th.join }
     end
 
+    # First verify we can convert a known user
+    def test_gidbyname
+        %x{groups}.split(" ").each { |group|
+            gid = nil
+            assert_nothing_raised {
+                gid = Puppet::Util.gid(group)
+            }
+
+            assert(gid, "Could not retrieve gid for %s" % group)
+
+            assert(Puppet.type(:group)[group], "Util did not create %s" % group)
+        }
+    end
+
+    # Then verify we can retrieve a known group by gid
+    def test_gidbyid
+        %x{groups}.split(" ").each { |group|
+            obj = Puppet.type(:group).create(
+                :name => group,
+                :check => [:gid]
+            )
+            obj.retrieve
+            id = obj.is(:gid)
+            gid = nil
+            assert_nothing_raised {
+                gid = Puppet::Util.gid(id)
+            }
+
+            assert(gid, "Could not retrieve gid for %s" % group)
+            assert_equal(id, gid, "Got mismatched ids")
+        }
+    end
+
+    # Finally, verify that we can find groups by id even if we don't
+    # know them
+    def test_gidbyunknownid
+        gid = nil
+        group = Process.gid
+        assert_nothing_raised {
+            gid = Puppet::Util.gid(group)
+        }
+
+        assert(gid, "Could not retrieve gid for %s" % group)
+        assert_equal(group, gid, "Got mismatched ids")
+    end
+
+    def user
+        require 'etc'
+        unless defined? @user
+            obj = Etc.getpwuid(Process.uid)
+            @user = obj.name
+        end
+        return @user
+    end
+
+    # And do it all over again for users
+    # First verify we can convert a known user
+    def test_uidbyname
+        user = user()
+        uid = nil
+        assert_nothing_raised {
+            uid = Puppet::Util.uid(user)
+        }
+
+        assert(uid, "Could not retrieve uid for %s" % user)
+        assert_equal(Process.uid, uid, "UIDs did not match")
+        assert(Puppet.type(:user)[user], "Util did not create %s" % user)
+    end
+
+    # Then verify we can retrieve a known user by uid
+    def test_uidbyid
+        user = user()
+        obj = Puppet.type(:user).create(
+            :name => user,
+            :check => [:uid]
+        )
+        obj.retrieve
+        id = obj.is(:uid)
+        uid = nil
+        assert_nothing_raised {
+            uid = Puppet::Util.uid(id)
+        }
+
+        assert(uid, "Could not retrieve uid for %s" % user)
+        assert_equal(id, uid, "Got mismatched ids")
+    end
+
+    # Finally, verify that we can find users by id even if we don't
+    # know them
+    def test_uidbyunknownid
+        uid = nil
+        user = Process.uid
+        assert_nothing_raised {
+            uid = Puppet::Util.uid(user)
+        }
+
+        assert(uid, "Could not retrieve uid for %s" % user)
+        assert_equal(user, uid, "Got mismatched ids")
+    end
+
     unless Process.uid == 0
         $stderr.puts "Run as root to perform Utility tests"
         def test_nothing
@@ -153,4 +253,4 @@ class TestPuppetUtil < Test::Unit::TestCase
     end
 end
 
-# $Id: utiltest.rb 897 2006-02-12 18:08:39Z luke $
+# $Id: utiltest.rb 914 2006-02-15 21:04:14Z luke $