diff --git a/lib/puppet/type/tidy.rb b/lib/puppet/type/tidy.rb
index 93a7e96cf..146481fed 100755
--- a/lib/puppet/type/tidy.rb
+++ b/lib/puppet/type/tidy.rb
@@ -1,333 +1,333 @@
 Puppet::Type.newtype(:tidy) do
   require 'puppet/file_serving/fileset'
   require 'puppet/file_bucket/dipper'
 
   @doc = "Remove unwanted files based on specific criteria.  Multiple
     criteria are OR'd together, so a file that is too large but is not
     old enough will still get tidied.
 
     If you don't specify either `age` or `size`, then all files will
     be removed.
 
     This resource type works by generating a file resource for every file
     that should be deleted and then letting that resource perform the
     actual deletion.
     "
 
   newparam(:path) do
     desc "The path to the file or directory to manage.  Must be fully
       qualified."
     isnamevar
   end
 
   newparam(:recurse) do
     desc "If target is a directory, recursively descend
       into the directory looking for files to tidy."
 
     newvalues(:true, :false, :inf, /^[0-9]+$/)
 
     # Replace the validation so that we allow numbers in
     # addition to string representations of them.
     validate { |arg| }
     munge do |value|
       newval = super(value)
       case newval
       when :true, :inf; true
       when :false; false
       when Integer, Fixnum, Bignum; value
       when /^\d+$/; Integer(value)
       else
         raise ArgumentError, "Invalid recurse value #{value.inspect}"
       end
     end
   end
 
   newparam(:matches) do
     desc "One or more (shell type) file glob patterns, which restrict
       the list of files to be tidied to those whose basenames match
       at least one of the patterns specified. Multiple patterns can
       be specified using an array.
 
       Example:
 
           tidy { \"/tmp\":
             age => \"1w\",
             recurse => 1,
             matches => [ \"[0-9]pub*.tmp\", \"*.temp\", \"tmpfile?\" ]
           }
 
       This removes files from `/tmp` if they are one week old or older,
       are not in a subdirectory and match one of the shell globs given.
 
       Note that the patterns are matched against the basename of each
       file -- that is, your glob patterns should not have any '/'
       characters in them, since you are only specifying against the last
       bit of the file.
 
       Finally, note that you must now specify a non-zero/non-false value
       for recurse if matches is used, as matches only apply to files found
       by recursion (there's no reason to use static patterns match against
       a statically determined path).  Requiering explicit recursion clears
       up a common source of confusion."
 
     # Make sure we convert to an array.
     munge do |value|
       fail "Tidy can't use matches with recurse 0, false, or undef" if "#{@resource[:recurse]}" =~ /^(0|false|)$/
       [value].flatten
     end
 
     # Does a given path match our glob patterns, if any?  Return true
     # if no patterns have been provided.
     def tidy?(path, stat)
       basename = File.basename(path)
       flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
       return(value.find {|pattern| File.fnmatch(pattern, basename, flags) } ? true : false)
     end
   end
 
   newparam(:backup) do
     desc "Whether tidied files should be backed up.  Any values are passed
       directly to the file resources used for actual file deletion, so use
       its backup documentation to determine valid values."
   end
 
   newparam(:age) do
     desc "Tidy files whose age is equal to or greater than
       the specified time.  You can choose seconds, minutes,
       hours, days, or weeks by specifying the first letter of any
       of those words (e.g., '1w').
 
       Specifying 0 will remove all files."
 
     @@ageconvertors = {
       :s => 1,
       :m => 60
     }
 
     @@ageconvertors[:h] = @@ageconvertors[:m] * 60
     @@ageconvertors[:d] = @@ageconvertors[:h] * 24
     @@ageconvertors[:w] = @@ageconvertors[:d] * 7
 
     def convert(unit, multi)
       if num = @@ageconvertors[unit]
         return num * multi
       else
         self.fail "Invalid age unit '#{unit}'"
       end
     end
 
     def tidy?(path, stat)
       # If the file's older than we allow, we should get rid of it.
       (Time.now.to_i - stat.send(resource[:type]).to_i) > value
     end
 
     munge do |age|
       unit = multi = nil
       case age
       when /^([0-9]+)(\w)\w*$/
         multi = Integer($1)
         unit = $2.downcase.intern
       when /^([0-9]+)$/
         multi = Integer($1)
         unit = :d
       else
         self.fail "Invalid tidy age #{age}"
       end
 
       convert(unit, multi)
     end
   end
 
   newparam(:size) do
     desc "Tidy files whose size is equal to or greater than
       the specified size.  Unqualified values are in kilobytes, but
       *b*, *k*, *m*, *g*, and *t* can be appended to specify *bytes*,
       *kilobytes*, *megabytes*, *gigabytes*, and *terabytes*, respectively.
       Only the first character is significant, so the full word can also 
       be used."
 
     @@sizeconvertors = {
       :b => 0,
       :k => 1,
       :m => 2,
       :g => 3,
       :t => 4
     }
 
     def convert(unit, multi)
       if num = @@sizeconvertors[unit]
         result = multi
         num.times do result *= 1024 end
         return result
       else
         self.fail "Invalid size unit '#{unit}'"
       end
     end
 
     def tidy?(path, stat)
       stat.size >= value
     end
 
     munge do |size|
       case size
       when /^([0-9]+)(\w)\w*$/
         multi = Integer($1)
         unit = $2.downcase.intern
       when /^([0-9]+)$/
         multi = Integer($1)
         unit = :k
       else
         self.fail "Invalid tidy size #{age}"
       end
 
       convert(unit, multi)
     end
   end
 
   newparam(:type) do
     desc "Set the mechanism for determining age."
 
     newvalues(:atime, :mtime, :ctime)
 
     defaultto :atime
   end
 
   newparam(:rmdirs, :boolean => true) do
     desc "Tidy directories in addition to files; that is, remove
       directories whose age is older than the specified criteria.
       This will only remove empty directories, so all contained
       files must also be tidied before a directory gets removed."
 
     newvalues :true, :false
   end
 
   # Erase PFile's validate method
   validate do
   end
 
   def self.instances
     []
   end
 
   @depthfirst = true
 
   def initialize(hash)
     super
 
     # only allow backing up into filebuckets
     self[:backup] = false unless self[:backup].is_a? Puppet::FileBucket::Dipper
   end
 
   # Make a file resource to remove a given file.
   def mkfile(path)
     # Force deletion, so directories actually get deleted.
     Puppet::Type.type(:file).new :path => path, :backup => self[:backup], :ensure => :absent, :force => true
   end
 
   def retrieve
     # Our ensure property knows how to retrieve everything for us.
     if obj = @parameters[:ensure]
       return obj.retrieve
     else
       return {}
     end
   end
 
   # Hack things a bit so we only ever check the ensure property.
   def properties
     []
   end
 
   def eval_generate
     []
   end
 
   def generate
     return [] unless stat(self[:path])
 
     case self[:recurse]
     when Integer, Fixnum, Bignum, /^\d+$/
       parameter = { :recurse => true, :recurselimit => self[:recurse] }
     when true, :true, :inf
       parameter = { :recurse => true }
     end
 
     if parameter
       files = Puppet::FileServing::Fileset.new(self[:path], parameter).files.collect do |f|
-        f == "." ? self[:path] : File.join(self[:path], f)
+        f == "." ? self[:path] : ::File.join(self[:path], f)
       end
     else
       files = [self[:path]]
     end
     result = files.find_all { |path| tidy?(path) }.collect { |path| mkfile(path) }.each { |file| notice "Tidying #{file.ref}" }.sort { |a,b| b[:path] <=> a[:path] }
 
     # No need to worry about relationships if we don't have rmdirs; there won't be
     # any directories.
     return result unless rmdirs?
 
     # Now make sure that all directories require the files they contain, if all are available,
     # so that a directory is emptied before we try to remove it.
     files_by_name = result.inject({}) { |hash, file| hash[file[:path]] = file; hash }
 
     files_by_name.keys.sort { |a,b| b <=> b }.each do |path|
-      dir = File.dirname(path)
+      dir = ::File.dirname(path)
       next unless resource = files_by_name[dir]
       if resource[:require]
         resource[:require] << Puppet::Resource.new(:file, path)
       else
         resource[:require] = [Puppet::Resource.new(:file, path)]
       end
     end
 
     result
   end
 
   # Does a given path match our glob patterns, if any?  Return true
   # if no patterns have been provided.
   def matches?(path)
     return true unless self[:matches]
 
     basename = File.basename(path)
     flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
     if self[:matches].find {|pattern| File.fnmatch(pattern, basename, flags) }
       return true
     else
       debug "No specified patterns match #{path}, not tidying"
       return false
     end
   end
 
   # Should we remove the specified file?
   def tidy?(path)
     return false unless stat = self.stat(path)
 
     return false if stat.ftype == "directory" and ! rmdirs?
 
     # The 'matches' parameter isn't OR'ed with the other tests --
     # it's just used to reduce the list of files we can match.
     return false if param = parameter(:matches) and ! param.tidy?(path, stat)
 
     tested = false
     [:age, :size].each do |name|
       next unless param = parameter(name)
       tested = true
       return true if param.tidy?(path, stat)
     end
 
     # If they don't specify either, then the file should always be removed.
     return true unless tested
     false
   end
 
   def stat(path)
     begin
-      File.lstat(path)
+      ::File.lstat(path)
     rescue Errno::ENOENT => error
       info "File does not exist"
       return nil
     rescue Errno::EACCES => error
       warning "Could not stat; permission denied"
       return nil
     end
   end
 end
diff --git a/lib/puppet/type/zone.rb b/lib/puppet/type/zone.rb
index 1bae93120..0fc702ccf 100644
--- a/lib/puppet/type/zone.rb
+++ b/lib/puppet/type/zone.rb
@@ -1,490 +1,490 @@
 Puppet::Type.newtype(:zone) do
   @doc = "Solaris zones.
 
 **Autorequires:** If Puppet is managing the directory specified as the root of the zone's filesystem (with the `path` attribute), the zone resource will autorequire that directory."
 
   # These properties modify the zone configuration, and they need to provide
   # the text separately from syncing it, so all config statements can be rolled
   # into a single creation statement.
   class ZoneConfigProperty < Puppet::Property
     # Perform the config operation.
     def sync
       provider.setconfig self.configtext
     end
   end
 
   # Those properties that can have multiple instances.
   class ZoneMultiConfigProperty < ZoneConfigProperty
     def configtext
       list = @should
 
       current_value = self.retrieve
 
       unless current_value.is_a? Symbol
         if current_value.is_a? Array
           list += current_value
         else
           list << current_value if current_value
         end
       end
 
       # Some hackery so we can test whether current_value is an array or a symbol
       if current_value.is_a? Array
         tmpis = current_value
       else
         if current_value
           tmpis = [current_value]
         else
           tmpis = []
         end
       end
 
       rms = []
       adds = []
 
       # Collect the modifications to make
       list.sort.uniq.collect do |obj|
         # Skip objectories that are configured and should be
         next if tmpis.include?(obj) and @should.include?(obj)
 
         if tmpis.include?(obj)
           rms << obj
         else
           adds << obj
         end
       end
 
 
       # And then perform all of the removals before any of the adds.
       (rms.collect { |o| rm(o) } + adds.collect { |o| add(o) }).join("\n")
     end
 
     # We want all specified directories to be included.
     def insync?(current_value)
       if current_value.is_a? Array and @should.is_a? Array
         current_value.sort == @should.sort
       else
         current_value == @should
       end
     end
   end
 
   ensurable do
     desc "The running state of the zone.  The valid states directly reflect
       the states that `zoneadm` provides.  The states are linear,
       in that a zone must be `configured` then `installed`, and
       only then can be `running`.  Note also that `halt` is currently
       used to stop zones."
 
     @states = {}
     @parametervalues = []
 
     def self.alias_state(values)
       @state_aliases ||= {}
       values.each do |nick, name|
         @state_aliases[nick] = name
       end
     end
 
     def self.newvalue(name, hash)
       @parametervalues = [] if @parametervalues.is_a? Hash
 
       @parametervalues << name
 
       @states[name] = hash
       hash[:name] = name
     end
 
     def self.state_name(name)
       if other = @state_aliases[name]
         other
       else
         name
       end
     end
 
     newvalue :absent, :down => :destroy
     newvalue :configured, :up => :configure, :down => :uninstall
     newvalue :installed, :up => :install, :down => :stop
     newvalue :running, :up => :start
 
     alias_state :incomplete => :installed, :ready => :installed, :shutting_down => :running
 
     defaultto :running
 
     def self.state_index(value)
       @parametervalues.index(state_name(value))
     end
 
     # Return all of the states between two listed values, exclusive
     # of the first item.
     def self.state_sequence(first, second)
       findex = sindex = nil
       unless findex = @parametervalues.index(state_name(first))
         raise ArgumentError, "'#{first}' is not a valid zone state"
       end
       unless sindex = @parametervalues.index(state_name(second))
         raise ArgumentError, "'#{first}' is not a valid zone state"
       end
       list = nil
 
       # Apparently ranges are unidirectional, so we have to reverse
       # the range op twice.
       if findex > sindex
         list = @parametervalues[sindex..findex].collect do |name|
           @states[name]
         end.reverse
       else
         list = @parametervalues[findex..sindex].collect do |name|
           @states[name]
         end
       end
 
       # The first result is the current state, so don't return it.
       list[1..-1]
     end
 
     def retrieve
       provider.properties[:ensure]
     end
 
     def sync
       method = nil
       if up?
         direction = :up
       else
         direction = :down
       end
 
       # We need to get the state we're currently in and just call
       # everything between it and us.
       self.class.state_sequence(self.retrieve, self.should).each do |state|
         if method = state[direction]
           warned = false
           while provider.processing?
             unless warned
               info "Waiting for zone to finish processing"
               warned = true
             end
             sleep 1
           end
           provider.send(method)
         else
           raise Puppet::DevError, "Cannot move #{direction} from #{st[:name]}"
         end
       end
 
       ("zone_#{self.should}").intern
     end
 
     # Are we moving up the property tree?
     def up?
       current_value = self.retrieve
       self.class.state_index(current_value) < self.class.state_index(self.should)
     end
   end
 
   newparam(:name) do
     desc "The name of the zone."
 
     isnamevar
   end
 
   newparam(:id) do
     desc "The numerical ID of the zone.  This number is autogenerated
       and cannot be changed."
   end
 
   newparam(:clone) do
     desc "Instead of installing the zone, clone it from another zone.
       If the zone root resides on a zfs file system, a snapshot will be
       used to create the clone, is it redisides on ufs, a copy of the zone
       will be used. The zone you clone from must not be running."
   end
 
   newproperty(:ip, :parent => ZoneMultiConfigProperty) do
     require 'ipaddr'
 
     desc "The IP address of the zone.  IP addresses must be specified
       with the interface, separated by a colon, e.g.: bge0:192.168.0.1.
       For multiple interfaces, specify them in an array."
 
     # Add an interface.
     def add(str)
       interface, ip, defrouter = ipsplit(str)
       cmd = "add net\n"
       cmd += "set physical=#{interface}\n" if interface
       cmd += "set address=#{ip}\n" if ip
       cmd += "set defrouter=#{defrouter}\n" if defrouter
       #if @resource[:iptype] == :shared
       cmd += "end\n"
     end
 
     # Convert a string into the component interface, address and defrouter
     def ipsplit(str)
       interface, address, defrouter = str.split(':')
       return interface, address, defrouter
     end
 
     # Remove an interface.
     def rm(str)
       interface, ip, defrouter = ipsplit(str)
       # Reality seems to disagree with the documentation here; the docs
       # specify that braces are required, but they're apparently only
       # required if you're specifying multiple values.
       if ip
         "remove net address=#{ip}"
       elsif interface
         "remove net interface=#{interface}"
       else
         raise ArgumentError, "can not remove network based on default router"
       end
     end
   end
 
   newproperty(:iptype, :parent => ZoneConfigProperty) do
     desc "The IP stack type of the zone. Can either be 'shared' or 'exclusive'."
 
     defaultto :shared
 
     newvalue :shared
     newvalue :exclusive
 
     def configtext
       "set ip-type=#{self.should}"
     end
   end
 
   newproperty(:autoboot, :parent => ZoneConfigProperty) do
     desc "Whether the zone should automatically boot."
 
     defaultto true
 
     newvalue(:true) {}
     newvalue(:false) {}
 
     def configtext
       "set autoboot=#{self.should}"
     end
   end
 
   newproperty(:pool, :parent => ZoneConfigProperty) do
     desc "The resource pool for this zone."
 
     def configtext
       "set pool=#{self.should}"
     end
   end
 
   newproperty(:shares, :parent => ZoneConfigProperty) do
     desc "Number of FSS CPU shares allocated to the zone."
 
     def configtext
       "add rctl\nset name=zone.cpu-shares\nadd value (priv=privileged,limit=#{self.should},action=none)\nend"
     end
   end
 
   newproperty(:dataset, :parent => ZoneMultiConfigProperty) do
     desc "The list of datasets delegated to the non global zone from the
       global zone.  All datasets must be zfs filesystem names which is
       different than the mountpoint." 
 
     validate do |value|
       unless value !~ /^\//
         raise ArgumentError, "Datasets must be the name of a zfs filesystem"
       end
     end
 
     # Add a zfs filesystem to our list of datasets.
     def add(dataset)
       "add dataset\nset name=#{dataset}\nend"
     end
 
     # Remove a zfs filesystem from our list of datasets.
     def rm(dataset)
       "remove dataset name=#{dataset}"
     end
 
     def should
       @should
     end
   end
 
 
   newproperty(:inherit, :parent => ZoneMultiConfigProperty) do
     desc "The list of directories that the zone inherits from the global
       zone.  All directories must be fully qualified."
 
     validate do |value|
       unless value =~ /^\//
         raise ArgumentError, "Inherited filesystems must be fully qualified"
       end
     end
 
     # Add a directory to our list of inherited directories.
     def add(dir)
       "add inherit-pkg-dir\nset dir=#{dir}\nend"
     end
 
     def rm(dir)
       # Reality seems to disagree with the documentation here; the docs
       # specify that braces are required, but they're apparently only
       # required if you're specifying multiple values.
       "remove inherit-pkg-dir dir=#{dir}"
     end
 
     def should
       @should
     end
   end
 
   # Specify the sysidcfg file.  This is pretty hackish, because it's
   # only used to boot the zone the very first time.
   newparam(:sysidcfg) do
     desc %{The text to go into the sysidcfg file when the zone is first
       booted.  The best way is to use a template:
 
           # $templatedir/sysidcfg
           system_locale=en_US
           timezone=GMT
           terminal=xterms
           security_policy=NONE
           root_password=<%= password %>
           timeserver=localhost
           name_service=DNS {domain_name=<%= domain %> name_server=<%= nameserver %>}
           network_interface=primary {hostname=<%= realhostname %>
             ip_address=<%= ip %>
             netmask=<%= netmask %>
             protocol_ipv6=no
             default_route=<%= defaultroute %>}
           nfs4_domain=dynamic
 
       And then call that:
 
           zone { myzone:
             ip => "bge0:192.168.0.23",
             sysidcfg => template(sysidcfg),
             path => "/opt/zones/myzone",
             realhostname => "fully.qualified.domain.name"
           }
 
       The sysidcfg only matters on the first booting of the zone,
       so Puppet only checks for it at that time.}
   end
 
   newparam(:path) do
     desc "The root of the zone's filesystem.  Must be a fully qualified
       file name.  If you include '%s' in the path, then it will be
       replaced with the zone's name.  At this point, you cannot use
       Puppet to move a zone."
 
     validate do |value|
       unless value =~ /^\//
         raise ArgumentError, "The zone base must be fully qualified"
       end
     end
 
     munge do |value|
       if value =~ /%s/
         value % @resource[:name]
       else
         value
       end
     end
   end
 
   newparam(:create_args) do
     desc "Arguments to the zonecfg create command.  This can be used to create branded zones."
   end
 
   newparam(:install_args) do
     desc "Arguments to the zoneadm install command.  This can be used to create branded zones."
   end
 
   newparam(:realhostname) do
     desc "The actual hostname of the zone."
   end
 
   # If Puppet is also managing the base dir or its parent dir, list them
   # both as prerequisites.
   autorequire(:file) do
     if @parameters.include? :path
-      [@parameters[:path].value, File.dirname(@parameters[:path].value)]
+      [@parameters[:path].value, ::File.dirname(@parameters[:path].value)]
     else
       nil
     end
   end
 
   # If Puppet is also managing the zfs filesystem which is the zone dataset
   # then list it as a prerequisite.  Zpool's get autorequired by the zfs
   # type.  We just need to autorequire the dataset zfs itself as the zfs type
   # will autorequire all of the zfs parents and zpool.
   autorequire(:zfs) do
 
   # Check if we have datasets in our zone configuration
     if @parameters.include? :dataset
       reqs = []
       # Autorequire each dataset
       self[:dataset].each { |value|
         reqs << value
       }
       reqs
     end
   end
 
   def validate_ip(ip, name)
       IPAddr.new(ip) if ip
   rescue ArgumentError
       self.fail "'#{ip}' is an invalid #{name}"
   end
 
   validate do
     value = self[:ip]
     interface, address, defrouter = value.split(':')
     if self[:iptype] == :shared
       if (interface && address && defrouter.nil?) ||
         (interface && address && defrouter)
         validate_ip(address, "IP address")
         validate_ip(defrouter, "default router")
       else
         self.fail "ip must contain interface name and ip address separated by a \":\""
       end
     else
       self.fail "only interface may be specified when using exclusive IP stack: #{value}" unless interface && address.nil? && defrouter.nil?
     end
 
     self.fail "zone path is required" unless self[:path]
   end
 
   def retrieve
     provider.flush
     if hash = provider.properties and hash[:ensure] != :absent
       result = setstatus(hash)
       result
     else
       # Return all properties as absent.
       return properties.inject({}) do | prophash, property|
         prophash[property] = :absent
         prophash
       end
     end
   end
 
   # Take the results of a listing and set everything appropriately.
   def setstatus(hash)
     prophash = {}
     hash.each do |param, value|
       next if param == :name
       case self.class.attrtype(param)
       when :property
         # Only try to provide values for the properties we're managing
         if prop = self.property(param)
           prophash[prop] = value
         end
       else
         self[param] = value
       end
     end
     prophash
   end
 end