puppet 3.8.7 → 4.0.0

data/lib/puppet/util/rdoc/parser/puppet_parser_core.rb

@@ -8,7 +8,7 @@ module RDoc::PuppetParserCore
       attr_accessor :input_file_name, :top_level
 
       # parser registration into RDoc
-      parse_files_matching(/\.(rb|pp)$/)
+      parse_files_matching(/\.(rb)$/)
     end
   end
 
@@ -25,18 +25,6 @@ module RDoc::PuppetParserCore
   # main entry point
   def scan
     environment = Puppet.lookup(:current_environment)
-    known_resource_types = environment.known_resource_types
-    unless known_resource_types.watching_file?(@input_file_name)
-      Puppet.info "rdoc: scanning #{@input_file_name}"
-      if @input_file_name =~ /\.pp$/
-        @parser = Puppet::Parser::Parser.new(environment)
-        @parser.file = @input_file_name
-        @parser.parse.instantiate('').each do |type|
-          known_resource_types.add type
-        end
-      end
-    end
-
     scan_top_level(@top_level, environment)
     @top_level
   end
@@ -64,10 +52,10 @@ module RDoc::PuppetParserCore
     names = name.split('::')
 
     final_name = names.pop
-    names.each do |name|
+    names.each do |n|
       prev_container = container
-      container = find_object_named(container, name)
-      container ||= prev_container.add_class(RDoc::PuppetClass, name, nil)
+      container = find_object_named(container, n)
+      container ||= prev_container.add_class(RDoc::PuppetClass, n, nil)
     end
     [container, final_name]
   end
@@ -80,7 +68,7 @@ module RDoc::PuppetParserCore
     # find a module
     fullpath = File.expand_path(path)
     Puppet.debug "rdoc: testing #{fullpath}"
-    if fullpath =~ /(.*)\/([^\/]+)\/(?:manifests|plugins|lib)\/.+\.(pp|rb)$/
+    if fullpath =~ /(.*)\/([^\/]+)\/(?:manifests|plugins|lib)\/.+\.(rb)$/
       modpath = $1
       name = $2
       Puppet.debug "rdoc: module #{name} into #{modpath} ?"
@@ -91,7 +79,7 @@ module RDoc::PuppetParserCore
         end
       end
     end
-    if fullpath =~ /\.(pp|rb)$/
+    if fullpath =~ /\.(rb)$/
       # there can be paths we don't want to scan under modules
       # imagine a ruby or manifest that would be distributed as part as a module
       # but we don't want those to be hosted under <site>
@@ -125,6 +113,7 @@ module RDoc::PuppetParserCore
     if name.nil?
       # skip .pp files that are not in manifests directories as we can't guarantee they're part
       # of a module or the global configuration.
+      # PUP-3638, keeping this while it should have no effect since no .pp files are now processed
       container.document_self = false
       return
     end
@@ -139,219 +128,11 @@ module RDoc::PuppetParserCore
     mod.record_location(@top_level)
     mod.add_comment(comment, @input_file_name)
 
-    if @input_file_name =~ /\.pp$/
-      parse_elements(mod, environment.known_resource_types)
-    elsif @input_file_name =~ /\.rb$/
+    if @input_file_name =~ /\.rb$/
       parse_plugins(mod)
     end
   end
 
-  # create documentation for include statements we can find in +code+
-  # and associate it with +container+
-  def scan_for_include_or_require(container, code)
-    code = [code] unless code.is_a?(Array)
-    code.each do |stmt|
-      scan_for_include_or_require(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::BlockExpression)
-
-      if stmt.is_a?(Puppet::Parser::AST::Function) and ['include','require'].include?(stmt.name)
-        stmt.arguments.each do |included|
-          Puppet.debug "found #{stmt.name}: #{included}"
-          container.send("add_#{stmt.name}", RDoc::Include.new(included.to_s, stmt.doc))
-        end
-      end
-    end
-  end
-
-  # create documentation for realize statements we can find in +code+
-  # and associate it with +container+
-  def scan_for_realize(container, code)
-    code = [code] unless code.is_a?(Array)
-    code.each do |stmt|
-      scan_for_realize(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::BlockExpression)
-
-      if stmt.is_a?(Puppet::Parser::AST::Function) and stmt.name == 'realize'
-        stmt.arguments.each do |realized|
-          Puppet.debug "found #{stmt.name}: #{realized}"
-          container.add_realize( RDoc::Include.new(realized.to_s, stmt.doc))
-        end
-      end
-    end
-  end
-
-  # create documentation for global variables assignements we can find in +code+
-  # and associate it with +container+
-  def scan_for_vardef(container, code)
-    code = [code] unless code.is_a?(Array)
-    code.each do |stmt|
-      scan_for_vardef(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::BlockExpression)
-
-      if stmt.is_a?(Puppet::Parser::AST::VarDef)
-        Puppet.debug "rdoc: found constant: #{stmt.name} = #{stmt.value}"
-        container.add_constant(RDoc::Constant.new(stmt.name.to_s, stmt.value.to_s, stmt.doc))
-      end
-    end
-  end
-
-  # create documentation for resources we can find in +code+
-  # and associate it with +container+
-  def scan_for_resource(container, code)
-    code = [code] unless code.is_a?(Array)
-    code.each do |stmt|
-      scan_for_resource(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::BlockExpression)
-
-      if stmt.is_a?(Puppet::Parser::AST::Resource) and !stmt.type.nil?
-        begin
-          type = stmt.type.split("::").collect { |s| s.capitalize }.join("::")
-          stmt.instances.each do |inst|
-            title = inst.title.is_a?(Puppet::Parser::AST::ASTArray) ? inst.title.to_s.gsub(/\[(.*)\]/,'\1') : inst.title.to_s
-            Puppet.debug "rdoc: found resource: #{type}[#{title}]"
-
-            param = []
-            inst.parameters.children.each do |p|
-              res = {}
-              res["name"] = p.param
-              res["value"] = "#{p.value.to_s}" unless p.value.nil?
-
-              param << res
-            end
-
-            container.add_resource(RDoc::PuppetResource.new(type, title, stmt.doc, param))
-          end
-        rescue => detail
-          raise Puppet::ParseError, "impossible to parse resource in #{stmt.file} at line #{stmt.line}: #{detail}", detail.backtrace
-        end
-      end
-    end
-  end
-
-  # create documentation for a class named +name+
-  def document_class(name, klass, container)
-    Puppet.debug "rdoc: found new class #{name}"
-    container, name = get_class_or_module(container, name)
-
-    superclass = klass.parent
-    superclass = "" if superclass.nil? or superclass.empty?
-
-    comment = klass.doc
-    look_for_directives_in(container, comment) unless comment.empty?
-    cls = container.add_class(RDoc::PuppetClass, name, superclass)
-    # it is possible we already encountered this class, while parsing some namespaces
-    # from other classes of other files. But at that time we couldn't know this class superclass
-    # so, now we know it and force it.
-    cls.superclass = superclass
-    cls.record_location(@top_level)
-
-    # scan class code for include
-    code = klass.code.children if klass.code.is_a?(Puppet::Parser::AST::BlockExpression)
-    code ||= klass.code
-    unless code.nil?
-      scan_for_include_or_require(cls, code)
-      scan_for_realize(cls, code)
-      scan_for_resource(cls, code) if Puppet.settings[:document_all]
-    end
-
-    cls.add_comment(comment, klass.file)
-  rescue => detail
-    raise Puppet::ParseError, "impossible to parse class '#{name}' in #{klass.file} at line #{klass.line}: #{detail}", detail.backtrace
-  end
-
-  # create documentation for a node
-  def document_node(name, node, container)
-    Puppet.debug "rdoc: found new node #{name}"
-    superclass = node.parent
-    superclass = "" if superclass.nil? or superclass.empty?
-
-    comment = node.doc
-    look_for_directives_in(container, comment) unless comment.empty?
-    n = container.add_node(name, superclass)
-    n.record_location(@top_level)
-
-    code = node.code.children if node.code.is_a?(Puppet::Parser::AST::BlockExpression)
-    code ||= node.code
-    unless code.nil?
-      scan_for_include_or_require(n, code)
-      scan_for_realize(n, code)
-      scan_for_vardef(n, code)
-      scan_for_resource(n, code) if Puppet.settings[:document_all]
-    end
-
-    n.add_comment(comment, node.file)
-  rescue => detail
-    raise Puppet::ParseError, "impossible to parse node '#{name}' in #{node.file} at line #{node.line}: #{detail}", detail.backtrace
-  end
-
-  # create documentation for a define
-  def document_define(name, define, container)
-    Puppet.debug "rdoc: found new definition #{name}"
-    # find superclas if any
-
-    # find the parent
-    # split define name by :: to find the complete module hierarchy
-    container, name = get_class_or_module(container,name)
-
-    # build up declaration
-    declaration = ""
-    define.arguments.each do |arg,value|
-      declaration << "\$#{arg}"
-      unless value.nil?
-        declaration << " => "
-        case value
-        when Puppet::Parser::AST::Leaf
-          declaration << "'#{value.value}'"
-        when Puppet::Parser::AST::BlockExpression
-          declaration << "[#{value.children.collect { |v| "'#{v}'" }.join(", ")}]"
-        else
-          declaration << "#{value.to_s}"
-        end
-      end
-      declaration << ", "
-    end
-    declaration.chop!.chop! if declaration.size > 1
-
-    # register method into the container
-    meth =  RDoc::AnyMethod.new(declaration, name)
-    meth.comment = define.doc
-    container.add_method(meth)
-    look_for_directives_in(container, meth.comment) unless meth.comment.empty?
-    meth.params = "( #{declaration} )"
-    meth.visibility = :public
-    meth.document_self = true
-    meth.singleton = false
-  rescue => detail
-    raise Puppet::ParseError, "impossible to parse definition '#{name}' in #{define.file} at line #{define.line}: #{detail}", detail.backtrace
-  end
-
-  # Traverse the AST tree and produce code-objects node
-  # that contains the documentation
-  def parse_elements(container, known_resource_types)
-    Puppet.debug "rdoc: scanning manifest"
-
-    known_resource_types.hostclasses.values.sort { |a,b| a.name <=> b.name }.each do |klass|
-      name = klass.name
-      if klass.file == @input_file_name
-        unless name.empty?
-          document_class(name,klass,container)
-        else # on main class document vardefs
-          code = klass.code.children if klass.code.is_a?(Puppet::Parser::AST::BlockExpression)
-          code ||= klass.code
-          scan_for_vardef(container, code) unless code.nil?
-        end
-      end
-    end
-
-    known_resource_types.definitions.each do |name, define|
-      if define.file == @input_file_name
-        document_define(name,define,container)
-      end
-    end
-
-    known_resource_types.nodes.each do |name, node|
-      if node.file == @input_file_name
-        document_node(name.to_s,node,container)
-      end
-    end
-  end
-
   # create documentation for plugins
   def parse_plugins(container)
     Puppet.debug "rdoc: scanning plugin or fact"

data/lib/puppet/util/rdoc/parser.rb

@@ -3,20 +3,10 @@
 # our current structures. It also parses ruby files that could contain
 # either custom facts or puppet plugins (functions, types...)
 
-# rdoc mandatory includes
+# rdoc2 includes
 require "rdoc/code_objects"
 require "puppet/util/rdoc/code_objects"
-
-begin
-  # Rdoc 1 imports
-  require "rdoc/tokenstream"
-  require "rdoc/markup/simple_markup/preprocess"
-  require "rdoc/parsers/parserfactory"
-  require "puppet/util/rdoc/parser/puppet_parser_rdoc1.rb"
-rescue LoadError
-  # Current version imports
-  require "rdoc/token_stream"
-  require "rdoc/markup/pre_process"
-  require "rdoc/parser"
-  require "puppet/util/rdoc/parser/puppet_parser_rdoc2.rb"
-end
+require "rdoc/token_stream"
+require "rdoc/markup/pre_process"
+require "rdoc/parser"
+require "puppet/util/rdoc/parser/puppet_parser_rdoc2.rb"

data/lib/puppet/util/rdoc.rb

@@ -5,7 +5,6 @@ module Puppet::Util::RDoc
   # launch a rdoc documenation process
   # with the files/dir passed in +files+
   def rdoc(outputdir, files, charset = nil)
-    Puppet[:ignoreimport] = true
 
     # then rdoc
     require 'rdoc/rdoc'
@@ -16,14 +15,6 @@ module Puppet::Util::RDoc
 
     r = RDoc::RDoc.new
 
-    if Puppet.features.rdoc1?
-      RDoc::RDoc::GENERATORS["puppet"] = RDoc::RDoc::Generator.new(
-          "puppet/util/rdoc/generators/puppet_generator.rb",
-          :PuppetGenerator,
-          "puppet"
-        )
-    end
-
     # specify our own format & where to output
     options = [ "--fmt", "puppet",
                 "--quiet",
@@ -33,9 +24,7 @@ module Puppet::Util::RDoc
                 "--exclude", "/modules/[^/]*/templates/.*$",
                 "--op", outputdir ]
 
-    if !Puppet.features.rdoc1? || ::Options::OptionList.options.any? { |o| o[0] == "--force-update" } # Options is a root object in the rdoc1 namespace...
-      options << "--force-update"
-    end
+    options << "--force-update"
     options += [ "--charset", charset] if charset
     # Rdoc root default is Dir.pwd, but the win32-dir gem monkey patchs Dir.pwd
     # replacing Ruby's normal / with \.  When RDoc generates relative paths it
@@ -52,45 +41,20 @@ module Puppet::Util::RDoc
 
   # launch an output to console manifest doc
   def manifestdoc(files)
-    Puppet[:ignoreimport] = true
-    files.select { |f| FileTest.file?(f) }.each do |f|
-      parser = Puppet::Parser::Parser.new(Puppet.lookup(:current_environment))
-      parser.file = f
-      ast = parser.parse
-      output(f, ast)
-    end
+    raise "RDOC SUPPORT FOR MANIFEST HAS BEEN REMOVED - See PUP-3638"
   end
 
-  # Ouputs to the console the documentation
+  # Outputs to the console the documentation
   # of a manifest
   def output(file, ast)
-    astobj = []
-    ast.instantiate('').each do |resource_type|
-      astobj << resource_type if resource_type.file == file
-    end
-
-    astobj.sort! {|a,b| a.line <=> b.line }.each do |k|
-      output_astnode_doc(k)
-    end
+    raise "RDOC SUPPORT FOR MANIFEST HAS BEEN REMOVED - See PUP-3638"
   end
 
   def output_astnode_doc(ast)
-    puts ast.doc if !ast.doc.nil? and !ast.doc.empty?
-    if Puppet.settings[:document_all]
-      # scan each underlying resources to produce documentation
-      code = ast.code.children if ast.code.is_a?(Puppet::Parser::AST::ASTArray)
-      code ||= ast.code
-      output_resource_doc(code) unless code.nil?
-    end
+    raise "RDOC SUPPORT FOR MANIFEST HAS BEEN REMOVED - See PUP-3638"
   end
 
   def output_resource_doc(code)
-    code.sort { |a,b| a.line <=> b.line }.each do |stmt|
-      output_resource_doc(stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
-
-      if stmt.is_a?(Puppet::Parser::AST::Resource)
-        puts stmt.doc if !stmt.doc.nil? and !stmt.doc.empty?
-      end
-    end
+    raise "RDOC SUPPORT FOR MANIFEST HAS BEEN REMOVED - See PUP-3638"
   end
 end

data/lib/puppet/util/retry_action.rb

@@ -0,0 +1,46 @@
+module Puppet::Util::RetryAction
+  class RetryException < Exception; end
+  class RetryException::NoBlockGiven < RetryException; end
+  class RetryException::NoRetriesGiven < RetryException;end
+  class RetryException::RetriesExceeded < RetryException; end
+
+  # Execute the supplied block retrying with exponential backoff.
+  #
+  # @param [Hash] options the retry options
+  # @option options [FixNum] :retries Maximum number of times to retry.
+  # @option options [Array<Exception>] :retry_exceptions ([StandardError]) Optional array of exceptions that are allowed to be retried.
+  # @yield The block to be executed.
+  def self.retry_action(options = {})
+    # Retry actions for a specified amount of time. This method will allow the final
+    # retry to complete even if that extends beyond the timeout period.
+    if !block_given?
+      raise RetryException::NoBlockGiven
+    end
+
+    retries = options[:retries]
+    if retries.nil?
+      raise RetryException::NoRetriesGiven
+    end
+
+    retry_exceptions = options[:retry_exceptions] || [StandardError]
+    failures = 0
+    begin
+      yield
+    rescue *retry_exceptions => e
+      if failures >= retries
+        raise RetryException::RetriesExceeded, "#{retries} exceeded", e.backtrace
+      end
+
+      Puppet.info("Caught exception #{e.class}:#{e} retrying")
+
+      failures += 1
+
+      # Increase the amount of time that we sleep after every
+      # failed retry attempt.
+      sleep (((2 ** failures) -1) * 0.1)
+
+      retry
+
+    end
+  end
+end

data/lib/puppet/util/run_mode.rb

@@ -1,4 +1,5 @@
 require 'etc'
+require 'fileutils'
 
 module Puppet
   module Util
@@ -31,11 +32,11 @@ module Puppet
       end
 
       def run_dir
-        "$vardir/run"
+        RunMode[name].run_dir
       end
 
       def log_dir
-        "$vardir/log"
+        RunMode[name].log_dir
       end
 
       private
@@ -49,33 +50,73 @@ module Puppet
       # @todo this code duplicates {Puppet::Settings#which\_configuration\_file}
       #   as described in {http://projects.puppetlabs.com/issues/16637 #16637}
       def which_dir( system, user )
-        File.expand_path(if Puppet.features.root? then system else user end)
+        if Puppet.features.root?
+          File.expand_path(system)
+        else
+          # Starting with puppet 4 and AIO packaging, AIO introduced new paths for
+          # both root and non-root users. The paths used by the root user are created
+          # by packaging, so no special action is required in the code.
+          #
+          # However, for non-root users, these new paths introduce deep paths (see below
+          # in the two RunMode sub-classes). Since puppet doesn't create parent directories
+          # for directories in the settings catalog, we take this opportunity to create
+          # those parent directories. (Note that pre-AIO this code would have had to do the
+          # same thing, except that everything was under ~/.puppet which was confdir so was
+          # created.)
+          expanded_user = File.expand_path(user)
+          FileUtils.mkdir_p(File.dirname(expanded_user)) if File.exists?(File.expand_path('~'))
+          expanded_user
+        end
       end
     end
 
     class UnixRunMode < RunMode
       def conf_dir
-        which_dir("/etc/puppet", "~/.puppet")
+        which_dir("/etc/puppetlabs/puppet", "~/.puppetlabs/etc/puppet")
+      end
+
+      def code_dir
+        which_dir("/etc/puppetlabs/code", "~/.puppetlabs/etc/code")
       end
 
       def var_dir
-        which_dir("/var/lib/puppet", "~/.puppet/var")
+        which_dir("/opt/puppetlabs/puppet/cache", "~/.puppetlabs/opt/puppet/cache")
+      end
+
+      def run_dir
+        which_dir("/var/run/puppetlabs", "~/.puppetlabs/var/run")
+      end
+
+      def log_dir
+        which_dir("/var/log/puppetlabs/puppet", "~/.puppetlabs/var/log")
       end
     end
 
     class WindowsRunMode < RunMode
       def conf_dir
-        which_dir(File.join(windows_common_base("etc")), "~/.puppet")
+        which_dir(File.join(windows_common_base("puppet/etc")), "~/.puppetlabs/etc/puppet")
+      end
+
+      def code_dir
+        which_dir(File.join(windows_common_base("code")), "~/.puppetlabs/etc/code")
       end
 
       def var_dir
-        which_dir(File.join(windows_common_base("var")), "~/.puppet/var")
+        which_dir(File.join(windows_common_base("puppet/cache")), "~/.puppetlabs/opt/puppet/cache")
+      end
+
+      def run_dir
+        which_dir(File.join(windows_common_base("puppet/var/run")), "~/.puppetlabs/var/run")
+      end
+
+      def log_dir
+        which_dir(File.join(windows_common_base("puppet/var/log")), "~/.puppetlabs/var/log")
       end
 
     private
 
       def windows_common_base(*extra)
-        [Dir::COMMON_APPDATA, "PuppetLabs", "puppet"] + extra
+        [Dir::COMMON_APPDATA, "PuppetLabs"] + extra
       end
     end
   end

data/lib/puppet/util/selinux.rb

@@ -62,7 +62,7 @@ module Puppet::Util::SELinux
     if context.nil? or context == "unlabeled"
       return nil
     end
-    unless context =~ /^([a-z0-9_]+):([a-z0-9_]+):([a-zA-Z0-9_]+)(?::([a-zA-Z0-9:,._-]+))?/
+    unless context =~ /^([^\s:]+):([^\s:]+):([^\s:]+)(?::([\sa-zA-Z0-9:,._-]+))?$/
       raise Puppet::Error, "Invalid context to parse: #{context}"
     end
     ret = {
@@ -105,7 +105,7 @@ module Puppet::Util::SELinux
         when :selrange
           context[3] = value
         else
-          raise ArguementError, "set_selinux_context component must be one of :seluser, :selrole, :seltype, or :selrange"
+          raise ArgumentError, "set_selinux_context component must be one of :seluser, :selrole, :seltype, or :selrange"
       end
       context = context.join(':')
     else

data/lib/puppet/util/ssl.rb

@@ -4,16 +4,12 @@
 #
 # @api private
 module Puppet::Util::SSL
-  NO_NAME = OpenSSL::X509::Name.new
 
-  DN_PARSERS = [
-    OpenSSL::X509::Name.method(:parse_rfc2253),
-    OpenSSL::X509::Name.method(:parse_openssl),
-    lambda { |dn| NO_NAME }
-  ]
+  @@dn_parsers = nil
+  @@no_name = nil
 
   # Given a DN string, parse it into an OpenSSL certificate subject.  This
-  # method will flexibly handle both OpenSSl and RFC2253 formats, as given by
+  # method will flexibly handle both OpenSSL and RFC2253 formats, as given by
   # nginx and Apache, respectively.
   #
   # @param [String] dn the x.509 Distinguished Name (DN) string.
@@ -21,19 +17,23 @@ module Puppet::Util::SSL
   # @return [OpenSSL::X509::Name] the certificate subject
   def self.subject_from_dn(dn)
     if is_possibly_valid_dn?(dn)
-      DN_PARSERS.each do |parser|
+      parsers = @@dn_parsers ||= [
+            OpenSSL::X509::Name.method(:parse_rfc2253),
+            OpenSSL::X509::Name.method(:parse_openssl)
+        ]
+      parsers.each do |parser|
         begin
           return parser.call(dn)
         rescue OpenSSL::X509::NameError
         end
       end
-    else
-      NO_NAME
     end
+
+    @@no_name ||= OpenSSL::X509::Name.new
   end
 
   ##
-  # cn_from_subject extracts the CN from the given OpenSSL certtificate
+  # cn_from_subject extracts the CN from the given OpenSSL certificate
   # subject.
   #
   # @api private

data/lib/puppet/util/suidmanager.rb

@@ -101,6 +101,8 @@ module Puppet::Util::SUIDManager
     gid = convert_xid(:gid, group)
     raise Puppet::Error, "No such group #{group}" unless gid
 
+    return if Process.egid == gid
+
     if permanently
       Process::GID.change_privilege(gid)
     else
@@ -115,6 +117,8 @@ module Puppet::Util::SUIDManager
     uid = convert_xid(:uid, user)
     raise Puppet::Error, "No such user #{user}" unless uid
 
+    return if Process.euid == uid
+
     if permanently
       # If changing uid, we must be root. So initgroups first here.
       initgroups(uid)
@@ -157,35 +161,4 @@ module Puppet::Util::SUIDManager
   end
 
   module_function :initgroups
-
-  # Run a command and capture the output
-  # Parameters:
-  # [command] the command to execute
-  # [new_uid] (optional) a userid to run the command as
-  # [new_gid] (optional) a groupid to run the command as
-  # [options] (optional, defaults to {}) a hash of option key/value pairs; currently supported:
-  #   :override_locale (defaults to true) a flag indicating whether or puppet should temporarily override the
-  #     system locale for the duration of the command.  If true, the locale will be set to 'C' to ensure consistent
-  #     output / formatting from the command, which makes it much easier to parse the output.  If false, the system
-  #     locale will be respected.
-  #   :custom_environment (default {}) -- a hash of key/value pairs to set as environment variables for the duration
-  #     of the command
-  def run_and_capture(command, new_uid=nil, new_gid=nil, options = {})
-    Puppet.deprecation_warning("Puppet::Util::SUIDManager.run_and_capture is deprecated; please use Puppet::Util::Execution.execute instead.")
-    # specifying these here rather than in the method signature to allow callers to pass in a partial
-    # set of overrides without affecting the default values for options that they don't pass in
-    default_options = {
-        :override_locale => true,
-        :custom_environment => {},
-    }
-
-    options = default_options.merge(options)
-
-    output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
-                                  :uid => new_uid, :gid => new_gid,
-                                  :override_locale => options[:override_locale],
-                                  :custom_environment => options[:custom_environment])
-    [output, $CHILD_STATUS.dup]
-  end
-  module_function :run_and_capture
 end

data/lib/puppet/util/tag_set.rb

@@ -16,11 +16,6 @@ class Puppet::Util::TagSet < Set
     self.new(data)
   end
 
-  def self.from_pson(data)
-    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
-    self.from_data_hash(data)
-  end
-
   def to_data_hash
     to_a
   end
@@ -29,12 +24,6 @@ class Puppet::Util::TagSet < Set
     to_data_hash.to_pson
   end
 
-  # this makes puppet serialize it as an array for backwards
-  # compatibility
-  def to_zaml(z)
-    to_data_hash.to_zaml(z)
-  end
-
   def join(*args)
     to_a.join(*args)
   end