diff --git a/lib/puppet/daemon.rb b/lib/puppet/daemon.rb
index ad0edd3b9..c76d63a54 100755
--- a/lib/puppet/daemon.rb
+++ b/lib/puppet/daemon.rb
@@ -1,130 +1,130 @@
 require 'puppet'
 require 'puppet/util/pidlock'
 require 'puppet/external/event-loop'
 require 'puppet/application'
 
 # A module that handles operations common to all daemons.  This is included
 # into the Server and Client base classes.
 class Puppet::Daemon
   attr_accessor :agent, :server, :argv
 
   def daemonname
     Puppet[:name]
   end
 
   # Put the daemon into the background.
   def daemonize
     if pid = fork
       Process.detach(pid)
       exit(0)
     end
 
     create_pidfile
 
     # Get rid of console logging
     Puppet::Util::Log.close(:console)
 
     Process.setsid
     Dir.chdir("/")
     begin
       $stdin.reopen "/dev/null"
       $stdout.reopen "/dev/null", "a"
       $stderr.reopen $stdout
       Puppet::Util::Log.reopen
     rescue => detail
       Puppet.err "Could not start #{Puppet[:name]}: #{detail}"
       Puppet::Util::secure_open("/tmp/daemonout", "w") { |f|
         f.puts "Could not start #{Puppet[:name]}: #{detail}"
       }
       exit(12)
     end
   end
 
   # Create a pidfile for our daemon, so we can be stopped and others
   # don't try to start.
   def create_pidfile
-    Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
+    Puppet::Util.synchronize_on(Puppet[:name],Sync::EX) do
       raise "Could not create PID file: #{pidfile}" unless Puppet::Util::Pidlock.new(pidfile).lock
     end
   end
 
   # Provide the path to our pidfile.
   def pidfile
     Puppet[:pidfile]
   end
 
   def reexec
     raise Puppet::DevError, "Cannot reexec unless ARGV arguments are set" unless argv
     command = $0 + " " + argv.join(" ")
     Puppet.notice "Restarting with '#{command}'"
     stop(:exit => false)
     exec(command)
   end
 
   def reload
     return unless agent
     if agent.running?
       Puppet.notice "Not triggering already-running agent"
       return
     end
 
     agent.run
   end
 
   # Remove the pid file for our daemon.
   def remove_pidfile
-    Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
+    Puppet::Util.synchronize_on(Puppet[:name],Sync::EX) do
       locker = Puppet::Util::Pidlock.new(pidfile)
       locker.unlock or Puppet.err "Could not remove PID file #{pidfile}" if locker.locked?
     end
   end
 
   def restart
     Puppet::Application.restart!
     reexec unless agent and agent.running?
   end
 
   def reopen_logs
     Puppet::Util::Log.reopen
   end
 
   # Trap a couple of the main signals.  This should probably be handled
   # in a way that anyone else can register callbacks for traps, but, eh.
   def set_signal_traps
     signals = {:INT => :stop, :TERM => :stop }
     # extended signals not supported under windows
     signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }) unless Puppet.features.microsoft_windows?
     signals.each do |signal, method|
       trap(signal) do
         Puppet.notice "Caught #{signal}; calling #{method}"
         send(method)
       end
     end
   end
 
   # Stop everything
   def stop(args = {:exit => true})
     Puppet::Application.stop!
 
     server.stop if server
 
     remove_pidfile
 
     Puppet::Util::Log.close_all
 
     exit if args[:exit]
   end
 
   def start
     set_signal_traps
 
     create_pidfile
 
     raise Puppet::DevError, "Daemons must have an agent, server, or both" unless agent or server
     server.start if server
     agent.start if agent
 
     EventLoop.current.run
   end
 end
 
diff --git a/lib/puppet/network/server.rb b/lib/puppet/network/server.rb
index d424b9c4a..e4de07dea 100644
--- a/lib/puppet/network/server.rb
+++ b/lib/puppet/network/server.rb
@@ -1,165 +1,165 @@
 require 'puppet/network/http'
 require 'puppet/util/pidlock'
 
 class Puppet::Network::Server
   attr_reader :server_type, :protocols, :address, :port
 
   # Put the daemon into the background.
   def daemonize
     if pid = fork
       Process.detach(pid)
       exit(0)
     end
 
     # Get rid of console logging
     Puppet::Util::Log.close(:console)
 
     Process.setsid
     Dir.chdir("/")
     begin
       $stdin.reopen "/dev/null"
       $stdout.reopen "/dev/null", "a"
       $stderr.reopen $stdout
       Puppet::Util::Log.reopen
     rescue => detail
       Puppet::Util.secure_open("/tmp/daemonout", "w") { |f|
         f.puts "Could not start #{Puppet[:name]}: #{detail}"
       }
       raise "Could not start #{Puppet[:name]}: #{detail}"
     end
   end
 
   # Create a pidfile for our daemon, so we can be stopped and others
   # don't try to start.
   def create_pidfile
-    Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
+    Puppet::Util.synchronize_on(Puppet[:name],Sync::EX) do
       raise "Could not create PID file: #{pidfile}" unless Puppet::Util::Pidlock.new(pidfile).lock
     end
   end
 
   # Remove the pid file for our daemon.
   def remove_pidfile
-    Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
+    Puppet::Util.synchronize_on(Puppet[:name],Sync::EX) do
       locker = Puppet::Util::Pidlock.new(pidfile)
       locker.unlock or Puppet.err "Could not remove PID file #{pidfile}" if locker.locked?
     end
   end
 
   # Provide the path to our pidfile.
   def pidfile
     Puppet[:pidfile]
   end
 
   def initialize(args = {})
     valid_args = [:handlers, :xmlrpc_handlers, :port]
     bad_args = args.keys.find_all { |p| ! valid_args.include?(p) }.collect { |p| p.to_s }.join(",")
     raise ArgumentError, "Invalid argument(s) #{bad_args}" unless bad_args == ""
     @server_type = Puppet[:servertype] or raise "No servertype configuration found."  # e.g.,  WEBrick, Mongrel, etc.
     http_server_class || raise(ArgumentError, "Could not determine HTTP Server class for server type [#{@server_type}]")
 
     @port = args[:port] || Puppet[:masterport] || raise(ArgumentError, "Must specify :port or configure Puppet :masterport")
     @address = determine_bind_address
 
     @protocols = [ :rest, :xmlrpc ]
     @listening = false
     @routes = {}
     @xmlrpc_routes = {}
     self.register(args[:handlers]) if args[:handlers]
     self.register_xmlrpc(args[:xmlrpc_handlers]) if args[:xmlrpc_handlers]
 
     # Make sure we have all of the directories we need to function.
     Puppet.settings.use(:main, :ssl, Puppet[:name])
   end
 
   # Register handlers for REST networking, based on the Indirector.
   def register(*indirections)
     raise ArgumentError, "Indirection names are required." if indirections.empty?
     indirections.flatten.each do |name|
       Puppet::Indirector::Indirection.model(name) || raise(ArgumentError, "Cannot locate indirection '#{name}'.")
       @routes[name.to_sym] = true
     end
   end
 
   # Unregister Indirector handlers.
   def unregister(*indirections)
     raise "Cannot unregister indirections while server is listening." if listening?
     indirections = @routes.keys if indirections.empty?
 
     indirections.flatten.each do |i|
       raise(ArgumentError, "Indirection [#{i}] is unknown.") unless @routes[i.to_sym]
     end
 
     indirections.flatten.each do |i|
       @routes.delete(i.to_sym)
     end
   end
 
   # Register xmlrpc handlers for backward compatibility.
   def register_xmlrpc(*namespaces)
     raise ArgumentError, "XMLRPC namespaces are required." if namespaces.empty?
     namespaces.flatten.each do |name|
       Puppet::Network::Handler.handler(name) || raise(ArgumentError, "Cannot locate XMLRPC handler for namespace '#{name}'.")
       @xmlrpc_routes[name.to_sym] = true
     end
   end
 
   # Unregister xmlrpc handlers.
   def unregister_xmlrpc(*namespaces)
     raise "Cannot unregister xmlrpc handlers while server is listening." if listening?
     namespaces = @xmlrpc_routes.keys if namespaces.empty?
 
     namespaces.flatten.each do |i|
       raise(ArgumentError, "XMLRPC handler '#{i}' is unknown.") unless @xmlrpc_routes[i.to_sym]
     end
 
     namespaces.flatten.each do |i|
       @xmlrpc_routes.delete(i.to_sym)
     end
   end
 
   def listening?
     @listening
   end
 
   def listen
     raise "Cannot listen -- already listening." if listening?
     @listening = true
     http_server.listen(:address => address, :port => port, :handlers => @routes.keys, :xmlrpc_handlers => @xmlrpc_routes.keys, :protocols => protocols)
   end
 
   def unlisten
     raise "Cannot unlisten -- not currently listening." unless listening?
     http_server.unlisten
     @listening = false
   end
 
   def http_server_class
     http_server_class_by_type(@server_type)
   end
 
   def start
     create_pidfile
     listen
   end
 
   def stop
     unlisten
     remove_pidfile
   end
 
   private
 
   def http_server
     @http_server ||= http_server_class.new
   end
 
   def http_server_class_by_type(kind)
     Puppet::Network::HTTP.server_class_by_type(kind)
   end
 
   def determine_bind_address
     tmp = Puppet[:bindaddress]
     return tmp if tmp != ""
     server_type.to_s == "webrick" ? "0.0.0.0" : "127.0.0.1"
   end
 end
diff --git a/lib/puppet/util.rb b/lib/puppet/util.rb
index f2eaf0d06..1a5acaf22 100644
--- a/lib/puppet/util.rb
+++ b/lib/puppet/util.rb
@@ -1,462 +1,469 @@
 # A module to collect utility functions.
 
 require 'puppet/util/monkey_patches'
 require 'sync'
 require 'puppet/external/lock'
+require 'monitor'
 
 module Puppet
   # A command failed to execute.
   require 'puppet/error'
   class ExecutionFailure < Puppet::Error
   end
 module Util
   require 'benchmark'
 
   # These are all for backward compatibility -- these are methods that used
   # to be in Puppet::Util but have been moved into external modules.
   require 'puppet/util/posix'
   extend Puppet::Util::POSIX
 
-  # Create a hash to store the different sync objects.
-  @@syncresources = {}
+  @@sync_objects = {}.extend MonitorMixin
 
   def self.activerecord_version
     if (defined?(::ActiveRecord) and defined?(::ActiveRecord::VERSION) and defined?(::ActiveRecord::VERSION::MAJOR) and defined?(::ActiveRecord::VERSION::MINOR))
       ([::ActiveRecord::VERSION::MAJOR, ::ActiveRecord::VERSION::MINOR].join('.').to_f)
     else
       0
     end
   end
 
-  # Return the sync object associated with a given resource.
-  def self.sync(resource)
-    @@syncresources[resource] ||= Sync.new
-    @@syncresources[resource]
+  
+  def self.synchronize_on(x,type)
+    sync_object,users = 0,1
+    begin
+      @@sync_objects.synchronize { 
+        (@@sync_objects[x] ||= [Sync.new,0])[users] += 1
+      }
+      @@sync_objects[x][sync_object].synchronize(type) { yield }
+    ensure
+      @@sync_objects.synchronize { 
+        @@sync_objects.delete(x) unless (@@sync_objects[x][users] -= 1) > 0
+      }
+    end
   end
 
   # Change the process to a different user
   def self.chuser
     if group = Puppet[:group]
       group = self.gid(group)
       raise Puppet::Error, "No such group #{Puppet[:group]}" unless group
       unless Puppet::Util::SUIDManager.gid == group
         begin
           Puppet::Util::SUIDManager.egid = group
           Puppet::Util::SUIDManager.gid = group
         rescue => detail
           Puppet.warning "could not change to group #{group.inspect}: #{detail}"
           $stderr.puts "could not change to group #{group.inspect}"
 
           # Don't exit on failed group changes, since it's
           # not fatal
           #exit(74)
         end
       end
     end
 
     if user = Puppet[:user]
       user = self.uid(user)
       raise Puppet::Error, "No such user #{Puppet[:user]}" unless user
       unless Puppet::Util::SUIDManager.uid == user
         begin
           Puppet::Util::SUIDManager.initgroups(user)
           Puppet::Util::SUIDManager.uid = user
           Puppet::Util::SUIDManager.euid = user
         rescue => detail
           $stderr.puts "Could not change to user #{user}: #{detail}"
           exit(74)
         end
       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
   # method.
   def self.logmethods(klass, useself = true)
     Puppet::Util::Log.eachlevel { |level|
       klass.send(:define_method, level, proc { |args|
         args = args.join(" ") if args.is_a?(Array)
         if useself
 
           Puppet::Util::Log.create(
 
             :level => level,
             :source => self,
 
             :message => args
           )
         else
 
           Puppet::Util::Log.create(
 
             :level => level,
 
             :message => args
           )
         end
       })
     }
   end
 
   # Proxy a bunch of methods to another object.
   def self.classproxy(klass, objmethod, *methods)
     classobj = class << klass; self; end
     methods.each do |method|
       classobj.send(:define_method, method) do |*args|
         obj = self.send(objmethod)
 
         obj.send(method, *args)
       end
     end
   end
 
   # Proxy a bunch of methods to another object.
   def self.proxy(klass, objmethod, *methods)
     methods.each do |method|
       klass.send(:define_method, method) do |*args|
         obj = self.send(objmethod)
 
         obj.send(method, *args)
       end
     end
   end
 
   # XXX this should all be done using puppet objects, not using
   # normal mkdir
   def self.recmkdir(dir,mode = 0755)
     if FileTest.exist?(dir)
       return false
     else
       tmp = dir.sub(/^\//,'')
       path = [File::SEPARATOR]
       tmp.split(File::SEPARATOR).each { |dir|
         path.push dir
         if ! FileTest.exist?(File.join(path))
           Dir.mkdir(File.join(path), mode)
         elsif FileTest.directory?(File.join(path))
           next
         else FileTest.exist?(File.join(path))
           raise "Cannot create #{dir}: basedir #{File.join(path)} is a file"
         end
       }
       return true
     end
   end
 
   # Execute a given chunk of code with a new umask.
   def self.withumask(mask)
     cur = File.umask(mask)
 
     begin
       yield
     ensure
       File.umask(cur)
     end
   end
 
   def benchmark(*args)
     msg = args.pop
     level = args.pop
     object = nil
 
     if args.empty?
       if respond_to?(level)
         object = self
       else
         object = Puppet
       end
     else
       object = args.pop
     end
 
     raise Puppet::DevError, "Failed to provide level to :benchmark" unless level
 
     unless level == :none or object.respond_to? level
       raise Puppet::DevError, "Benchmarked object does not respond to #{level}"
     end
 
     # Only benchmark if our log level is high enough
     if level != :none and Puppet::Util::Log.sendlevel?(level)
       result = nil
       seconds = Benchmark.realtime {
         yield
       }
       object.send(level, msg + (" in %0.2f seconds" % seconds))
       return seconds
     else
       yield
     end
   end
 
   def binary(bin)
     if bin =~ /^\//
       return bin if FileTest.file? bin and FileTest.executable? bin
     else
       ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
         dest=File.join(dir, bin)
         return dest if FileTest.file? dest and FileTest.executable? dest
       end
     end
     nil
   end
   module_function :binary
 
   # Execute the provided command in a pipe, yielding the pipe object.
   def execpipe(command, failonfail = true)
     if respond_to? :debug
       debug "Executing '#{command}'"
     else
       Puppet.debug "Executing '#{command}'"
     end
 
     output = open("| #{command} 2>&1") do |pipe|
       yield pipe
     end
 
     if failonfail
       unless $CHILD_STATUS == 0
         raise ExecutionFailure, output
       end
     end
 
     output
   end
 
   def execfail(command, exception)
       output = execute(command)
       return output
   rescue ExecutionFailure
       raise exception, output
   end
 
   # Execute the desired command, and return the status and output.
   # def execute(command, failonfail = true, uid = nil, gid = nil)
   # :combine sets whether or not to combine stdout/stderr in the output
   # :stdinfile sets a file that can be used for stdin. Passing a string
   # for stdin is not currently supported.
   def execute(command, arguments = {:failonfail => true, :combine => true})
     if command.is_a?(Array)
       command = command.flatten.collect { |i| i.to_s }
       str = command.join(" ")
     else
       # We require an array here so we know where we're incorrectly
       # using a string instead of an array.  Once everything is
       # switched to an array, we might relax this requirement.
       raise ArgumentError, "Must pass an array to execute()"
     end
 
     if respond_to? :debug
       debug "Executing '#{str}'"
     else
       Puppet.debug "Executing '#{str}'"
     end
 
     arguments[:uid] = Puppet::Util::SUIDManager.convert_xid(:uid, arguments[:uid]) if arguments[:uid]
     arguments[:gid] = Puppet::Util::SUIDManager.convert_xid(:gid, arguments[:gid]) if arguments[:gid]
 
     @@os ||= Facter.value(:operatingsystem)
     output = nil
     child_pid, child_status = nil
     # There are problems with read blocking with badly behaved children
     # read.partialread doesn't seem to capture either stdout or stderr
     # We hack around this using a temporary file
 
     # The idea here is to avoid IO#read whenever possible.
     output_file="/dev/null"
     error_file="/dev/null"
     if ! arguments[:squelch]
       require "tempfile"
       output_file = Tempfile.new("puppet")
       error_file=output_file if arguments[:combine]
     end
 
     if Puppet.features.posix?
       oldverb = $VERBOSE
       $VERBOSE = nil
       child_pid = Kernel.fork
       $VERBOSE = oldverb
       if child_pid
         # Parent process executes this
         child_status = (Process.waitpid2(child_pid)[1]).to_i >> 8
       else
         # Child process executes this
         Process.setsid
         begin
           if arguments[:stdinfile]
             $stdin.reopen(arguments[:stdinfile])
           else
             $stdin.reopen("/dev/null")
           end
           $stdout.reopen(output_file)
           $stderr.reopen(error_file)
 
           3.upto(256){|fd| IO::new(fd).close rescue nil}
           if arguments[:gid]
             Process.egid = arguments[:gid]
             Process.gid = arguments[:gid] unless @@os == "Darwin"
           end
           if arguments[:uid]
             Process.euid = arguments[:uid]
             Process.uid = arguments[:uid] unless @@os == "Darwin"
           end
           ENV['LANG'] = ENV['LC_ALL'] = ENV['LC_MESSAGES'] = ENV['LANGUAGE'] = 'C'
           if command.is_a?(Array)
             Kernel.exec(*command)
           else
             Kernel.exec(command)
           end
         rescue => detail
           puts detail.to_s
           exit!(1)
         end
       end
     elsif Puppet.features.microsoft_windows?
       command = command.collect {|part| '"' + part.gsub(/"/, '\\"') + '"'}.join(" ") if command.is_a?(Array)
       Puppet.debug "Creating process '#{command}'"
       processinfo = Process.create( :command_line => command )
       child_status = (Process.waitpid2(child_pid)[1]).to_i >> 8
     end
 
     # read output in if required
     if ! arguments[:squelch]
 
       # Make sure the file's actually there.  This is
       # basically a race condition, and is probably a horrible
       # way to handle it, but, well, oh well.
       unless FileTest.exists?(output_file.path)
         Puppet.warning "sleeping"
         sleep 0.5
         unless FileTest.exists?(output_file.path)
           Puppet.warning "sleeping 2"
           sleep 1
           unless FileTest.exists?(output_file.path)
             Puppet.warning "Could not get output"
             output = ""
           end
         end
       end
       unless output
         # We have to explicitly open here, so that it reopens
         # after the child writes.
         output = output_file.open.read
 
         # The 'true' causes the file to get unlinked right away.
         output_file.close(true)
       end
     end
 
     if arguments[:failonfail]
       unless child_status == 0
         raise ExecutionFailure, "Execution of '#{str}' returned #{child_status}: #{output}"
       end
     end
 
     output
   end
 
   module_function :execute
 
   # Create an exclusive lock.
   def threadlock(resource, type = Sync::EX)
-    Puppet::Util.sync(resource).synchronize(type) do
-      yield
-    end
+    Puppet::Util.synchronize_on(resource,type) { yield }
   end
 
   # Because some modules provide their own version of this method.
   alias util_execute execute
 
   module_function :benchmark
 
   def memory
     unless defined?(@pmap)
       pmap = %x{which pmap 2>/dev/null}.chomp
       if $CHILD_STATUS != 0 or pmap =~ /^no/
         @pmap = nil
       else
         @pmap = pmap
       end
     end
     if @pmap
       return %x{pmap #{Process.pid}| grep total}.chomp.sub(/^\s*total\s+/, '').sub(/K$/, '').to_i
     else
       0
     end
   end
 
   def symbolize(value)
     if value.respond_to? :intern
       value.intern
     else
       value
     end
   end
 
   def symbolizehash(hash)
     newhash = {}
     hash.each do |name, val|
       if name.is_a? String
         newhash[name.intern] = val
       else
         newhash[name] = val
       end
     end
   end
 
   def symbolizehash!(hash)
     hash.each do |name, val|
       if name.is_a? String
         hash[name.intern] = val
         hash.delete(name)
       end
     end
 
     hash
   end
   module_function :symbolize, :symbolizehash, :symbolizehash!
 
   # Just benchmark, with no logging.
   def thinmark
     seconds = Benchmark.realtime {
       yield
     }
 
     seconds
   end
 
   module_function :memory, :thinmark
 
   def secure_open(file,must_be_w,&block)
     raise Puppet::DevError,"secure_open only works with mode 'w'" unless must_be_w == 'w'
     raise Puppet::DevError,"secure_open only requires a block"    unless block_given?
     Puppet.warning "#{file} was a symlink to #{File.readlink(file)}" if File.symlink?(file)
     if File.exists?(file) or File.symlink?(file)
       wait = File.symlink?(file) ? 5.0 : 0.1
       File.delete(file)
       sleep wait # give it a chance to reappear, just in case someone is actively trying something.
     end
     begin
       File.open(file,File::CREAT|File::EXCL|File::TRUNC|File::WRONLY,&block)
     rescue Errno::EEXIST
       desc = File.symlink?(file) ? "symlink to #{File.readlink(file)}" : File.stat(file).ftype
       puts "Warning: #{file} was apparently created by another process (as"
       puts "a #{desc}) as soon as it was deleted by this process.  Someone may be trying"
       puts "to do something objectionable (such as tricking you into overwriting system"
       puts "files if you are running as root)."
       raise
     end
   end
   module_function :secure_open
 end
 end
 
 require 'puppet/util/errors'
 require 'puppet/util/methodhelper'
 require 'puppet/util/metaid'
 require 'puppet/util/classgen'
 require 'puppet/util/docs'
 require 'puppet/util/execution'
 require 'puppet/util/logging'
 require 'puppet/util/package'
 require 'puppet/util/warnings'
diff --git a/lib/puppet/util/file_locking.rb b/lib/puppet/util/file_locking.rb
index bd0181733..18744cab7 100644
--- a/lib/puppet/util/file_locking.rb
+++ b/lib/puppet/util/file_locking.rb
@@ -1,47 +1,47 @@
 require 'puppet/util'
 
 module Puppet::Util::FileLocking
   module_function
 
   # Create a shared lock for reading
   def readlock(file)
     raise ArgumentError, "#{file} is not a file" unless !File.exists?(file) or File.file?(file)
-    Puppet::Util.sync(file).synchronize(Sync::SH) do
+    Puppet::Util.synchronize_on(file,Sync::SH) do
       File.open(file) { |f|
         f.lock_shared { |lf| yield lf }
       }
     end
   end
 
   # Create an exclusive lock for writing, and do the writing in a
   # tmp file.
   def writelock(file, mode = nil)
     raise Puppet::DevError, "Cannot create #{file}; directory #{File.dirname(file)} does not exist" unless FileTest.directory?(File.dirname(file))
     raise ArgumentError, "#{file} is not a file" unless !File.exists?(file) or File.file?(file)
     tmpfile = file + ".tmp"
 
     unless mode
       # It's far more likely that the file will be there than not, so it's
       # better to stat once to check for existence and mode.
       # If we can't stat, it's most likely because the file's not there,
       # but could also be because the directory isn't readable, in which case
       # we won't be able to write anyway.
       begin
         mode = File.stat(file).mode
       rescue
         mode = 0600
       end
     end
 
-    Puppet::Util.sync(file).synchronize(Sync::EX) do
+    Puppet::Util.synchronize_on(file,Sync::EX) do
       File.open(file, File::Constants::CREAT | File::Constants::WRONLY, mode) do |rf|
         rf.lock_exclusive do |lrf|
           # poor's man open(2) O_EXLOCK|O_TRUNC
           lrf.seek(0, IO::SEEK_SET)
           lrf.truncate(0)
           yield lrf
         end
       end
     end
   end
 end
diff --git a/spec/unit/daemon_spec.rb b/spec/unit/daemon_spec.rb
index 15320736c..e24db7881 100755
--- a/spec/unit/daemon_spec.rb
+++ b/spec/unit/daemon_spec.rb
@@ -1,306 +1,300 @@
-#!/usr/bin/env ruby"
+#!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'puppet/daemon'
 
 def without_warnings
   flag = $VERBOSE
   $VERBOSE = nil
   yield
   $VERBOSE = flag
 end
 
 describe Puppet::Daemon do
   before do
     @daemon = Puppet::Daemon.new
   end
 
   it "should be able to manage an agent" do
     @daemon.should respond_to(:agent)
   end
 
   it "should be able to manage a network server" do
     @daemon.should respond_to(:server)
   end
 
   it "should reopen the Log logs when told to reopen logs" do
     Puppet::Util::Log.expects(:reopen)
     @daemon.reopen_logs
   end
 
   describe "when setting signal traps" do
     before do
       @daemon.stubs(:trap)
     end
 
     {:INT => :stop, :TERM => :stop, :HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
       it "should log and call #{method} when it receives #{signal}" do
         @daemon.expects(:trap).with(signal).yields
 
         Puppet.expects(:notice)
 
         @daemon.expects(method)
 
         @daemon.set_signal_traps
       end
     end
   end
 
   describe "when starting" do
     before do
       @daemon.stubs(:create_pidfile)
       @daemon.stubs(:set_signal_traps)
       EventLoop.current.stubs(:run)
     end
 
     it "should fail if it has neither agent nor server" do
       lambda { @daemon.start }.should raise_error(Puppet::DevError)
     end
 
     it "should create its pidfile" do
       @daemon.stubs(:agent).returns stub('agent', :start => nil)
 
       @daemon.expects(:create_pidfile)
       @daemon.start
     end
 
     it "should start the agent if the agent is configured" do
       agent = mock 'agent'
       agent.expects(:start)
       @daemon.stubs(:agent).returns agent
 
       @daemon.start
     end
 
     it "should start its server if one is configured" do
       server = mock 'server'
       server.expects(:start)
       @daemon.stubs(:server).returns server
 
       @daemon.start
     end
 
     it "should let the current EventLoop run" do
       @daemon.stubs(:agent).returns stub('agent', :start => nil)
       EventLoop.current.expects(:run)
 
       @daemon.start
     end
   end
 
   describe "when stopping" do
     before do
       @daemon.stubs(:remove_pidfile)
       @daemon.stubs(:exit)
       Puppet::Util::Log.stubs(:close_all)
       # to make the global safe to mock, set it to a subclass of itself,
       # then restore it in an after pass
       without_warnings { Puppet::Application = Class.new(Puppet::Application) }
     end
 
     after do
       # restore from the superclass so we lose the stub garbage
       without_warnings { Puppet::Application = Puppet::Application.superclass }
     end
 
     it "should stop its server if one is configured" do
       server = mock 'server'
       server.expects(:stop)
       @daemon.stubs(:server).returns server
 
       @daemon.stop
     end
 
     it 'should request a stop from Puppet::Application' do
       Puppet::Application.expects(:stop!)
       @daemon.stop
     end
 
     it "should remove its pidfile" do
       @daemon.expects(:remove_pidfile)
 
       @daemon.stop
     end
 
     it "should close all logs" do
       Puppet::Util::Log.expects(:close_all)
 
       @daemon.stop
     end
 
     it "should exit unless called with ':exit => false'" do
       @daemon.expects(:exit)
       @daemon.stop
     end
 
     it "should not exit if called with ':exit => false'" do
       @daemon.expects(:exit).never
       @daemon.stop :exit => false
     end
   end
 
   describe "when creating its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.settings.expects(:value).with(:name).returns "me"
-
-      sync = mock 'sync'
-      Puppet::Util.expects(:sync).with("me").returns sync
-
-      sync.expects(:synchronize).with(Sync::EX)
+      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
       @daemon.create_pidfile
     end
 
     it "should lock the pidfile using the Pidlock class" do
       pidfile = mock 'pidfile'
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.expects(:value).with(:pidfile).returns "/my/file"
 
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
 
       pidfile.expects(:lock).returns true
       @daemon.create_pidfile
     end
 
     it "should fail if it cannot lock" do
       pidfile = mock 'pidfile'
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
 
       pidfile.expects(:lock).returns false
 
       lambda { @daemon.create_pidfile }.should raise_error
     end
   end
 
   describe "when removing its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.settings.expects(:value).with(:name).returns "me"
 
-      sync = mock 'sync'
-      Puppet::Util.expects(:sync).with("me").returns sync
+      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
 
-      sync.expects(:synchronize).with(Sync::EX)
       @daemon.remove_pidfile
     end
 
     it "should do nothing if the pidfile is not present" do
       pidfile = mock 'pidfile', :locked? => false
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       pidfile.expects(:unlock).never
       @daemon.remove_pidfile
     end
 
     it "should unlock the pidfile using the Pidlock class" do
       pidfile = mock 'pidfile', :locked? => true
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
       pidfile.expects(:unlock).returns true
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       @daemon.remove_pidfile
     end
 
     it "should warn if it cannot remove the pidfile" do
       pidfile = mock 'pidfile', :locked? => true
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
       pidfile.expects(:unlock).returns false
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       Puppet.expects :err
       @daemon.remove_pidfile
     end
   end
 
   describe "when reloading" do
     it "should do nothing if no agent is configured" do
       @daemon.reload
     end
 
     it "should do nothing if the agent is running" do
       agent = mock 'agent'
       agent.expects(:running?).returns true
 
       @daemon.stubs(:agent).returns agent
 
       @daemon.reload
     end
 
     it "should run the agent if one is available and it is not running" do
       agent = mock 'agent'
       agent.expects(:running?).returns false
       agent.expects :run
 
       @daemon.stubs(:agent).returns agent
 
       @daemon.reload
     end
   end
 
   describe "when restarting" do
     before do
       without_warnings { Puppet::Application = Class.new(Puppet::Application) }
     end
 
     after do
       without_warnings { Puppet::Application = Puppet::Application.superclass }
     end
 
     it 'should set Puppet::Application.restart!' do
       Puppet::Application.expects(:restart!)
       @daemon.stubs(:reexec)
       @daemon.restart
     end
 
     it "should reexec itself if no agent is available" do
       @daemon.expects(:reexec)
 
       @daemon.restart
     end
 
     it "should reexec itself if the agent is not running" do
       agent = mock 'agent'
       agent.expects(:running?).returns false
       @daemon.stubs(:agent).returns agent
       @daemon.expects(:reexec)
 
       @daemon.restart
     end
   end
 
   describe "when reexecing it self" do
     before do
       @daemon.stubs(:exec)
       @daemon.stubs(:stop)
     end
 
     it "should fail if no argv values are available" do
       @daemon.expects(:argv).returns nil
       lambda { @daemon.reexec }.should raise_error(Puppet::DevError)
     end
 
     it "should shut down without exiting" do
       @daemon.argv = %w{foo}
       @daemon.expects(:stop).with(:exit => false)
 
       @daemon.reexec
     end
 
     it "should call 'exec' with the original executable and arguments" do
       @daemon.argv = %w{foo}
       @daemon.expects(:exec).with($0 + " foo")
 
       @daemon.reexec
     end
   end
 end
diff --git a/spec/unit/network/server_spec.rb b/spec/unit/network/server_spec.rb
index ccd9c082e..c2496dcca 100755
--- a/spec/unit/network/server_spec.rb
+++ b/spec/unit/network/server_spec.rb
@@ -1,534 +1,527 @@
 #!/usr/bin/env ruby
 #
 #  Created by Rick Bradley on 2007-10-03.
 #  Copyright (c) 2007. All rights reserved.
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/network/server'
+require 'puppet/network/handler'
 
 describe Puppet::Network::Server do
   before do
     @mock_http_server_class = mock('http server class')
     Puppet.settings.stubs(:use)
     Puppet.settings.stubs(:value).with(:name).returns("me")
     Puppet.settings.stubs(:value).with(:servertype).returns(:suparserver)
     Puppet.settings.stubs(:value).with(:bindaddress).returns("")
     Puppet.settings.stubs(:value).with(:masterport).returns(8140)
     Puppet::Network::HTTP.stubs(:server_class_by_type).returns(@mock_http_server_class)
     Puppet.settings.stubs(:value).with(:servertype).returns(:suparserver)
     @server = Puppet::Network::Server.new(:port => 31337)
   end
 
   describe "when initializing" do
     before do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
       Puppet::Network::Handler.stubs(:handler).returns mock('xmlrpc_handler')
       Puppet.settings.stubs(:value).with(:bindaddress).returns("")
       Puppet.settings.stubs(:value).with(:masterport).returns('')
     end
 
     it 'should fail if an unknown option is provided' do
       lambda { Puppet::Network::Server.new(:foo => 31337) }.should raise_error(ArgumentError)
     end
 
     it "should allow specifying a listening port" do
       Puppet.settings.stubs(:value).with(:bindaddress).returns('')
       @server = Puppet::Network::Server.new(:port => 31337)
       @server.port.should == 31337
     end
 
     it "should use the :bindaddress setting to determine the default listening address" do
       Puppet.settings.stubs(:value).with(:masterport).returns('')
       Puppet.settings.expects(:value).with(:bindaddress).returns("10.0.0.1")
       @server = Puppet::Network::Server.new
       @server.address.should == "10.0.0.1"
     end
 
     it "should set the bind address to '127.0.0.1' if the default address is an empty string and the server type is mongrel" do
       Puppet.settings.stubs(:value).with(:servertype).returns("mongrel")
       Puppet.settings.expects(:value).with(:bindaddress).returns("")
       @server = Puppet::Network::Server.new
       @server.address.should == '127.0.0.1'
     end
 
     it "should set the bind address to '0.0.0.0' if the default address is an empty string and the server type is webrick" do
       Puppet.settings.stubs(:value).with(:servertype).returns("webrick")
       Puppet.settings.expects(:value).with(:bindaddress).returns("")
       @server = Puppet::Network::Server.new
       @server.address.should == '0.0.0.0'
     end
 
     it "should use the Puppet configurator to find a default listening port" do
       Puppet.settings.stubs(:value).with(:bindaddress).returns('')
       Puppet.settings.expects(:value).with(:masterport).returns(6667)
       @server = Puppet::Network::Server.new
       @server.port.should == 6667
     end
 
     it "should fail to initialize if no listening port can be found" do
       Puppet.settings.stubs(:value).with(:bindaddress).returns("127.0.0.1")
       Puppet.settings.stubs(:value).with(:masterport).returns(nil)
       lambda { Puppet::Network::Server.new }.should raise_error(ArgumentError)
     end
 
     it "should use the Puppet configurator to determine which HTTP server will be used to provide access to clients" do
       Puppet.settings.expects(:value).with(:servertype).returns(:suparserver)
       @server = Puppet::Network::Server.new(:port => 31337)
       @server.server_type.should == :suparserver
     end
 
     it "should fail to initialize if there is no HTTP server known to the Puppet configurator" do
       Puppet.settings.expects(:value).with(:servertype).returns(nil)
       lambda { Puppet::Network::Server.new(:port => 31337) }.should raise_error
     end
 
     it "should ask the Puppet::Network::HTTP class to fetch the proper HTTP server class" do
       Puppet::Network::HTTP.expects(:server_class_by_type).with(:suparserver).returns(@mock_http_server_class)
       @server = Puppet::Network::Server.new(:port => 31337)
     end
 
     it "should fail if the HTTP server class is unknown" do
       Puppet::Network::HTTP.stubs(:server_class_by_type).returns(nil)
       lambda { Puppet::Network::Server.new(:port => 31337) }.should raise_error(ArgumentError)
     end
 
     it "should allow registering REST handlers" do
       @server = Puppet::Network::Server.new(:port => 31337, :handlers => [ :foo, :bar, :baz])
       lambda { @server.unregister(:foo, :bar, :baz) }.should_not raise_error
     end
 
     it "should allow registering XMLRPC handlers" do
       @server = Puppet::Network::Server.new(:port => 31337, :xmlrpc_handlers => [ :foo, :bar, :baz])
       lambda { @server.unregister_xmlrpc(:foo, :bar, :baz) }.should_not raise_error
     end
 
     it "should not be listening after initialization" do
       Puppet::Network::Server.new(:port => 31337).should_not be_listening
     end
 
     it "should use the :main setting section" do
       Puppet.settings.expects(:use).with { |*args| args.include?(:main) }
       @server = Puppet::Network::Server.new(:port => 31337, :xmlrpc_handlers => [ :foo, :bar, :baz])
     end
 
     it "should use the Puppet[:name] setting section" do
       Puppet.settings.expects(:value).with(:name).returns "me"
       Puppet.settings.expects(:use).with { |*args| args.include?("me") }
 
       @server = Puppet::Network::Server.new(:port => 31337, :xmlrpc_handlers => [ :foo, :bar, :baz])
     end
   end
 
   # We don't test the method, because it's too much of a Unix-y pain.
   it "should be able to daemonize" do
     @server.should respond_to(:daemonize)
   end
 
   describe "when being started" do
     before do
       @server.stubs(:listen)
       @server.stubs(:create_pidfile)
     end
 
     it "should listen" do
       @server.expects(:listen)
       @server.start
     end
 
     it "should create its PID file" do
       @server.expects(:create_pidfile)
       @server.start
     end
   end
 
   describe "when being stopped" do
     before do
       @server.stubs(:unlisten)
       @server.stubs(:remove_pidfile)
     end
 
     it "should unlisten" do
       @server.expects(:unlisten)
       @server.stop
     end
 
     it "should remove its PID file" do
       @server.expects(:remove_pidfile)
       @server.stop
     end
   end
 
   describe "when creating its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.settings.expects(:value).with(:name).returns "me"
-
-      sync = mock 'sync'
-      Puppet::Util.expects(:sync).with("me").returns sync
-
-      sync.expects(:synchronize).with(Sync::EX)
+      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
       @server.create_pidfile
     end
 
     it "should lock the pidfile using the Pidlock class" do
       pidfile = mock 'pidfile'
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.expects(:value).with(:pidfile).returns "/my/file"
 
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
 
       pidfile.expects(:lock).returns true
       @server.create_pidfile
     end
 
     it "should fail if it cannot lock" do
       pidfile = mock 'pidfile'
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
 
       pidfile.expects(:lock).returns false
 
       lambda { @server.create_pidfile }.should raise_error
     end
   end
 
   describe "when removing its pidfile" do
     it "should use an exclusive mutex" do
       Puppet.settings.expects(:value).with(:name).returns "me"
-
-      sync = mock 'sync'
-      Puppet::Util.expects(:sync).with("me").returns sync
-
-      sync.expects(:synchronize).with(Sync::EX)
+      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
       @server.remove_pidfile
     end
 
     it "should do nothing if the pidfile is not present" do
       pidfile = mock 'pidfile', :locked? => false
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       pidfile.expects(:unlock).never
       @server.remove_pidfile
     end
 
     it "should unlock the pidfile using the Pidlock class" do
       pidfile = mock 'pidfile', :locked? => true
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
       pidfile.expects(:unlock).returns true
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       @server.remove_pidfile
     end
 
     it "should warn if it cannot remove the pidfile" do
       pidfile = mock 'pidfile', :locked? => true
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
       pidfile.expects(:unlock).returns false
 
       Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
       Puppet.expects :err
       @server.remove_pidfile
     end
   end
 
   describe "when managing indirection registrations" do
     before do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
     end
 
     it "should allow registering an indirection for client access by specifying its indirection name" do
       lambda { @server.register(:foo) }.should_not raise_error
     end
 
     it "should require that the indirection be valid" do
       Puppet::Indirector::Indirection.expects(:model).with(:foo).returns nil
       lambda { @server.register(:foo) }.should raise_error(ArgumentError)
     end
 
     it "should require at least one indirection name when registering indirections for client access" do
       lambda { @server.register }.should raise_error(ArgumentError)
     end
 
     it "should allow for numerous indirections to be registered at once for client access" do
       lambda { @server.register(:foo, :bar, :baz) }.should_not raise_error
     end
 
     it "should allow the use of indirection names to specify which indirections are to be no longer accessible to clients" do
       @server.register(:foo)
       lambda { @server.unregister(:foo) }.should_not raise_error
     end
 
     it "should leave other indirections accessible to clients when turning off indirections" do
       @server.register(:foo, :bar)
       @server.unregister(:foo)
       lambda { @server.unregister(:bar)}.should_not raise_error
     end
 
     it "should allow specifying numerous indirections which are to be no longer accessible to clients" do
       @server.register(:foo, :bar)
       lambda { @server.unregister(:foo, :bar) }.should_not raise_error
     end
 
     it "should not turn off any indirections if given unknown indirection names to turn off" do
       @server.register(:foo, :bar)
       lambda { @server.unregister(:foo, :bar, :baz) }.should raise_error(ArgumentError)
       lambda { @server.unregister(:foo, :bar) }.should_not raise_error
     end
 
     it "should not allow turning off unknown indirection names" do
       @server.register(:foo, :bar)
       lambda { @server.unregister(:baz) }.should raise_error(ArgumentError)
     end
 
     it "should disable client access immediately when turning off indirections" do
       @server.register(:foo, :bar)
       @server.unregister(:foo)
       lambda { @server.unregister(:foo) }.should raise_error(ArgumentError)
     end
 
     it "should allow turning off all indirections at once" do
       @server.register(:foo, :bar)
       @server.unregister
       [ :foo, :bar, :baz].each do |indirection|
         lambda { @server.unregister(indirection) }.should raise_error(ArgumentError)
       end
     end
   end
 
   it "should provide a means of determining whether it is listening" do
     @server.should respond_to(:listening?)
   end
 
   it "should provide a means of determining which HTTP server will be used to provide access to clients" do
     @server.server_type.should == :suparserver
   end
 
   it "should provide a means of determining which protocols are in use" do
     @server.should respond_to(:protocols)
   end
 
   it "should set the protocols to :rest and :xmlrpc" do
     @server.protocols.should == [ :rest, :xmlrpc ]
   end
 
   it "should provide a means of determining the listening address" do
     @server.address.should == "127.0.0.1"
   end
 
   it "should provide a means of determining the listening port" do
     @server.port.should == 31337
   end
 
   it "should allow for multiple configurations, each handling different indirections" do
     Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
 
     @server2 = Puppet::Network::Server.new(:port => 31337)
     @server.register(:foo, :bar)
     @server2.register(:foo, :xyzzy)
     @server.unregister(:foo, :bar)
     @server2.unregister(:foo, :xyzzy)
     lambda { @server.unregister(:xyzzy) }.should raise_error(ArgumentError)
     lambda { @server2.unregister(:bar) }.should raise_error(ArgumentError)
   end
 
   describe "when managing xmlrpc registrations" do
     before do
       Puppet::Network::Handler.stubs(:handler).returns mock('xmlrpc_handler')
     end
 
     it "should allow registering an xmlrpc handler by specifying its namespace" do
       lambda { @server.register_xmlrpc(:foo) }.should_not raise_error
     end
 
     it "should require that the xmlrpc namespace be valid" do
       Puppet::Network::Handler.stubs(:handler).returns nil
 
       lambda { @server.register_xmlrpc(:foo) }.should raise_error(ArgumentError)
     end
 
     it "should require at least one namespace" do
       lambda { @server.register_xmlrpc }.should raise_error(ArgumentError)
     end
 
     it "should allow multiple namespaces to be registered at once" do
       lambda { @server.register_xmlrpc(:foo, :bar) }.should_not raise_error
     end
 
     it "should allow the use of namespaces to specify which are no longer accessible to clients" do
       @server.register_xmlrpc(:foo, :bar)
     end
 
     it "should leave other namespaces accessible to clients when turning off xmlrpc namespaces" do
       @server.register_xmlrpc(:foo, :bar)
       @server.unregister_xmlrpc(:foo)
       lambda { @server.unregister_xmlrpc(:bar)}.should_not raise_error
     end
 
     it "should allow specifying numerous namespaces which are to be no longer accessible to clients" do
       @server.register_xmlrpc(:foo, :bar)
       lambda { @server.unregister_xmlrpc(:foo, :bar) }.should_not raise_error
     end
 
     it "should not turn off any indirections if given unknown namespaces to turn off" do
       @server.register_xmlrpc(:foo, :bar)
       lambda { @server.unregister_xmlrpc(:foo, :bar, :baz) }.should raise_error(ArgumentError)
       lambda { @server.unregister_xmlrpc(:foo, :bar) }.should_not raise_error
     end
 
     it "should not allow turning off unknown namespaces" do
       @server.register_xmlrpc(:foo, :bar)
       lambda { @server.unregister_xmlrpc(:baz) }.should raise_error(ArgumentError)
     end
 
     it "should disable client access immediately when turning off namespaces" do
       @server.register_xmlrpc(:foo, :bar)
       @server.unregister_xmlrpc(:foo)
       lambda { @server.unregister_xmlrpc(:foo) }.should raise_error(ArgumentError)
     end
 
     it "should allow turning off all namespaces at once" do
       @server.register_xmlrpc(:foo, :bar)
       @server.unregister_xmlrpc
       [ :foo, :bar, :baz].each do |indirection|
         lambda { @server.unregister_xmlrpc(indirection) }.should raise_error(ArgumentError)
       end
     end
   end
 
   describe "when listening is off" do
     before do
       @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
       @server.stubs(:http_server).returns(@mock_http_server)
     end
 
     it "should indicate that it is not listening" do
       @server.should_not be_listening
     end
 
     it "should not allow listening to be turned off" do
       lambda { @server.unlisten }.should raise_error(RuntimeError)
     end
 
     it "should allow listening to be turned on" do
       lambda { @server.listen }.should_not raise_error
     end
 
   end
 
   describe "when listening is on" do
     before do
       @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
       @mock_http_server.stubs(:unlisten)
       @server.stubs(:http_server).returns(@mock_http_server)
       @server.listen
     end
 
     it "should indicate that it is listening" do
       @server.should be_listening
     end
 
     it "should not allow listening to be turned on" do
       lambda { @server.listen }.should raise_error(RuntimeError)
     end
 
     it "should allow listening to be turned off" do
       lambda { @server.unlisten }.should_not raise_error
     end
   end
 
   describe "when listening is being turned on" do
     before do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
       Puppet::Network::Handler.stubs(:handler).returns mock('xmlrpc_handler')
 
       @server = Puppet::Network::Server.new(:port => 31337, :handlers => [:node], :xmlrpc_handlers => [:master])
       @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
     end
 
     it "should fetch an instance of an HTTP server" do
       @server.stubs(:http_server_class).returns(@mock_http_server_class)
       @mock_http_server_class.expects(:new).returns(@mock_http_server)
       @server.listen
     end
 
     it "should cause the HTTP server to listen" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen)
       @server.listen
     end
 
     it "should pass the listening address to the HTTP server" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen).with do |args|
         args[:address] == '127.0.0.1'
       end
       @server.listen
     end
 
     it "should pass the listening port to the HTTP server" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen).with do |args|
         args[:port] == 31337
       end
       @server.listen
     end
 
     it "should pass a list of REST handlers to the HTTP server" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen).with do |args|
         args[:handlers] == [ :node ]
       end
       @server.listen
     end
 
     it "should pass a list of XMLRPC handlers to the HTTP server" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen).with do |args|
         args[:xmlrpc_handlers] == [ :master ]
       end
       @server.listen
     end
 
     it "should pass a list of protocols to the HTTP server" do
       @server.stubs(:http_server).returns(@mock_http_server)
       @mock_http_server.expects(:listen).with do |args|
         args[:protocols] == [ :rest, :xmlrpc ]
       end
       @server.listen
     end
   end
 
   describe "when listening is being turned off" do
     before do
       @mock_http_server = mock('http server')
       @mock_http_server.stubs(:listen)
       @server.stubs(:http_server).returns(@mock_http_server)
       @server.listen
     end
 
     it "should cause the HTTP server to stop listening" do
       @mock_http_server.expects(:unlisten)
       @server.unlisten
     end
 
     it "should not allow for indirections to be turned off" do
       Puppet::Indirector::Indirection.stubs(:model).returns mock('indirection')
 
       @server.register(:foo)
       lambda { @server.unregister(:foo) }.should raise_error(RuntimeError)
     end
   end
 end
diff --git a/spec/unit/util/file_locking_spec.rb b/spec/unit/util/file_locking_spec.rb
index 476aa2caa..8fafb1d52 100755
--- a/spec/unit/util/file_locking_spec.rb
+++ b/spec/unit/util/file_locking_spec.rb
@@ -1,174 +1,160 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 require 'puppet/util/file_locking'
 
 class FileLocker
   include Puppet::Util::FileLocking
 end
 
 describe Puppet::Util::FileLocking do
   it "should have a module method for getting a read lock on files" do
     Puppet::Util::FileLocking.should respond_to(:readlock)
   end
 
   it "should have a module method for getting a write lock on files" do
     Puppet::Util::FileLocking.should respond_to(:writelock)
   end
 
   it "should have an instance method for getting a read lock on files" do
     FileLocker.new.private_methods.should be_include("readlock")
   end
 
   it "should have an instance method for getting a write lock on files" do
     FileLocker.new.private_methods.should be_include("writelock")
   end
 
   describe "when acquiring a read lock" do
     before do
       File.stubs(:exists?).with('/file').returns true
       File.stubs(:file?).with('/file').returns true
     end
 
     it "should use a global shared mutex" do
-      @sync = mock 'sync'
-      @sync.expects(:synchronize).with(Sync::SH).once
-      Puppet::Util.expects(:sync).with('/file').returns @sync
-
+      Puppet::Util.expects(:synchronize_on).with('/file',Sync::SH).once
       Puppet::Util::FileLocking.readlock '/file'
     end
 
     it "should use a shared lock on the file" do
-      @sync = mock 'sync'
-      @sync.stubs(:synchronize).yields
-      Puppet::Util.expects(:sync).with('/file').returns @sync
+      Puppet::Util.expects(:synchronize_on).with('/file',Sync::SH).yields
 
       fh = mock 'filehandle'
       File.expects(:open).with("/file").yields fh
       fh.expects(:lock_shared).yields "locked_fh"
 
       result = nil
       Puppet::Util::FileLocking.readlock('/file') { |l| result = l }
       result.should == "locked_fh"
     end
 
     it "should only work on regular files" do
       File.expects(:file?).with('/file').returns false
       proc { Puppet::Util::FileLocking.readlock('/file') }.should raise_error(ArgumentError)
     end
 
     it "should create missing files" do
-      @sync = mock 'sync'
-      @sync.stubs(:synchronize).yields
-      Puppet::Util.expects(:sync).with('/file').returns @sync
+      Puppet::Util.expects(:synchronize_on).with('/file',Sync::SH).yields
 
       File.expects(:exists?).with('/file').returns false
       File.expects(:open).with('/file').once
 
       Puppet::Util::FileLocking.readlock('/file')
     end
   end
 
   describe "when acquiring a write lock" do
     before do
-      @sync = mock 'sync'
-      Puppet::Util.stubs(:sync).returns @sync
-      @sync.stubs(:synchronize).yields
+      Puppet::Util.stubs(:synchronize_on).yields
       File.stubs(:file?).with('/file').returns true
       File.stubs(:exists?).with('/file').returns true
     end
 
     it "should fail if the parent directory does not exist" do
       FileTest.expects(:directory?).with("/my/dir").returns false
       File.stubs(:file?).with('/my/dir/file').returns true
       File.stubs(:exists?).with('/my/dir/file').returns true
 
       lambda { Puppet::Util::FileLocking.writelock('/my/dir/file') }.should raise_error(Puppet::DevError)
     end
 
     it "should use a global exclusive mutex" do
-      sync = mock 'sync'
-      sync.expects(:synchronize).with(Sync::EX)
-      Puppet::Util.expects(:sync).with("/file").returns sync
-
+      Puppet::Util.expects(:synchronize_on).with("/file",Sync::EX)
       Puppet::Util::FileLocking.writelock '/file'
     end
 
     it "should use any specified mode when opening the file" do
       File.expects(:open).with("/file", File::Constants::CREAT | File::Constants::WRONLY , :mymode)
 
       Puppet::Util::FileLocking.writelock('/file', :mymode)
     end
 
     it "should use the mode of the existing file if no mode is specified" do
       File.expects(:stat).with("/file").returns(mock("stat", :mode => 0755))
       File.expects(:open).with("/file", File::Constants::CREAT | File::Constants::WRONLY, 0755)
 
       Puppet::Util::FileLocking.writelock('/file')
     end
 
     it "should use 0600 as the mode if no mode is specified and the file does not exist" do
       File.expects(:stat).raises(Errno::ENOENT)
       File.expects(:open).with("/file", File::Constants::CREAT | File::Constants::WRONLY, 0600)
 
       Puppet::Util::FileLocking.writelock('/file')
     end
 
     it "should create an exclusive file lock" do
       fh = mock 'fh'
       File.expects(:open).yields fh
       fh.expects(:lock_exclusive)
 
       Puppet::Util::FileLocking.writelock('/file')
     end
 
     it "should allow the caller to write to the locked file" do
       fh = mock 'fh'
       File.expects(:open).yields fh
 
       lfh = mock 'locked_filehandle'
       fh.expects(:lock_exclusive).yields(lfh)
 
       lfh.stubs(:seek)
       lfh.stubs(:truncate)
       lfh.expects(:print).with "foo"
 
       Puppet::Util::FileLocking.writelock('/file') do |f|
         f.print "foo"
       end
     end
 
     it "should truncate the file under an exclusive lock" do
       fh = mock 'fh'
       File.expects(:open).yields fh
 
       lfh = mock 'locked_filehandle'
       fh.expects(:lock_exclusive).yields(lfh)
 
       lfh.expects(:seek).with(0, IO::SEEK_SET)
       lfh.expects(:truncate).with(0)
       lfh.stubs(:print)
 
       Puppet::Util::FileLocking.writelock('/file') do |f|
         f.print "foo"
       end
     end
 
     it "should only work on regular files" do
       File.expects(:file?).with('/file').returns false
       proc { Puppet::Util::FileLocking.writelock('/file') }.should raise_error(ArgumentError)
     end
 
     it "should create missing files" do
-      @sync = mock 'sync'
-      @sync.stubs(:synchronize).yields
-      Puppet::Util.expects(:sync).with('/file').returns @sync
+      Puppet::Util.expects(:synchronize_on).with('/file',Sync::EX).yields
 
       File.expects(:exists?).with('/file').returns false
       File.expects(:open).with('/file', File::Constants::CREAT | File::Constants::WRONLY, 0600).once
 
       Puppet::Util::FileLocking.writelock('/file')
     end
   end
 end