puppet 2.6.18 → 2.7.1

data/lib/puppet/type/zone.rb

@@ -284,6 +284,33 @@ Puppet::Type.newtype(:zone) do
     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."
@@ -382,12 +409,29 @@ Puppet::Type.newtype(:zone) do
   # 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

data/lib/puppet/type/zpool.rb

@@ -4,6 +4,7 @@ module Puppet
     class VDev < Property
 
       def flatten_and_sort(array)
+        array = [array] unless array.is_a? Array
         array.collect { |a| a.split(' ') }.flatten.sort
       end
 

data/lib/puppet/util.rb

@@ -1,11 +1,11 @@
 # A module to collect utility functions.
+
+require 'English'
 require 'puppet/util/monkey_patches'
-require 'puppet/external/lock'
-require 'puppet/util/execution_stub'
 require 'sync'
+require 'puppet/external/lock'
 require 'monitor'
-require 'tempfile'
-require 'pathname'
+require 'puppet/util/execution_stub'
 
 module Puppet
   # A command failed to execute.
@@ -30,6 +30,7 @@ module Util
     end
   end
 
+  
   def self.synchronize_on(x,type)
     sync_object,users = 0,1
     begin
@@ -47,24 +48,35 @@ module Util
   # Change the process to a different user
   def self.chuser
     if group = Puppet[:group]
-      begin
-        Puppet::Util::SUIDManager.change_group(group, true)
-      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)
+      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]
-      begin
-        Puppet::Util::SUIDManager.change_user(user, true)
-      rescue => detail
-        $stderr.puts "Could not change to user #{user}: #{detail}"
-        exit(74)
+      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
@@ -79,14 +91,18 @@ module Util
         if useself
 
           Puppet::Util::Log.create(
+
             :level => level,
             :source => self,
+
             :message => args
           )
         else
 
           Puppet::Util::Log.create(
+
             :level => level,
+
             :message => args
           )
         end
@@ -247,6 +263,9 @@ module Util
       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]
+
     if execution_stub = Puppet::Util::ExecutionStub.current_value
       return execution_stub.call(command, arguments)
     end
@@ -262,6 +281,7 @@ module Util
     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
@@ -287,7 +307,14 @@ module Util
           $stderr.reopen(error_file)
 
           3.upto(256){|fd| IO::new(fd).close rescue nil}
-          Puppet::Util::SUIDManager.change_privileges(arguments[:uid], arguments[:gid], true)
+          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)
@@ -408,82 +435,27 @@ module Util
 
   module_function :memory, :thinmark
 
-  # Replace a file, securely.  This takes a block, and passes it the file
-  # handle of a file open for writing.  Write the replacement content inside
-  # the block and it will safely replace the target file.
-  #
-  # This method will make no changes to the target file until the content is
-  # successfully written and the block returns without raising an error.
-  #
-  # As far as possible the state of the existing file, such as mode, is
-  # preserved.  This works hard to avoid loss of any metadata, but will result
-  # in an inode change for the file.
-  #
-  # Arguments: `filename`, `default_mode`
-  #
-  # The filename is the file we are going to replace.
-  #
-  # The default_mode is the mode to use when the target file doesn't already
-  # exist; if the file is present we copy the existing mode/owner/group values
-  # across.
-  def replace_file(file, default_mode, &block)
-    raise Puppet::DevError, "replace_file requires a block" unless block_given?
-
-    file     = Pathname(file)
-    tempfile = Tempfile.new(file.basename.to_s, file.dirname.to_s)
-
-    file_exists = file.exist?
-
-    # If the file exists, use its current mode/owner/group. If it doesn't, use
-    # the supplied mode, and default to current user/group.
-    if file_exists
-      stat = file.lstat
-
-      # We only care about the four lowest-order octets. Higher octets are
-      # filesystem-specific.
-      mode = stat.mode & 07777
-      uid = stat.uid
-      gid = stat.gid
-    else
-      mode = default_mode
-      uid = Process.euid
-      gid = Process.egid
+  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
-
-    # Set properties of the temporary file before we write the content, because
-    # Tempfile doesn't promise to be safe from reading by other people, just
-    # that it avoids races around creating the file.
-    tempfile.chmod(mode)
-    tempfile.chown(uid, gid)
-
-    # OK, now allow the caller to write the content of the file.
-    yield tempfile
-
-    # Now, make sure the data (which includes the mode) is safe on disk.
-    tempfile.flush
     begin
-      tempfile.fsync
-    rescue NotImplementedError
-      # fsync may not be implemented by Ruby on all platforms, but
-      # there is absolutely no recovery path if we detect that.  So, we just
-      # ignore the return code.
-      #
-      # However, don't be fooled: that is accepting that we are running in
-      # an unsafe fashion.  If you are porting to a new platform don't stub
-      # that out.
+      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
-
-    tempfile.close
-
-    File.rename(tempfile.path, file)
-
-    # Ideally, we would now fsync the directory as well, but Ruby doesn't
-    # have support for that, and it doesn't matter /that/ much...
-
-    # Return something true, and possibly useful.
-    file
   end
-  module_function :replace_file
+  module_function :secure_open
 end
 end
 

data/lib/puppet/util/autoload.rb

@@ -105,26 +105,28 @@ class Puppet::Util::Autoload
   # so that already-loaded files don't get reloaded unnecessarily.
   def loadall
     # Load every instance of everything we can find.
-    searchpath.each do |dir|
-      Dir.glob("#{dir}/*.rb").each do |file|
-        name = File.basename(file).sub(".rb", '').intern
-        next if loaded?(name)
-        begin
-          Kernel.require file
-          loaded(name, file)
-        rescue SystemExit,NoMemoryError
-          raise
-        rescue Exception => detail
-          puts detail.backtrace if Puppet[:trace]
-          raise Puppet::Error, "Could not autoload #{file}: #{detail}"
-        end
+    files_to_load.each do |file|
+      name = File.basename(file).chomp(".rb").intern
+      next if loaded?(name)
+      begin
+        Kernel.require file
+        loaded(name, file)
+      rescue SystemExit,NoMemoryError
+        raise
+      rescue Exception => detail
+        puts detail.backtrace if Puppet[:trace]
+        raise Puppet::Error, "Could not autoload #{file}: #{detail}"
       end
     end
   end
 
+  def files_to_load
+    searchpath.map { |dir| Dir.glob("#{dir}/*.rb") }.flatten
+  end
+
   # The list of directories to search through for loadable plugins.
   def searchpath(env=nil)
-    search_directories(env).collect { |d| File.join(d, @path) }.find_all { |d| FileTest.directory?(d) }
+    search_directories(env).uniq.collect { |d| File.join(d, @path) }.find_all { |d| FileTest.directory?(d) }
   end
 
   def module_directories(env=nil)

data/lib/puppet/util/classgen.rb

@@ -124,11 +124,23 @@ module Puppet::Util::ClassGen
     klass
   end
 
+  # const_defined? in Ruby 1.9 behaves differently in terms
+  # of which class hierarchy it polls for nested namespaces
+  #
+  # See http://redmine.ruby-lang.org/issues/show/1915
+  def is_constant_defined?(const)
+    if ::RUBY_VERSION =~ /1.9/
+      const_defined?(const, false)
+    else
+      const_defined?(const)
+    end
+  end
+
   # Handle the setting and/or removing of the associated constant.
   def handleclassconst(klass, name, options)
     const = genconst_string(name, options)
 
-    if const_defined?(const)
+    if is_constant_defined?(const)
       if options[:overwrite]
         Puppet.info "Redefining #{name} in #{self}"
         remove_const(const)

data/lib/puppet/util/command_line.rb

@@ -14,15 +14,16 @@ module Puppet
         'queue'      => 'puppetqd',
         'resource'   => 'ralsh',
         'kick'       => 'puppetrun',
-        'master'     => 'puppetmasterd'
+        'master'     => 'puppetmasterd',
+        'device'     => 'puppetdevice'
       )
 
-      def initialize( zero = $0, argv = ARGV, stdin = STDIN )
+      def initialize(zero = $0, argv = ARGV, stdin = STDIN)
         @zero  = zero
         @argv  = argv.dup
         @stdin = stdin
 
-        @subcommand_name, @args = subcommand_and_args( @zero, @argv, @stdin )
+        @subcommand_name, @args = subcommand_and_args(@zero, @argv, @stdin)
         Puppet::Plugins.on_commandline_initialization(:command_line_object => self)
       end
 
@@ -33,19 +34,20 @@ module Puppet
         File.join('puppet', 'application')
       end
 
-      def available_subcommands
-        absolute_appdirs = $LOAD_PATH.collect do |x| 
+      def self.available_subcommands
+        absolute_appdirs = $LOAD_PATH.collect do |x|
           File.join(x,'puppet','application')
         end.select{ |x| File.directory?(x) }
         absolute_appdirs.inject([]) do |commands, dir|
           commands + Dir[File.join(dir, '*.rb')].map{|fn| File.basename(fn, '.rb')}
         end.uniq
       end
-
-      def usage_message
-        usage = "Usage: puppet command <space separated arguments>"
-        available = "Available commands are: #{available_subcommands.sort.join(', ')}"
-        [usage, available].join("\n")
+      # available_subcommands was previously an instance method, not a class
+      # method, and we have an unknown number of user-implemented applications
+      # that depend on that behaviour.  Forwarding allows us to preserve a
+      # backward compatible API. --daniel 2011-04-11
+      def available_subcommands
+        self.class.available_subcommands
       end
 
       def require_application(application)
@@ -53,15 +55,26 @@ module Puppet
       end
 
       def execute
-        if subcommand_name.nil?
-          puts usage_message
-        elsif available_subcommands.include?(subcommand_name) #subcommand
+        if subcommand_name and available_subcommands.include?(subcommand_name) then
           require_application subcommand_name
           app = Puppet::Application.find(subcommand_name).new(self)
           Puppet::Plugins.on_application_initialization(:appliation_object => self)
+
+          # See the note in 'warn_later' down below. --daniel 2011-06-01
+          if $delayed_deprecation_warning_for_p_u_cl.is_a? String then
+            Puppet.deprecation_warning($delayed_deprecation_warning_for_p_u_cl)
+            $delayed_deprecation_warning_for_p_u_cl = true
+          end
+
           app.run
+        elsif execute_external_subcommand then
+          # Logically, we shouldn't get here, but we do, so whatever.  We just
+          # return to the caller.  How strange we are. --daniel 2011-04-11
         else
-          abort "Error: Unknown command #{subcommand_name}.\n#{usage_message}" unless execute_external_subcommand
+          unless subcommand_name.nil? then
+            puts "Error: Unknown Puppet subcommand '#{subcommand_name}'"
+          end
+          puts "See 'puppet help' for help on available puppet subcommands"
         end
       end
 
@@ -69,10 +82,10 @@ module Puppet
         external_command = "puppet-#{subcommand_name}"
 
         require 'puppet/util'
-        path_to_subcommand = Puppet::Util.which( external_command )
+        path_to_subcommand = Puppet::Util.which(external_command)
         return false unless path_to_subcommand
 
-        system( path_to_subcommand, *args )
+        system(path_to_subcommand, *args)
         true
       end
 
@@ -82,21 +95,95 @@ module Puppet
 
       private
 
-      def subcommand_and_args( zero, argv, stdin )
+      def subcommand_and_args(zero, argv, stdin)
         zero = File.basename(zero, '.rb')
 
         if zero == 'puppet'
           case argv.first
-          when nil;              [ stdin.tty? ? nil : "apply", argv] # ttys get usage info
-          when "--help", "-h";         [nil,     argv] # help should give you usage, not the help for `puppet apply`
-          when /^-|\.pp$|\.rb$/; ["apply", argv]
-          else [ argv.first, argv[1..-1] ]
+          when nil then
+            if stdin.tty? then
+              [nil, argv]       # ttys get usage info
+            else
+              # Killed for 2.7.0 --daniel 2011-06-01
+              warn_later <<EOM
+Implicit invocation of 'puppet apply' by redirection into 'puppet' is deprecated,
+and will be removed in the 2.8 series. Please invoke 'puppet apply' directly
+in the future.
+EOM
+              ["apply", argv]
+            end
+          when "--help", "-h" then
+            # help should give you usage, not the help for `puppet apply`
+            [nil, argv]
+          when /^-|\.pp$|\.rb$/ then
+            # Killed for 2.7.0 --daniel 2011-06-01
+            warn_later <<EOM
+Implicit invocation of 'puppet apply' by passing files (or flags) directly
+to 'puppet' is deprecated, and will be removed in the 2.8 series.  Please
+invoke 'puppet apply' directly in the future.
+EOM
+            ["apply", argv]
+          else
+            [argv.first, argv[1..-1]]
           end
         else
-          [ zero, argv ]
+          [zero, argv]
         end
       end
 
+      # So, this is more than a little bit of a horror.  You see, the process
+      # of bootstrapping Puppet is ... complex.  This file, like many of our
+      # early initialization files, has an incestuous relationship between the
+      # order of files loaded, code executed at load time, and code executed
+      # in other files at runtime.
+      #
+      # When we construct this object we have not yet actually loaded the
+      # global puppet object, so we can't use any methods in it.  That
+      # includes all the logging stuff, which is used by the deprecation
+      # warning subsystem.
+      #
+      # On the other hand, we can't just load the logging system, because that
+      # depends on the top level Puppet module being bootstrapped.  It doesn't
+      # actually load the stuff it uses, though, for hysterical raisins.
+      #
+      # Finally, we can't actually just load the top level Puppet module.
+      # This one is precious: it turns out that some of the code loaded in the
+      # top level Puppet module has a dependency on the run mode values.
+      #
+      # Run mode is set correctly *only* when the application is loaded, and
+      # if it is wrong when the top level code is brought in we end up with
+      # the wrong settings scattered through some of the defaults.
+      #
+      # Which means that we have a dependency cycle that runs:
+      # 1. The binary creates an instance of P::U::CL.
+      # 2. That identifies the application to load.
+      # 3. It does, then instantiates the application.
+      #    4. That sets the run-mode.
+      #    5. That then loads the top level Puppet module.
+      # 6. Finally, we get to where we can use the top level stuff
+      #
+      # So, essentially, we see a dependency between runtime code in this
+      # file, run-time code in the application, and load-time code in the top
+      # level module.
+      #
+      # Which leads me to our current horrible hack: we stash away the message
+      # we wanted to log about deprecation, then send it to our logging system
+      # once we have done enough bootstrapping that it will, y'know, actually
+      # work.
+      #
+      # I would have liked to fix this, but that is going to be a whole pile
+      # of work digging through and decrufting all the global state from the
+      # local state, and working out what depends on what else in the product.
+      #
+      # Oh, and we use a global because we have *two* instances of a P::U::CL
+      # object during the startup sequence.  I don't know why.
+      #
+      # Maybe, one day, when I am not behind a deadline to ship code.
+      # --daniel 2011-06-01
+      def warn_later(text)
+        return if $delayed_deprecation_warning_for_p_u_cl
+        $delayed_deprecation_warning_for_p_u_cl = text
+      end
     end
   end
 end