puppet 3.3.0 → 3.3.1.rc1

data/lib/puppet/transaction/event.rb

@@ -83,7 +83,7 @@ class Puppet::Transaction::Event
   end
 
   def to_yaml_properties
-    YAML_ATTRIBUTES & instance_variables
+    YAML_ATTRIBUTES & super
   end
 
   private

data/lib/puppet/transaction/report.rb

@@ -312,11 +312,15 @@ class Puppet::Transaction::Report
   # @api private
   #
   def to_yaml_properties
-    instance_variables - [:@external_times]
+    super - [:@external_times]
   end
 
   def self.supported_formats
-    [Puppet[:report_serialization_format].intern]
+    [:pson, :yaml]
+  end
+
+  def self.default_format
+    Puppet[:report_serialization_format].intern
   end
 
   private

data/lib/puppet/util/monkey_patches.rb

@@ -161,58 +161,6 @@ class Range
   alias_method :&, :intersection unless method_defined? :&
 end
 
-########################################################################
-# The return type of `instance_variables` changes between Ruby 1.8 and 1.9
-# releases; it used to return an array of strings in the form "@foo", but
-# now returns an array of symbols in the form :@foo.
-#
-# Nothing else in the stack cares which form you get - you can pass the
-# string or symbol to things like `instance_variable_set` and they will work
-# transparently.
-#
-# Having the same form in all releases of Puppet is a win, though, so we
-# pick a unification and enforce than on all releases.  That way developers
-# who do set math on them (eg: for YAML rendering) don't have to handle the
-# distinction themselves.
-#
-# In the sane tradition, we bring older releases into conformance with newer
-# releases, so we return symbols rather than strings, to be more like the
-# future versions of Ruby are.
-#
-# We also carefully support reloading, by only wrapping when we don't
-# already have the original version of the method aliased away somewhere.
-if RUBY_VERSION[0,3] == '1.8'
-  unless Object.respond_to?(:puppet_original_instance_variables)
-
-    # Add our wrapper to the method.
-    class Object
-      alias :puppet_original_instance_variables :instance_variables
-
-      def instance_variables
-        puppet_original_instance_variables.map(&:to_sym)
-      end
-    end
-
-    # The one place that Ruby 1.8 assumes something about the return format of
-    # the `instance_variables` method is actually kind of odd, because it uses
-    # eval to get at instance variables of another object.
-    #
-    # This takes the original code and applies replaces instance_eval with
-    # instance_variable_get through it.  All other bugs in the original (such
-    # as equality depending on the instance variables having the same order
-    # without any promise from the runtime) are preserved. --daniel 2012-03-11
-    require 'resolv'
-    class Resolv::DNS::Resource
-      def ==(other) # :nodoc:
-        return self.class == other.class &&
-          self.instance_variables == other.instance_variables &&
-          self.instance_variables.collect {|name| self.instance_variable_get name} ==
-          other.instance_variables.collect {|name| other.instance_variable_get name}
-      end
-    end
-  end
-end
-
 # (#19151) Reject all SSLv2 ciphers and handshakes
 require 'openssl'
 class OpenSSL::SSL::SSLContext

data/lib/puppet/util/storage.rb

@@ -1,6 +1,7 @@
 require 'yaml'
 require 'sync'
 require 'singleton'
+require 'puppet/util/yaml'
 
 # a class for storing state
 class Puppet::Util::Storage
@@ -32,12 +33,10 @@ class Puppet::Util::Storage
 
   def self.clear
     @@state.clear
-    Storage.init
   end
 
   def self.init
     @@state = {}
-    @@splitchar = "\t"
   end
 
   self.init
@@ -47,7 +46,7 @@ class Puppet::Util::Storage
     filename = Puppet[:statefile]
 
     unless File.exists?(filename)
-      self.init unless !@@state.nil?
+      self.init if @@state.nil?
       return
     end
     unless File.file?(filename)
@@ -56,8 +55,8 @@ class Puppet::Util::Storage
     end
     Puppet::Util.benchmark(:debug, "Loaded state") do
       begin
-        @@state = YAML.load(::File.read(filename))
-      rescue => detail
+        @@state = Puppet::Util::Yaml.load_file(filename)
+      rescue Puppet::Util::Yaml::YamlLoadError => detail
         Puppet.err "Checksumfile #{filename} is corrupt (#{detail}); replacing"
 
         begin
@@ -84,9 +83,7 @@ class Puppet::Util::Storage
     Puppet.info "Creating state file #{Puppet[:statefile]}" unless FileTest.exist?(Puppet[:statefile])
 
     Puppet::Util.benchmark(:debug, "Stored state") do
-      Puppet::Util.replace_file(Puppet[:statefile], 0660) do |fh|
-        fh.print YAML.dump(@@state)
-      end
+      Puppet::Util::Yaml.dump(@@state, Puppet[:statefile])
     end
   end
 end

data/lib/puppet/util/yaml.rb

@@ -0,0 +1,23 @@
+require 'yaml'
+
+module Puppet::Util::Yaml
+  if defined?(::Psych::SyntaxError)
+    YamlLoadExceptions = [::StandardError, ::Psych::SyntaxError]
+  else
+    YamlLoadExceptions = [::StandardError]
+  end
+
+  class YamlLoadError < Puppet::Error; end
+
+  def self.load_file(filename)
+    YAML.load_file(filename)
+  rescue *YamlLoadExceptions => detail
+    raise YamlLoadError.new(detail.message, detail)
+  end
+
+  def self.dump(structure, filename)
+    Puppet::Util.replace_file(filename, 0660) do |fh|
+      YAML.dump(structure, fh)
+    end
+  end
+end

data/lib/puppet/util/zaml.rb

@@ -171,16 +171,28 @@ end
 ################################################################
 
 class Object
-  def to_yaml_properties
-    instance_variables          # default YAML behaviour.
+  # Users of this method need to do set math consistently with the
+  # result. Since #instance_variables returns strings in 1.8 and symbols
+  # on 1.9, standardize on symbols
+  if RUBY_VERSION[0,3] == '1.8'
+    def to_yaml_properties
+      instance_variables.map(&:to_sym)
+    end
+  else
+    def to_yaml_properties
+      instance_variables
+    end
   end
+
   def yaml_property_munge(x)
     x
   end
+
   def zamlized_class_name(root)
     cls = self.class
     "!ruby/#{root.name.downcase}#{cls == root ? '' : ":#{cls.respond_to?(:name) ? cls.name : cls}"}"
   end
+
   def to_zaml(z)
     z.first_time_only(self) {
       z.emit(zamlized_class_name(Object))

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.3.0'
+  PUPPETVERSION = '3.3.1-rc1'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/unit/agent_spec.rb

@@ -20,6 +20,8 @@ end
 
 describe Puppet::Agent do
   before do
+    Puppet::Status.indirection.stubs(:find).returns Puppet::Status.new("version" => Puppet.version)
+
     @agent = Puppet::Agent.new(AgentTestClient, false)
 
     # So we don't actually try to hit the filesystem.

data/spec/unit/file_bucket/file_spec.rb

@@ -15,18 +15,28 @@ describe Puppet::FileBucket::File do
   let(:bucketdir) { Puppet[:bucketdir] = tmpdir('bucket') }
   let(:destdir) { File.join(bucketdir, "8/b/3/7/0/2/a/d/#{digest}") }
 
-  it "defines its supported format to be `:s`" do
-    expect(Puppet::FileBucket::File.supported_formats).to eq([:s])
+  it "defaults to serializing to `:s`" do
+    expect(Puppet::FileBucket::File.default_format).to eq(:s)
   end
 
-  it "serializes to `:s`" do
-    expect(Puppet::FileBucket::File.new(contents).to_s).to eq(contents)
+  it "accepts s and pson" do
+   expect(Puppet::FileBucket::File.supported_formats).to include(:s, :pson)
   end
 
-  it "deserializes from `:s`" do
-    file = Puppet::FileBucket::File.from_s(contents)
+  it "can make a round trip through `s`" do
+    file = Puppet::FileBucket::File.new(contents)
 
-    expect(file.contents).to eq(contents)
+    tripped = Puppet::FileBucket::File.convert_from(:s, file.render)
+
+    expect(tripped.contents).to eq(contents)
+  end
+
+  it "can make a round trip through `pson`" do
+    file = Puppet::FileBucket::File.new(contents)
+
+    tripped = Puppet::FileBucket::File.convert_from(:pson, file.render(:pson))
+
+    expect(tripped.contents).to eq(contents)
   end
 
   it "should raise an error if changing content" do
@@ -76,12 +86,8 @@ describe Puppet::FileBucket::File do
   end
 
   it "should convert the contents to PSON" do
-    # The model class no longer defines to_pson and it is not a supported
-    # format, but pson monkey patches Object#to_pson to return
-    # Object#to_s.to_pson, and it monkey patches String#to_pson to wrap the
-    # returned string in quotes. So it works in a way that is completely
-    # unexpected, and it doesn't round-trip correctly, awesome.
-    Puppet::FileBucket::File.new("file contents").to_pson.should == '"file contents"'
+    Puppet.expects(:deprecation_warning).with('Serializing Puppet::FileBucket::File objects to pson is deprecated.')
+    Puppet::FileBucket::File.new("file contents").to_pson.should == '{"contents":"file contents"}'
   end
 
   it "should load from PSON" do

data/spec/unit/indirector/certificate/rest_spec.rb

@@ -51,6 +51,7 @@ rn/G
     response = stub 'response', :code => "200", :body => cert_string
     response.stubs(:[]).with('content-type').returns "text/plain"
     response.stubs(:[]).with('content-encoding')
+    response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
     network.stubs(:verify_callback=)
     network.expects(:get).returns response
 

data/spec/unit/indirector/report/rest_spec.rb

@@ -36,6 +36,7 @@ describe Puppet::Transaction::Report::Rest do
     obj = stub('http 200 ok', :code => code.to_s, :body => body)
     obj.stubs(:[]).with('content-type').returns(content_type)
     obj.stubs(:[]).with('content-encoding').returns(encoding)
+    obj.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
     obj
   end
 

data/spec/unit/indirector/request_spec.rb

@@ -334,6 +334,15 @@ describe Puppet::Indirector::Request do
       }
     end
 
+    it "should convert an array of values into a single yaml entry when in legacy mode" do
+      Puppet[:legacy_query_parameter_serialization] = true
+      request = a_request_with_options(:one => %w{one two})
+
+      the_parsed_query_string_from(request).should == {
+          "one" => ["--- \n  - one\n  - two"]
+      }
+    end
+
     it "should stringify simple data types inside an array" do
       request = a_request_with_options(:one => ['one', nil])
 

data/spec/unit/indirector/rest_spec.rb

@@ -5,8 +5,28 @@ require 'puppet/indirector/errors'
 require 'puppet/indirector/rest'
 
 # Just one from each category since the code makes no real distinctions
-HTTP_ERROR_CODES = [300, 400, 500]
 shared_examples_for "a REST terminus method" do |terminus_method|
+  describe "when talking to an older master" do
+    it "should set backward compatibility settings" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns nil
+
+      terminus.send(terminus_method, request)
+      Puppet[:report_serialization_format].should == 'yaml'
+      Puppet[:legacy_query_parameter_serialization].should == true
+    end
+  end
+
+  describe "when talking to a 3.3.1 master" do
+    it "should not set backward compatibility settings" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns "3.3.1"
+
+      terminus.send(terminus_method, request)
+      Puppet[:report_serialization_format].should == 'pson'
+      Puppet[:legacy_query_parameter_serialization].should == false
+    end
+  end
+
+  HTTP_ERROR_CODES = [300, 400, 500]
   HTTP_ERROR_CODES.each do |code|
     describe "when the response code is #{code}" do
       let(:response) { mock_response(code, 'error messaged!!!') }
@@ -115,6 +135,7 @@ describe Puppet::Indirector::REST do
     obj = stub('http 200 ok', :code => code.to_s, :body => body)
     obj.stubs(:[]).with('content-type').returns(content_type)
     obj.stubs(:[]).with('content-encoding').returns(encoding)
+    obj.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
     obj
   end
 
@@ -174,7 +195,6 @@ describe Puppet::Indirector::REST do
     terminus_class.port.should == 543
   end
 
-
   it 'should default to :puppet for the srv_service' do
     Puppet::Indirector::REST.srv_service.should == :puppet
   end

data/spec/unit/indirector/run/local_spec.rb

@@ -4,11 +4,13 @@ require 'spec_helper'
 require 'puppet/indirector/run/local'
 
 describe Puppet::Run::Local do
-  it "should be a sublcass of Puppet::Indirector::Code" do
+  it "should be a subclass of Puppet::Indirector::Code" do
     Puppet::Run::Local.superclass.should equal(Puppet::Indirector::Code)
   end
 
   it "should call runner.run on save and return the runner" do
+    Puppet::Status.indirection.stubs(:find).returns Puppet::Status.new
+
     runner  = Puppet::Run.new
     runner.stubs(:run).returns(runner)
 

data/spec/unit/indirector/status/local_spec.rb

@@ -0,0 +1,11 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/indirector/status/local'
+
+describe Puppet::Indirector::Status::Local do
+  it "should set the puppet version" do
+    Puppet::Status.indirection.terminus_class = :local
+    expect(Puppet::Status.indirection.find('*').version).to eq(Puppet.version)
+  end
+end

data/spec/unit/indirector/status/rest_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 require 'puppet/indirector/status/rest'
 
 describe Puppet::Indirector::Status::Rest do
-  it "should be a sublcass of Puppet::Indirector::REST" do
+  it "should be a subclass of Puppet::Indirector::REST" do
     Puppet::Indirector::Status::Rest.superclass.should equal(Puppet::Indirector::REST)
   end
 end

data/spec/unit/indirector/yaml_spec.rb

@@ -4,6 +4,12 @@ require 'spec_helper'
 require 'puppet/indirector/yaml'
 
 describe Puppet::Indirector::Yaml do
+  include PuppetSpec::Files
+
+  class TestSubject
+    attr_accessor :name
+  end
+
   before :all do
     @indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
     Puppet::Indirector::Indirection.expects(:instance).with(:my_yaml).returns(@indirection)
@@ -16,11 +22,10 @@ describe Puppet::Indirector::Yaml do
   before :each do
     @store = @store_class.new
 
-    @subject = Object.new
-    @subject.singleton_class.send(:attr_accessor, :name)
+    @subject = TestSubject.new
     @subject.name = :me
 
-    @dir = File.expand_path("/what/ever")
+    @dir = tmpdir("yaml_indirector")
     Puppet[:clientyamldir] = @dir
     Puppet.run_mode.stubs(:master?).returns false
 
@@ -87,54 +92,25 @@ describe Puppet::Indirector::Yaml do
       @request.stubs(:instance).returns Object.new
       proc { @store.save(@request) }.should raise_error(ArgumentError)
     end
-
-    it "should convert Ruby objects to YAML and write them to disk using a write lock" do
-      yaml = @subject.to_yaml
-      file = mock 'file'
-      path = @store.send(:path, @subject.name)
-      FileTest.expects(:exist?).with(File.dirname(path)).returns(true)
-      Puppet::Util.expects(:replace_file).with(path, 0660).yields(file)
-      file.expects(:print).with(yaml)
-
-      @store.save(@request)
-    end
-
-    it "should create the indirection subdirectory if it does not exist" do
-      yaml = @subject.to_yaml
-      file = mock 'file'
-      path = @store.send(:path, @subject.name)
-      dir = File.dirname(path)
-
-      FileTest.expects(:exist?).with(dir).returns(false)
-      Dir.expects(:mkdir).with(dir)
-
-      Puppet::Util.expects(:replace_file).yields(file)
-      file.expects(:print).with(yaml)
-
-      @store.save(@request)
-    end
   end
 
   describe "when retrieving YAML" do
     it "should read YAML in from disk and convert it to Ruby objects" do
-      path = @store.send(:path, @subject.name)
-      yaml = @subject.to_yaml
-
-      FileTest.expects(:exist?).with(path).returns true
-      File.expects(:read).with(path).returns yaml
+      @store.save(Puppet::Indirector::Request.new(:my_yaml, :save, "testing", @subject))
 
-      @store.find(@request).instance_variable_get("@name").should == :me
+      @store.find(Puppet::Indirector::Request.new(:my_yaml, :find, "testing", nil)).name.should == :me
     end
 
     it "should fail coherently when the stored YAML is invalid" do
-      path = @store.send(:path, @subject.name)
-      FileTest.expects(:exist?).with(path).returns(true)
+      saved_structure = Struct.new(:name).new("testing")
 
-      # Something that will fail in yaml
-      File.expects(:read).returns "--- foo:\n  1,2,3\nargh"
+      @store.save(Puppet::Indirector::Request.new(:my_yaml, :save, "testing", saved_structure))
+      File.open(@store.path(saved_structure.name), "w") do |file|
+        file.puts "{ invalid"
+      end
 
       expect {
-        @store.find(@request)
+        @store.find(Puppet::Indirector::Request.new(:my_yaml, :find, "testing", nil))
       }.to raise_error(Puppet::Error, /Could not parse YAML data/)
     end
   end