puppet 0.25.0 → 0.25.1

data/lib/puppet/type/yumrepo.rb

@@ -178,9 +178,16 @@ module Puppet
 
         # Store all modifications back to disk
         def self.store
-            file = inifile.store
-            unless file.nil?
-                File.chmod(0644, file)
+            inifile.store
+            unless Puppet[:noop]
+                target_mode = 0644 # FIXME: should be configurable
+                inifile.each_file do |file|
+                    current_mode = File.stat(file).mode & 0777
+                    unless current_mode == target_mode
+                        Puppet::info "changing mode of #{file} from %03o to %03o" % [current_mode, target_mode]
+                        File.chmod(target_mode, file)
+                    end
+                end
             end
         end
 

data/lib/puppet/util.rb

@@ -185,19 +185,14 @@ module Util
 
     def binary(bin)
         if bin =~ /^\//
-            if FileTest.file? bin and FileTest.executable? bin
-                return bin
-            else
-                return nil
-            end
+            return bin if FileTest.file? bin and FileTest.executable? bin
         else
-            x = %x{which #{bin} 2>/dev/null}.chomp
-            if x == ""
-                return nil
-            else
-                return x
-            end
+           ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
+               dest=File.join(dir, bin)
+               return dest if FileTest.file? dest and FileTest.executable? dest
+           end
         end
+        return nil
     end
     module_function :binary
 

data/lib/puppet/util/inifile.rb

@@ -180,6 +180,14 @@ module Puppet::Util::IniConfig
             end
         end
 
+        # Execute BLOCK, passing each file constituting this inifile
+        # as an argument
+        def each_file(&block)
+            @files.keys.each do |file|
+                yield(file)
+            end
+        end
+
         # Return the Section with the given name or nil
         def [](name)
             name = name.to_s

data/lib/puppet/util/log.rb

@@ -282,9 +282,9 @@ class Puppet::Util::Log
 
         def colorize(level, str)
             case Puppet[:color]
-            when false; str
-            when true, :ansi, "ansi"; console_color(level, str)
+            when true, :ansi, "ansi", :yes, "yes"; console_color(level, str)
             when :html, "html"; html_color(level, str)
+            else str
             end
         end
 

data/lib/puppet/util/monkey_patches.rb

@@ -1,43 +0,0 @@
-#
-# Monkey patches to ruby classes for compatibility
-#
-#
-# In earlier versions of ruby (e.g. 1.8.1) yaml serialized symbols with an explicit
-# type designation.  Later versions understand the explicit form in addition to the
-# implicit "literal" form (e.g. :symbol) which they produce.
-#
-# This causes problems when the puppet master and the client are running on different
-# versions of ruby; the newer version can produce yaml that it's older partner can't 
-# decypher.
-#
-# This patch causes newer versions to produce the older encoding for Symbols.  It is
-# only applied if the existing library does not already produce them.  Thus it will
-# not be applied on older rubys and it will not be applied more than once.  It also 
-# checks that it has been applied to a version which support it and, if not reverts
-# to the original.
-#
-require "yaml"
-
-if :test.to_yaml !~ %r{!ruby/sym}
-    class Symbol
-        if !respond_to? :original_to_yaml
-            alias :original_to_yaml :to_yaml
-            def to_yaml(opts={})
-                YAML::quick_emit(nil,opts) { |out|
-                    if out.respond_to? :scalar
-                        # 1.8.5 through 1.8.8, possibly others
-                        out.scalar("tag:ruby:sym", to_s,:to_yaml_style)
-                    elsif out.respond_to? :<<
-                        # 1.8.2, possibly others
-                        out << "!ruby/sym "
-                        self.id2name.to_yaml( :Emitter => out )
-                    else
-                        # go back to the base version if neither of the above work
-                        alias :to_yaml :original_to_yaml
-                        to_yaml(opts)
-                    end
-                }
-            end    
-        end
-    end
-end

data/lib/puppet/util/{json.rb → pson.rb}

@@ -1,13 +1,13 @@
-# A simple module to provide consistency between how we use JSON and how 
+# A simple module to provide consistency between how we use PSON and how 
 # ruby expects it to be used.  Basically, we don't want to require
 # that the sender specify a class.
-#  Ruby wants everyone to provide a 'json_class' field, and the JSON support
+#  Ruby wants everyone to provide a 'type' field, and the PSON support
 # requires such a field to track the class down.  Because we use our URL to
 # figure out what class we're working on, we don't need that, and we don't want
 # our consumers and producers to need to know anything about our internals.
-module Puppet::Util::Json
-    def json_create(json)
-        raise ArgumentError, "No data provided in json data" unless json['data']
-        from_json(json['data'])
+module Puppet::Util::Pson
+    def pson_create(pson)
+        raise ArgumentError, "No data provided in pson data" unless pson['data']
+        from_pson(pson['data'])
     end
 end

data/lib/puppet/util/rdoc.rb

@@ -49,13 +49,15 @@ module Puppet::Util::RDoc
     # of a manifest
     def output(file, ast)
         astobj = []
-        ast[:nodes].each do |name, k|
+        ast.nodes.each do |name, k|
             astobj << k if k.file == file
         end
-        ast[:classes].each do |name, k|
+
+        ast.hostclasses.each do |name,k|
             astobj << k if k.file == file
         end
-        ast[:definitions].each do |name, k|
+
+        ast.definitions.each do |name, k|
             astobj << k if k.file == file
         end
         astobj.sort! {|a,b| a.line <=> b.line }.each do |k|

data/lib/puppet/util/selinux.rb

@@ -154,16 +154,22 @@ module Puppet::Util::SELinux
     def read_mounts
         mounts = ""
         begin
-            mountfh = File.open("/proc/mounts")
-            # We use read_nonblock() in a loop rather than read() to work-around
-            # a linux kernel bug.  See ticket #1963 for details.
-            while true
-                mounts += mountfh.read_nonblock(1024)
+            if File.instance_methods.include? "read_nonblock"
+                # If possible we use read_nonblock() in a loop rather than read() to work-
+                # a linux kernel bug.  See ticket #1963 for details.
+                mountfh = File.open("/proc/mounts")
+                mounts += mountfh.read_nonblock(1024) while true
+            else
+                # Otherwise we shell out and let cat do it for us
+                mountfh = IO.popen("/bin/cat /proc/mounts")
+                mounts = mountfh.read
             end
         rescue EOFError
-            mountfh.close
+            # that's expected
         rescue
             return nil
+        ensure        
+            mountfh.close
         end
 
         mntpoint = {}

data/lib/puppet/util/settings.rb

@@ -653,6 +653,30 @@ Generated on #{Time.now}.
         @config.has_key?(param)
     end
 
+    def uninterpolated_value(param, environment = nil)
+        param = param.to_sym
+        environment = environment.to_sym if environment
+
+        # See if we can find it within our searchable list of values
+        val = catch :foundval do
+            each_source(environment) do |source|
+                # Look for the value.  We have to test the hash for whether
+                # it exists, because the value might be false.
+                @sync.synchronize do
+                    if @values[source].include?(param)
+                        throw :foundval, @values[source][param]
+                    end
+                end
+            end
+            throw :foundval, nil
+        end
+        
+        # If we didn't get a value, use the default
+        val = @config[param].default if val.nil?
+
+        return val
+    end
+
     # Find the correct value using our search path.  Optionally accept an environment
     # in which to search before the other configuration sections.
     def value(param, environment = nil)
@@ -672,22 +696,7 @@ Generated on #{Time.now}.
             return cached
         end
 
-        # See if we can find it within our searchable list of values
-        val = catch :foundval do
-            each_source(environment) do |source|
-                # Look for the value.  We have to test the hash for whether
-                # it exists, because the value might be false.
-                @sync.synchronize do
-                    if @values[source].include?(param)
-                        throw :foundval, @values[source][param]
-                    end
-                end
-            end
-            throw :foundval, nil
-        end
-
-        # If we didn't get a value, use the default
-        val = @config[param].default if val.nil?
+        val = uninterpolated_value(param, environment)
 
         # Convert it if necessary
         val = convert(val, environment)

data/lib/puppet/util/settings/file_setting.rb

@@ -16,7 +16,8 @@ class Puppet::Util::Settings::FileSetting < Puppet::Util::Settings::Setting
 
     def group=(value)
         unless AllowedGroups.include?(value)
-            raise SettingError, "Invalid group %s on setting %s. Valid groups are %s." % [value, name, AllowedGroups.join(', ')]
+            identifying_fields = [desc,name,default].compact.join(': ') 
+            raise SettingError, "Internal error: The :group setting for %s must be 'service', not '%s'" % [identifying_fields,value]
         end
         @group = value
     end
@@ -28,7 +29,8 @@ class Puppet::Util::Settings::FileSetting < Puppet::Util::Settings::Setting
 
     def owner=(value)
         unless AllowedOwners.include?(value)
-            raise SettingError, "Invalid owner %s on setting %s. Valid owners are %s." % [value, name, AllowedOwners.join(', ')]
+            identifying_fields = [desc,name,default].compact.join(': ') 
+            raise SettingError, "Internal error: The :owner setting for %s must be either 'root' or 'service', not '%s'" % [identifying_fields,value]
         end
         @owner = value
     end

data/spec/integration/application/puppet.rb

@@ -10,16 +10,16 @@ describe "Puppet" do
     include PuppetSpec::Files
 
     describe "when applying provided catalogs" do
-        confine "JSON library is missing; cannot test applying catalogs" => Puppet.features.json?
-        it "should be able to apply catalogs provided in a file in json" do
-            file_to_create = tmpfile("json_catalog")
+        confine "PSON library is missing; cannot test applying catalogs" => Puppet.features.pson?
+        it "should be able to apply catalogs provided in a file in pson" do
+            file_to_create = tmpfile("pson_catalog")
             catalog = Puppet::Resource::Catalog.new
             resource = Puppet::Resource.new(:file, file_to_create, :content => "my stuff")
             catalog.add_resource resource
 
             manifest = tmpfile("manifest")
 
-            File.open(manifest, "w") { |f| f.print catalog.to_json }
+            File.open(manifest, "w") { |f| f.print catalog.to_pson }
 
             puppet = Puppet::Application[:puppet]
             puppet.options[:catalog] = manifest

data/spec/integration/defaults.rb

@@ -89,8 +89,8 @@ describe "Puppet defaults" do
         end
     end
 
-    it "should default to json for the preferred serialization format" do
-        Puppet.settings.value(:preferred_serialization_format).should == "json"
+    it "should default to pson for the preferred serialization format" do
+        Puppet.settings.value(:preferred_serialization_format).should == "pson"
     end
 
     describe "when enabling storeconfigs" do

data/spec/integration/indirector/catalog/queue.rb

@@ -6,7 +6,7 @@ require 'puppet/resource/catalog'
 
 
 describe "Puppet::Resource::Catalog::Queue" do
-    confine "Missing json support; cannot test queue" => Puppet.features.json?
+    confine "Missing pson support; cannot test queue" => Puppet.features.pson?
 
     before do
         Puppet::Resource::Catalog.indirection.terminus(:queue)
@@ -23,13 +23,13 @@ describe "Puppet::Resource::Catalog::Queue" do
 
     after { Puppet.settings.clear }
 
-    it "should render catalogs to json and send them via the queue client when catalogs are saved" do
+    it "should render catalogs to pson and send them via the queue client when catalogs are saved" do
         terminus = Puppet::Resource::Catalog.indirection.terminus(:queue)
 
         client = mock 'client'
         terminus.stubs(:client).returns client
 
-        client.expects(:send_message).with(:catalog, @catalog.to_json)
+        client.expects(:send_message).with(:catalog, @catalog.to_pson)
 
         request = Puppet::Indirector::Request.new(:catalog, :save, "foo", :instance => @catalog)
 
@@ -40,9 +40,9 @@ describe "Puppet::Resource::Catalog::Queue" do
         client = mock 'client'
         Puppet::Resource::Catalog::Queue.stubs(:client).returns client
 
-        json = @catalog.to_json
+        pson = @catalog.to_pson
 
-        client.expects(:subscribe).with(:catalog).yields(json)
+        client.expects(:subscribe).with(:catalog).yields(pson)
 
         Puppet.expects(:err).never
 

data/spec/integration/indirector/certificate/rest.rb

@@ -64,6 +64,8 @@ describe "Certificate REST Terminus" do
 
         # There's no good '==' method on certs.
         result.content.to_s.should == @host.certificate.content.to_s
-        result.name.should == @host.certificate.name
+
+        # also make sure it uses the provided name, rather than the internal one.
+        result.name.should == "bar"
     end
 end

data/spec/integration/network/formats.rb

@@ -4,13 +4,13 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/network/formats'
 
-class JsonIntTest
+class PsonIntTest
     attr_accessor :string
     def ==(other)
         other.class == self.class and string == other.string
     end
 
-    def self.from_json(data)
+    def self.from_pson(data)
         new(data[0])
     end
 
@@ -18,15 +18,15 @@ class JsonIntTest
         @string = string
     end
 
-    def to_json(*args)
+    def to_pson(*args)
         {
-            'json_class' => self.class.name,
+            'type' => self.class.name,
             'data' => [@string]
-        }.to_json(*args)
+        }.to_pson(*args)
     end
 
     def self.canonical_order(s)
-        s.gsub(/\{"data":\[(.*?)\],"json_class":"JsonIntTest"\}/,'{"json_class":"JsonIntTest","data":[\1]}')
+        s.gsub(/\{"data":\[(.*?)\],"type":"PsonIntTest"\}/,'{"type":"PsonIntTest","data":[\1]}')
     end
 
 end
@@ -45,65 +45,65 @@ describe Puppet::Network::FormatHandler.format(:s) do
     end
 end
 
-describe Puppet::Network::FormatHandler.format(:json) do
-    describe "when json is absent" do
-        confine "'json' library is present" => (! Puppet.features.json?)
+describe Puppet::Network::FormatHandler.format(:pson) do
+    describe "when pson is absent" do
+        confine "'pson' library is present" => (! Puppet.features.pson?)
 
         before do
-            @json = Puppet::Network::FormatHandler.format(:json)
+            @pson = Puppet::Network::FormatHandler.format(:pson)
         end
 
         it "should not be suitable" do
-            @json.should_not be_suitable
+            @pson.should_not be_suitable
         end
     end
 
-    describe "when json is available" do
-        confine "Missing 'json' library" => Puppet.features.json?
+    describe "when pson is available" do
+        confine "Missing 'pson' library" => Puppet.features.pson?
 
         before do
-            @json = Puppet::Network::FormatHandler.format(:json)
+            @pson = Puppet::Network::FormatHandler.format(:pson)
         end
 
-        it "should be able to render an instance to json" do
-            instance = JsonIntTest.new("foo")
-            JsonIntTest.canonical_order(@json.render(instance)).should == JsonIntTest.canonical_order('{"json_class":"JsonIntTest","data":["foo"]}' )
+        it "should be able to render an instance to pson" do
+            instance = PsonIntTest.new("foo")
+            PsonIntTest.canonical_order(@pson.render(instance)).should == PsonIntTest.canonical_order('{"type":"PsonIntTest","data":["foo"]}' )
         end
 
-        it "should be able to render arrays to json" do
-            @json.render([1,2]).should == '[1,2]'
+        it "should be able to render arrays to pson" do
+            @pson.render([1,2]).should == '[1,2]'
         end
 
-        it "should be able to render arrays containing hashes to json" do
-            @json.render([{"one"=>1},{"two"=>2}]).should == '[{"one":1},{"two":2}]'
+        it "should be able to render arrays containing hashes to pson" do
+            @pson.render([{"one"=>1},{"two"=>2}]).should == '[{"one":1},{"two":2}]'
         end
 
-        it "should be able to render multiple instances to json" do
-            Puppet.features.add(:json, :libs => ["json"])
+        it "should be able to render multiple instances to pson" do
+            Puppet.features.add(:pson, :libs => ["pson"])
 
-            one = JsonIntTest.new("one")
-            two = JsonIntTest.new("two")
+            one = PsonIntTest.new("one")
+            two = PsonIntTest.new("two")
 
-            JsonIntTest.canonical_order(@json.render([one,two])).should == JsonIntTest.canonical_order('[{"json_class":"JsonIntTest","data":["one"]},{"json_class":"JsonIntTest","data":["two"]}]')
+            PsonIntTest.canonical_order(@pson.render([one,two])).should == PsonIntTest.canonical_order('[{"type":"PsonIntTest","data":["one"]},{"type":"PsonIntTest","data":["two"]}]')
         end
 
-        it "should be able to intern json into an instance" do
-            @json.intern(JsonIntTest, '{"json_class":"JsonIntTest","data":["foo"]}').should == JsonIntTest.new("foo")
+        it "should be able to intern pson into an instance" do
+            @pson.intern(PsonIntTest, '{"type":"PsonIntTest","data":["foo"]}').should == PsonIntTest.new("foo")
         end
 
-        it "should be able to intern json with no class information into an instance" do
-            @json.intern(JsonIntTest, '["foo"]').should == JsonIntTest.new("foo")
+        it "should be able to intern pson with no class information into an instance" do
+            @pson.intern(PsonIntTest, '["foo"]').should == PsonIntTest.new("foo")
         end
 
-        it "should be able to intern multiple instances from json" do
-            @json.intern_multiple(JsonIntTest, '[{"json_class": "JsonIntTest", "data": ["one"]},{"json_class": "JsonIntTest", "data": ["two"]}]').should == [
-                JsonIntTest.new("one"), JsonIntTest.new("two")
+        it "should be able to intern multiple instances from pson" do
+            @pson.intern_multiple(PsonIntTest, '[{"type": "PsonIntTest", "data": ["one"]},{"type": "PsonIntTest", "data": ["two"]}]').should == [
+                PsonIntTest.new("one"), PsonIntTest.new("two")
             ]
         end
 
-        it "should be able to intern multiple instances from json with no class information" do
-            @json.intern_multiple(JsonIntTest, '[["one"],["two"]]').should == [
-                JsonIntTest.new("one"), JsonIntTest.new("two")
+        it "should be able to intern multiple instances from pson with no class information" do
+            @pson.intern_multiple(PsonIntTest, '[["one"],["two"]]').should == [
+                PsonIntTest.new("one"), PsonIntTest.new("two")
             ]
         end
     end