puppet 3.2.1 → 3.2.2

data/install.rb

@@ -107,7 +107,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

@@ -1,6 +1,8 @@
 require 'puppet/version'
 
 # see the bottom of the file for further inclusions
+# Also see the new Vendor support - towards the end
+#
 require 'facter'
 require 'puppet/error'
 require 'puppet/util'
@@ -153,6 +155,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
 
 # This feels weird to me; I would really like for us to get to a state where there is never a "require" statement

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

@@ -48,7 +48,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

@@ -5,4 +5,11 @@ class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
   use_server_setting(:report_server)
   use_port_setting(:report_port)
   use_srv_service(:report)
+
+  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

@@ -5,4 +5,12 @@ class Puppet::Resource::Rest < Puppet::Indirector::REST
 
   desc "Maniuplate resources remotely? Undocumented."
 
+  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

@@ -42,36 +42,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(", ")})
@@ -126,12 +96,15 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
         http_get(request, uri_with_query_string, headers)
       end
     end
-    result = deserialize(response)
 
-    return nil unless result
-
-    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)
@@ -139,39 +112,49 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
       http_head(request, indirection2uri(request), headers)
     end
 
-    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)
-    result = do_request(request) do |request|
-      deserialize(http_get(request, indirection2uri(request), headers), true)
+    response = do_request(request) do |request|
+      http_get(request, indirection2uri(request), headers)
     end
 
-    # result from the server can be nil, but we promise to return an array...
-    result || []
+    if is_http_200?(response)
+      content_type, body = parse_response(response)
+      deserialize_search(content_type, body) || []
+    else
+      []
+    end
   end
 
   def destroy(request)
     raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
 
-    do_request(request) do |request|
-      return deserialize(http_delete(request, indirection2uri(request), headers))
+    response = do_request(request) do |request|
+      http_delete(request, indirection2uri(request), headers)
+    end
+
+    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?
 
-    do_request(request) do |request|
-      deserialize http_put(request, indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+    response = do_request(request) do |request|
+      http_put(request, indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+    end
+
+    if is_http_200?(response)
+      content_type, body = parse_response(response)
+      deserialize_save(content_type, body)
+    else
+      nil
     end
   end
 
@@ -191,6 +174,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

data/lib/puppet/network/http/handler.rb

@@ -265,7 +265,7 @@ module Puppet::Network::HTTP::Handler
       next result if param == :ip
       value = CGI.unescape(value)
       if value =~ /^---/
-        value = YAML.safely_load(value)
+        value = YAML.load(value, :safe => true, :deserialize_symbols => true)
       else
         value = true if value == "true"
         value = false if value == "false"

data/lib/puppet/node.rb

@@ -22,7 +22,7 @@ class Puppet::Node
   ::PSON.register_document_type('Node',self)
 
   def self.from_pson(pson)
-    raise ArgumentError, "No name provided in pson data" unless name = pson['name']
+    raise ArgumentError, "No name provided in serialized data" unless name = pson['name']
 
     node = new(name)
     node.classes = pson['classes']

data/lib/puppet/node/facts.rb

@@ -37,6 +37,26 @@ class Puppet::Node::Facts
     add_timestamp
   end
 
+  def initialize_from_hash(data)
+    @name = data['name']
+    @values = data['values']
+    # Timestamp will be here in YAML
+    timestamp = data['values']['_timestamp']
+    @values.delete_if do |key, val|
+      key =~ /^_/
+    end
+
+    #Timestamp will be here in pson
+    timestamp ||= data['timestamp']
+    timestamp = Time.parse(timestamp) if timestamp.is_a? String
+    self.timestamp = timestamp
+
+    self.expiration = data['expiration']
+    if expiration.is_a? String
+      self.expiration = Time.parse(expiration)
+    end
+  end
+
   # Convert all fact values into strings.
   def stringify
     values.each do |fact, value|
@@ -50,10 +70,9 @@ class Puppet::Node::Facts
   end
 
   def self.from_pson(data)
-    result = new(data['name'], data['values'])
-    result.timestamp = Time.parse(data['timestamp']) if data['timestamp']
-    result.expiration = Time.parse(data['expiration']) if data['expiration']
-    result
+    new_facts = allocate
+    new_facts.initialize_from_hash(data)
+    new_facts
   end
 
   def to_pson(*args)

data/lib/puppet/resource.rb

@@ -28,8 +28,8 @@ class Puppet::Resource
   ATTRIBUTES = [:file, :line, :exported]
 
   def self.from_pson(pson)
-    raise ArgumentError, "No resource type provided in pson data" unless type = pson['type']
-    raise ArgumentError, "No resource title provided in pson data" unless title = pson['title']
+    raise ArgumentError, "No resource type provided in serialized data" unless type = pson['type']
+    raise ArgumentError, "No resource title provided in serialized data" unless title = pson['title']
 
     resource = new(type, title)
 
@@ -47,8 +47,6 @@ class Puppet::Resource
       end
     end
 
-    resource.exported ||= false
-
     resource
   end
 

data/lib/puppet/resource/status.rb

@@ -17,6 +17,13 @@ module Puppet
                            @changed @resource_type @title @skipped @failed}.
         map(&:to_sym)
 
+
+      def self.from_pson(data)
+        obj = self.allocate
+        obj.initialize_from_hash(data)
+        obj
+      end
+
       # Provide a boolean method for each of the states.
       STATES.each do |attr|
         define_method("#{attr}?") do
@@ -67,6 +74,27 @@ module Puppet
         @title = resource.title
       end
 
+      def initialize_from_hash(data)
+        @resource_type = data['resource_type']
+        @title = data['title']
+        @resource = data['resource']
+        @file = data['file']
+        @line = data['line']
+        @evaluation_time = data['evaluation_time']
+        @change_count = data['change_count']
+        @out_of_sync_count = data['out_of_sync_count']
+        @tags = data['tags']
+        @time = data['time']
+        @out_of_sync = data['out_of_sync']
+        @changed = data['changed']
+        @skipped = data['skipped']
+        @failed = data['failed']
+
+        @events = data['events'].map do |event|
+          Puppet::Transaction::Event.from_pson(event)
+        end
+      end
+
       def to_yaml_properties
         YAML_ATTRIBUTES & instance_variables
       end

data/lib/puppet/run.rb

@@ -33,6 +33,17 @@ class Puppet::Run
     @options = options
   end
 
+  def initialize_from_hash(hash)
+    @options = {}
+
+    hash['options'].each do |key, value|
+      @options[key.to_sym] = value
+    end
+
+    @background = hash['background']
+    @status = hash['status']
+  end
+
   def log_run
     msg = ""
     msg += "triggered run" % if options[:tags]
@@ -63,9 +74,20 @@ class Puppet::Run
     self
   end
 
-  def self.from_pson( pson )
+  def self.from_hash(hash)
+    obj = allocate
+    obj.initialize_from_hash(hash)
+    obj
+  end
+
+  def self.from_pson(hash)
+    if hash['options']
+      return from_hash(hash)
+    end
+
     options = { :pluginsync => Puppet[:pluginsync] }
-    pson.each do |key, value|
+
+    hash.each do |key, value|
       options[key.to_sym] = value
     end