puppet 2.7.21 → 2.7.22

data/ext/packaging/tasks/ship.rake

@@ -67,9 +67,9 @@ namespace :pl do
       rsync_to('pkg/apple/*.dmg', @build.yum_host, @build.dmg_path)
     end if @build.build_dmg
 
-    desc "ship tarball and signature to #{@build.yum_host}"
+    desc "ship tarball and signature to #{@build.tar_host}"
     task :ship_tar => 'pl:fetch' do
-      rsync_to("pkg/#{@build.project}-#{@build.version}.tar.gz*", @build.yum_host, @build.tarball_path)
+      rsync_to("pkg/#{@build.project}-#{@build.version}.tar.gz*", @build.tar_host, @build.tarball_path)
     end
 
     desc "UBER ship: ship all the things in pkg"
@@ -101,6 +101,18 @@ namespace :pl do
       remote_ssh_cmd(@build.distribution_server, "mkdir -p #{artifact_dir}")
       rsync_to("pkg/", @build.distribution_server, "#{artifact_dir}/ --exclude repo_configs")
     end
+
+    desc "Ship generated repository configs to the distribution server"
+    task :ship_repo_configs do
+      if empty_dir?("pkg/repo_configs")
+        warn "No repo configs have been generated! Try pl:deb_repo_configs or pl:rpm_repo_configs"
+        exit 1
+      end
+      invoke_task("pl:fetch")
+      repo_dir = "#{@build.jenkins_repo_path}/#{@build.project}/#{@build.ref}/repo_configs"
+      remote_ssh_cmd(@build.distribution_server, "mkdir -p #{repo_dir}")
+      rsync_to("pkg/repo_configs/", @build.distribution_server, repo_dir)
+    end
   end
 end
 

data/ext/packaging/tasks/sign.rake

@@ -98,9 +98,15 @@ namespace :pl do
         warn "There were files found in pkg/. Maybe you wanted to build/retrieve something first?"
         exit 1
       end
-      sign_tasks   = ["pl:sign_tar", "pl:sign_rpms", "pl:sign_deb_changes"]
-      remote_repo  = remote_bootstrap(@build.distribution_server, 'HEAD')
-      build_params = remote_buildparams(@build.distribution_server, @build)
+      # Because rpms and debs are laid out differently in PE under pkg/ they
+      # have a different sign task to address this. Rather than create a whole
+      # extra :jenkins task for signing PE, we determine which sign task to use
+      # based on if we're building PE
+      rpm_sign_task = @build.build_pe ? "pe:sign_rpms" : "pl:sign_rpms"
+      deb_sign_task = @build.build_pe ? "pe:sign_deb_changes" : "pl:sign_deb_changes"
+      sign_tasks    = ["pl:sign_tar", rpm_sign_task, deb_sign_task]
+      remote_repo   = remote_bootstrap(@build.distribution_server, 'HEAD')
+      build_params  = remote_buildparams(@build.distribution_server, @build)
       rsync_to('pkg', @build.distribution_server, remote_repo)
       remote_ssh_cmd(@build.distribution_server, "cd #{remote_repo} ; rake #{sign_tasks.join(' ')} PARAMS_FILE=#{build_params}")
       rsync_from("#{remote_repo}/pkg/", @build.distribution_server, "pkg/")

data/ext/packaging/tasks/tar.rake

@@ -1,6 +1,11 @@
 namespace :package do
   desc "Create a source tar archive"
   task :tar => [ :clean ] do
+
+    if @build.pre_tar_task
+      invoke_task(@build.pre_tar_task)
+    end
+
     Rake::Task["package:doc"].invoke if @build.build_doc
     tar = ENV['TAR'] || 'tar'
     workdir = "pkg/#{@build.project}-#{@build.version}"

data/ext/packaging/tasks/vendor_gems.rake

@@ -0,0 +1,110 @@
+# This is an optional pre-tar-task, so we only want to present it if we're
+# using it
+if @build.pre_tar_task == "package:vendor_gems"
+  namespace :package do
+    desc "vendor gems required by project"
+    task :vendor_gems do
+      check_tool("bundle")
+      require 'bundler'
+
+      class UI
+        LEVELS = %w(silent error warn confirm info debug)
+
+        def warn(message, newline = nil)
+          puts message
+        end
+
+        def debug(message, newline = nil)
+          puts message
+        end
+
+        def trace(message, newline = nil)
+          puts message
+        end
+
+        def error(message, newline = nil)
+          puts message
+        end
+
+        def info(message, newline = nil)
+          puts message
+        end
+
+        def confirm(message, newline = nil)
+        end
+
+        def debug?
+          true
+        end
+
+        def ask(message)
+        end
+
+        def quiet?
+          false
+        end
+
+        def level=(level)
+          raise ArgumentError unless LEVELS.include?(level.to_s)
+          @level = level
+        end
+
+        def level(name = nil)
+          name ? LEVELS.index(name) <= LEVELS.index(@level) : @level
+        end
+
+        def silence
+          old_level, @level = @level, "silent"
+          yield
+        ensure
+          @level = old_level
+        end
+
+      end
+
+      class RGProxy < ::Gem::SilentUI
+        def initialize(ui)
+          @ui = ui
+          super()
+        end
+
+        def say(message)
+          if message =~ /native extensions/
+            @ui.info "with native extensions "
+          else
+            @ui.debug(message)
+          end
+        end
+      end
+
+
+      # Cache all the gems locally without using the shared GEM_PATH
+      Bundler.settings[:cache_all] = true
+      Bundler.settings[:local] = true
+      Bundler.settings[:disable_shared_gems] = true
+      # Make sure we cache all the gems, despite what the local config file says...
+      Bundler.settings.without = []
+
+      # Stupid bundler requires this because it's not abstracted out into a library that doesn't need IO
+      Bundler.ui = UI.new()
+      Bundler.rubygems.ui = ::RGProxy.new(Bundler.ui)
+      Bundler.ui.level = "debug"
+
+      # Load the the Gemfile and resolve gems using RubyGems.org
+      definition = Bundler.definition
+      definition.validate_ruby!
+      definition.resolve_remotely!
+
+      mkdir_p Bundler.app_cache
+
+      # Cache the gems
+      definition.specs.each do |spec|
+        # Fetch Rubygem specs
+        Bundler::Fetcher.fetch(spec) if spec.source.is_a?(Bundler::Source::Rubygems)
+        # Cache everything but bundler itself...
+        spec.source.cache(spec) unless spec.name == "bundler"
+      end
+
+    end
+  end
+end

data/install.rb

@@ -121,7 +121,7 @@ end
 
 def do_libs(libs, strip = 'lib/')
   libs.each do |lf|
-    olf = File.join(InstallOptions.site_dir, lf.gsub(/#{strip}/, ''))
+    olf = File.join(InstallOptions.site_dir, lf.sub(/^#{strip}/, ''))
     op = File.dirname(olf)
     if $haveftools
       File.makedirs(op, true)

data/lib/puppet.rb

@@ -7,6 +7,8 @@ rescue LoadError
 end
 
 # see the bottom of the file for further inclusions
+# Also see the new Vendor support - towards the end
+
 require 'singleton'
 require 'facter'
 require 'puppet/error'
@@ -112,6 +114,15 @@ module Puppet
   def self.newtype(name, options = {}, &block)
     Puppet::Type.newtype(name, options, &block)
   end
+
+  # Load vendored (setup paths, and load what is needed upfront).
+  # See the Vendor class for how to add additional vendored gems/code
+  require "puppet/vendor"
+  Puppet::Vendor.load_vendored
+
+  # Set default for YAML.load to unsafe so we don't affect programs
+  # requiring puppet -- in puppet we will call safe explicitly
+  SafeYAML::OPTIONS[:default_mode] = :unsafe
 end
 
 require 'puppet/type'

data/lib/puppet/indirector/report/processor.rb

@@ -49,7 +49,7 @@ class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
   end
 
   def processors(&blk)
-    return if Puppet[:reports] == "none"
+    return [] if Puppet[:reports] == "none"
     reports.each do |name|
       if mod = Puppet::Reports.report(name)
         yield(mod)

data/lib/puppet/indirector/report/rest.rb

@@ -4,4 +4,11 @@ class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
   desc "Get server report over HTTP via REST."
   use_server_setting(:report_server)
   use_port_setting(:report_port)
+
+  private
+
+  def deserialize_save(content_type, body)
+    format = Puppet::Network::FormatHandler.protected_format(content_type)
+    format.intern(Array, body)
+  end
 end

data/lib/puppet/indirector/resource/rest.rb

@@ -2,4 +2,13 @@ require 'puppet/indirector/status'
 require 'puppet/indirector/rest'
 
 class Puppet::Resource::Rest < Puppet::Indirector::REST
+
+  private
+
+  def deserialize_save(content_type, body)
+    # Body is [ral_res.to_resource, transaction.report]
+    format = Puppet::Network::FormatHandler.protected_format(content_type)
+    ary = format.intern(Array, body)
+    [Puppet::Resource.from_pson(ary[0]), Puppet::Transaction::Report.from_pson(ary[1])]
+  end
 end

data/lib/puppet/indirector/rest.rb

@@ -32,36 +32,6 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     Puppet.settings[port_setting || :masterport].to_i
   end
 
-  # Figure out the content type, turn that into a format, and use the format
-  # to extract the body of the response.
-  def deserialize(response, multiple = false)
-    case response.code
-    when "404"
-      return nil
-    when /^2/
-      raise "No content type in http response; cannot parse" unless response['content-type']
-
-      content_type = response['content-type'].gsub(/\s*;.*$/,'') # strip any appended charset
-
-      body = uncompress_body(response)
-
-      # Convert the response to a deserialized object.
-      if multiple
-        model.convert_from_multiple(content_type, body)
-      else
-        model.convert_from(content_type, body)
-      end
-    else
-      # Raise the http error if we didn't get a 'success' of some kind.
-      raise convert_to_http_error(response)
-    end
-  end
-
-  def convert_to_http_error(response)
-    message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
-    Net::HTTPError.new(message, response)
-  end
-
   # Provide appropriate headers.
   def headers
     add_accept_encoding({"Accept" => model.supported_formats.join(", ")})
@@ -127,39 +97,58 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     else
       http_get(request, uri_with_query_string, headers)
     end
-    result = deserialize response
-    result.name = request.key if result.respond_to?(:name=)
-    result
+
+    if is_http_200?(response)
+      content_type, body = parse_response(response)
+      result = deserialize_find(content_type, body)
+      result.name = request.key if result.respond_to?(:name=)
+      result
+    else
+      nil
+    end
   end
 
   def head(request)
     response = http_head(request, indirection2uri(request), headers)
-    case response.code
-    when "404"
-      return false
-    when /^2/
-      return true
-    else
-      # Raise the http error if we didn't get a 'success' of some kind.
-      raise convert_to_http_error(response)
-    end
+
+    !!is_http_200?(response)
   end
 
   def search(request)
-    unless result = deserialize(http_get(request, indirection2uri(request), headers), true)
-      return []
+    response = http_get(request, indirection2uri(request), headers)
+
+    if is_http_200?(response)
+      content_type, body = parse_response(response)
+      deserialize_search(content_type, body) || []
+    else
+      []
     end
-    result
   end
 
   def destroy(request)
     raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
-    deserialize http_delete(request, indirection2uri(request), headers)
+
+    response = http_delete(request, indirection2uri(request), headers)
+
+    if is_http_200?(response)
+      content_type, body = parse_response(response)
+      deserialize_destroy(content_type, body)
+    else
+      nil
+    end
   end
 
   def save(request)
     raise ArgumentError, "PUT does not accept options" unless request.options.empty?
-    deserialize http_put(request, indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+
+    response = http_put(request, indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+
+    if is_http_200?(response)
+      content_type, body = parse_response(response)
+      deserialize_save(content_type, body)
+    else
+      nil
+    end
   end
 
   def validate_key(request)
@@ -168,6 +157,51 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
 
   private
 
+  def is_http_200?(response)
+    case response.code
+    when "404"
+      false
+    when /^2/
+      true
+    else
+      # Raise the http error if we didn't get a 'success' of some kind.
+      raise convert_to_http_error(response)
+    end
+  end
+
+  def convert_to_http_error(response)
+    message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
+    Net::HTTPError.new(message, response)
+  end
+
+  # Returns the content_type, stripping any appended charset, and the
+  # body, decompressed if necessary (content-encoding is checked inside
+  # uncompress_body)
+  def parse_response(response)
+    if response['content-type']
+      [ response['content-type'].gsub(/\s*;.*$/,''),
+        body = uncompress_body(response) ]
+    else
+      raise "No content type in http response; cannot parse"
+    end
+  end
+
+  def deserialize_find(content_type, body)
+    model.convert_from(content_type, body)
+  end
+
+  def deserialize_search(content_type, body)
+    model.convert_from_multiple(content_type, body)
+  end
+
+  def deserialize_destroy(content_type, body)
+    model.convert_from(content_type, body)
+  end
+
+  def deserialize_save(content_type, body)
+    nil
+  end
+
   def environment
     Puppet::Node::Environment.new
   end

data/lib/puppet/indirector/run/rest.rb

@@ -3,4 +3,10 @@ require 'puppet/indirector/rest'
 
 class Puppet::Run::Rest < Puppet::Indirector::REST
   desc "Trigger Agent runs via REST."
+
+  private
+
+  def deserialize_save(content_type, body)
+    model.convert_from(content_type, body)
+  end
 end

data/lib/puppet/network/formats.rb

@@ -3,12 +3,20 @@ require 'puppet/network/format_handler'
 Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
   # Yaml doesn't need the class name; it's serialized.
   def intern(klass, text)
-    YAML.safely_load(text)
+    data = YAML.load(text, :safe => true, :deserialize_symbols => true)
+    return data if data.is_a?(klass)
+    klass.from_pson(data)
   end
 
   # Yaml doesn't need the class name; it's serialized.
   def intern_multiple(klass, text)
-    YAML.safely_load(text)
+    YAML.load(text, :safe => true, :deserialize_symbols => true).collect do |data|
+      if data.is_a?(klass)
+        data
+      else
+        klass.from_pson(data)
+      end
+    end
   end
 
   def render(instance)
@@ -45,11 +53,15 @@ Puppet::Network::FormatHandler.create_serialized_formats(:b64_zlib_yaml) do
   end
 
   def intern(klass, text)
-    decode(text)
+    requiring_zlib do
+      Puppet::Network::FormatHandler.format(:yaml).intern(klass, decode(text))
+    end
   end
 
   def intern_multiple(klass, text)
-    decode(text)
+    requiring_zlib do
+      Puppet::Network::FormatHandler.format(:yaml).intern_multiple(klass, decode(text))
+    end
   end
 
   def render(instance)
@@ -64,15 +76,13 @@ Puppet::Network::FormatHandler.create_serialized_formats(:b64_zlib_yaml) do
     true
   end
 
-  def encode(text)
-    requiring_zlib do
-      Base64.encode64(Zlib::Deflate.deflate(text, Zlib::BEST_COMPRESSION))
-    end
+  def decode(data)
+    Zlib::Inflate.inflate(Base64.decode64(data))
   end
 
-  def decode(yaml)
+  def encode(text)
     requiring_zlib do
-      YAML.safely_load(Zlib::Inflate.inflate(Base64.decode64(yaml)))
+      Base64.encode64(Zlib::Deflate.deflate(text, Zlib::BEST_COMPRESSION))
     end
   end
 end