puppet 0.25.0 → 0.25.1

data/lib/puppet/provider/zone/solaris.rb

@@ -156,11 +156,16 @@ Puppet::Type.type(:zone).provide(:solaris) do
     def start
         # Check the sysidcfg stuff
         if cfg = @resource[:sysidcfg]
-            path = File.join(@resource[:path], "root", "etc", "sysidcfg")
+            zoneetc = File.join(@resource[:path], "root", "etc")
+            sysidcfg = File.join(zoneetc, "sysidcfg")
 
-            unless File.exists?(path)
+            # if the zone root isn't present "ready" the zone
+            # which makes zoneadmd mount the zone root
+            zoneadm :ready unless File.directory?(zoneetc)
+
+            unless File.exists?(sysidcfg)
                 begin
-                    File.open(path, "w", 0600) do |f|
+                    File.open(sysidcfg, "w", 0600) do |f|
                         f.puts cfg
                     end
                 rescue => detail
@@ -193,6 +198,10 @@ Puppet::Type.type(:zone).provide(:solaris) do
         main
     end
 
+    def ready
+        zoneadm :ready
+    end
+
     def stop
         zoneadm :halt
     end

data/lib/puppet/relationship.rb

@@ -6,26 +6,26 @@
 # subscriptions are permanent associations determining how different
 # objects react to an event
 
-require 'puppet/util/json'
+require 'puppet/util/pson'
 
 # This is Puppet's class for modeling edges in its configuration graph.
 # It used to be a subclass of GRATR::Edge, but that class has weird hash
 # overrides that dramatically slow down the graphing.
 class Puppet::Relationship
-    extend Puppet::Util::Json
+    extend Puppet::Util::Pson
     attr_accessor :source, :target, :callback
 
     attr_reader :event
 
-    def self.from_json(json)
-        source = json["source"]
-        target = json["target"]
+    def self.from_pson(pson)
+        source = pson["source"]
+        target = pson["target"]
 
         args = {}
-        if event = json["event"]
+        if event = pson["event"]
             args[:event] = event
         end
-        if callback = json["callback"]
+        if callback = pson["callback"]
             args[:callback] = callback
         end
 
@@ -73,7 +73,7 @@ class Puppet::Relationship
         "%s => %s" % [source, target]
     end
 
-    def to_json(*args)
+    def to_pson_data_hash
         data = {
             'source' => source.to_s,
             'target' => target.to_s
@@ -83,11 +83,11 @@ class Puppet::Relationship
             next unless value = send(attr)
             data[attr] = value
         end
+        data
+    end
 
-        {
-            'json_class' => self.class.to_s,
-            'data' => data
-        }.to_json(*args)
+    def to_pson(*args)
+        to_pson_data_hash.to_pson(*args)
     end
 
     def to_s

data/lib/puppet/reports/rrdgraph.rb

@@ -104,7 +104,7 @@ Puppet::Reports.register_report(:rrdgraph) do
         unless File.directory?(hostdir) and FileTest.writable?(hostdir)
             # Some hackishness to create the dir with all of the right modes and ownership
             config = Puppet::Util::Settings.new
-            config.setdefaults(:reports, :hostdir => {:default => hostdir, :owner => Puppet[:user], :mode => 0755, :group => Puppet[:group], :desc => "eh"})
+            config.setdefaults(:reports, :hostdir => {:default => hostdir, :owner => 'service', :mode => 0755, :group => 'service', :desc => "eh"})
 
             # This creates the dir.
             config.use(:reports)

data/lib/puppet/reports/store.rb

@@ -16,8 +16,8 @@ Puppet::Reports.register_report(:store) do
             "client-#{client}-dir" => { :default => dir,
                 :mode => 0750,
                 :desc => "Client dir for %s" % client,
-                :owner => Puppet[:user],
-                :group => Puppet[:group]
+                :owner => 'service',
+                :group => 'service'
             }
         )
 

data/lib/puppet/reports/tagmail.rb

@@ -128,7 +128,6 @@ Puppet::Reports.register_report(:tagmail) do
                 begin
                     Net::SMTP.start(Puppet[:smtpserver]) do |smtp|
                         reports.each do |emails, messages|
-                            Puppet.info "Sending report to %s" % emails.join(", ")
                             smtp.open_message_stream(Puppet[:reportfrom], *emails) do |p|
                               p.puts "From: #{Puppet[:reportfrom]}"
                               p.puts "Subject: Puppet Report for %s" % self.host
@@ -149,16 +148,13 @@ Puppet::Reports.register_report(:tagmail) do
             elsif Puppet[:sendmail] != ""
                 begin
                     reports.each do |emails, messages|
-                        Puppet.info "Sending report to %s" % emails.join(", ")
                         # We need to open a separate process for every set of email addresses
-                        sync.synchronize do
-                            IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
-                                p.puts "From: #{Puppet[:reportfrom]}"
-                                p.puts "Subject: Puppet Report for %s" % self.host
-                                p.puts "To: " + emails.join(", ")
+                        IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
+                            p.puts "From: #{Puppet[:reportfrom]}"
+                            p.puts "Subject: Puppet Report for %s" % self.host
+                            p.puts "To: " + emails.join(", ")
 
-                                p.puts messages
-                            end
+                            p.puts messages
                         end
                     end
                 rescue => detail
@@ -176,12 +172,5 @@ Puppet::Reports.register_report(:tagmail) do
         # Don't bother waiting for the pid to return.
         Process.detach(pid)
     end
-
-    def sync
-        unless defined?(@sync)
-            @sync = Sync.new
-        end
-        @sync
-    end
 end
 

data/lib/puppet/resource.rb

@@ -1,35 +1,35 @@
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/resource/reference'
-require 'puppet/util/json'
+require 'puppet/util/pson'
 
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
 class Puppet::Resource
     include Puppet::Util::Tagging
-    extend Puppet::Util::Json
+    extend Puppet::Util::Pson
     include Enumerable
     attr_accessor :file, :line, :catalog, :exported, :virtual
     attr_writer :type, :title
 
     ATTRIBUTES = [:file, :line, :exported]
 
-    def self.from_json(json)
-        raise ArgumentError, "No resource type provided in json data" unless type = json['type']
-        raise ArgumentError, "No resource title provided in json data" unless title = json['title']
+    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']
 
         resource = new(type, title)
 
-        if params = json['parameters']
+        if params = pson['parameters']
             params.each { |param, value| resource[param] = value }
         end
 
-        if tags = json['tags']
+        if tags = pson['tags']
             tags.each { |tag| resource.tag(tag) }
         end
 
         ATTRIBUTES.each do |a|
-            if value = json[a.to_s]
+            if value = pson[a.to_s]
                 resource.send(a.to_s + "=", value)
             end
         end
@@ -39,9 +39,7 @@ class Puppet::Resource
         resource
     end
 
-    def to_json(*args)
-        raise "Cannot convert to JSON unless the 'json' library is installed" unless Puppet.features.json?
-
+    def to_pson_data_hash
         data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
             next hash unless value = self.send(param)
             hash[param.to_s] = value
@@ -55,20 +53,17 @@ class Puppet::Resource
 
             # Don't duplicate the title as the namevar
             next hash if param == namevar and value == title
-            value = [value] unless value.is_a?(Array)
             hash[param] = value
             hash
         end
 
-        unless params.empty?
-            data["parameters"] = params
-        end
+        data["parameters"] = params unless params.empty?
+
+        data
+    end
 
-        res = {
-            'json_class' => self.class.name,
-            'data' => data
-        }
-        res.to_json(*args)
+    def to_pson(*args)
+        to_pson_data_hash.to_pson(*args)
     end
 
     # Proxy these methods to the parameters hash.  It's likely they'll

data/lib/puppet/resource/catalog.rb

@@ -4,7 +4,7 @@ require 'puppet/simple_graph'
 require 'puppet/transaction'
 
 require 'puppet/util/cacher'
-require 'puppet/util/json'
+require 'puppet/util/pson'
 
 require 'puppet/util/tagging'
 
@@ -19,7 +19,7 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
     indirects :catalog, :terminus_class => :compiler
 
     include Puppet::Util::Tagging
-    extend Puppet::Util::Json
+    extend Puppet::Util::Pson
     include Puppet::Util::Cacher::Expirer
 
     # The host name this is a catalog for.
@@ -46,6 +46,9 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
     # whether it is written back out again.
     attr_accessor :from_cache
 
+    # Some metadata to help us compile and generally respond to the current state.
+    attr_accessor :client_version, :server_version
+
     # Add classes to our class list.
     def add_class(*classes)
         classes.each do |klass|
@@ -390,7 +393,7 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
         @resource_table.keys
     end
 
-    def self.from_json(data)
+    def self.from_pson(data)
         result = new(data['name'])
 
         if tags = data['tags'] 
@@ -402,60 +405,68 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
         end
 
         if resources = data['resources']
-            resources = JSON.parse(resources) if resources.is_a?(String)
+            resources = PSON.parse(resources) if resources.is_a?(String)
             resources.each do |res|
-                resource_from_json(result, res)
+                resource_from_pson(result, res)
             end
         end
 
         if edges = data['edges']
-            edges = JSON.parse(edges) if edges.is_a?(String)
+            edges = PSON.parse(edges) if edges.is_a?(String)
             edges.each do |edge|
-                edge_from_json(result, edge)
+                edge_from_pson(result, edge)
             end
         end
 
+        if classes = data['classes']
+            result.add_class(*classes)
+        end
+
         result
     end
 
-    def self.edge_from_json(result, edge)
-        # If no json_class information was presented, we manually find
+    def self.edge_from_pson(result, edge)
+        # If no type information was presented, we manually find
         # the class.
-        edge = Puppet::Relationship.from_json(edge) if edge.is_a?(Hash)
+        edge = Puppet::Relationship.from_pson(edge) if edge.is_a?(Hash)
         unless source = result.resource(edge.source)
-            raise ArgumentError, "Could not convert from json: Could not find relationship source '%s'" % source
+            raise ArgumentError, "Could not convert from pson: Could not find relationship source '%s'" % source
         end
         edge.source = source
 
         unless target = result.resource(edge.target)
-            raise ArgumentError, "Could not convert from json: Could not find relationship target '%s'" % target
+            raise ArgumentError, "Could not convert from pson: Could not find relationship target '%s'" % target
         end
         edge.target = target
 
         result.add_edge(edge)
     end
 
-    def self.resource_from_json(result, res)
-        # If no json_class information was presented, we manually find
-        # the class.
-        if res.is_a?(Hash)
-            res = res['data'] if res['json_class']
-            res = Puppet::Resource.from_json(res)
-        end
+    def self.resource_from_pson(result, res)
+        res = Puppet::Resource.from_pson(res) if res.is_a? Hash
         result.add_resource(res)
     end
 
-    def to_json(*args)
+    PSON.register_document_type('Catalog',self)
+    def to_pson_data_hash
         {
-            'json_class' => 'Puppet::Resource::Catalog',
-            'data' => {
-                'tags' => tags,
-                'name' => name,
-                'version' => version,
-                'resources' => vertices.to_json(*args),
-                'edges' => edges.to_json(*args)
-            }
-        }.to_json(*args)
+            'document_type' => 'Catalog',
+            'data'       => {
+                'tags'      => tags,
+                'name'      => name,
+                'version'   => version,
+                'resources' => vertices.collect { |v| v.to_pson_data_hash },
+                'edges'     => edges.   collect { |e| e.to_pson_data_hash },
+                'classes'   => classes
+                },
+            'metadata' => {
+                'api_version' => 1
+                }
+       }
+    end
+
+    def to_pson(*args)
+       to_pson_data_hash.to_pson(*args)
     end
 
     # Convert our catalog into a RAL catalog.

data/lib/puppet/ssl/certificate_revocation_list.rb

@@ -46,8 +46,6 @@ class Puppet::SSL::CertificateRevocationList < Puppet::SSL::Base
     # The name doesn't actually matter; there's only one CRL.
     # We just need the name so our Indirector stuff all works more easily.
     def initialize(fakename)
-        raise Puppet::Error, "Cannot manage the CRL when :cacrl is set to false" if [false, "false"].include?(Puppet[:cacrl])
-
         @name = "crl"
     end
 

data/lib/puppet/ssl/host.rb

@@ -235,12 +235,11 @@ class Puppet::SSL::Host
 
     # Attempt to retrieve a cert, if we don't already have one.
     def wait_for_cert(time)
-        return if certificate
         begin
+            return if certificate
             generate
-
             return if certificate
-        rescue StandardError => detail
+        rescue Exception => detail
             Puppet.err "Could not request certificate: %s" % detail.to_s
             if time < 1
                 puts "Exiting; failed to retrieve certificate and watiforcert is disabled"

data/lib/puppet/sslcertificates/ca.rb

@@ -194,9 +194,6 @@ class Puppet::SSLCertificates::CA
     # Revoke the certificate with serial number SERIAL issued by this
     # CA. The REASON must be one of the OpenSSL::OCSP::REVOKED_* reasons
     def revoke(serial, reason = OpenSSL::OCSP::REVOKED_STATUS_KEYCOMPROMISE)
-        if @config[:cacrl] == 'false'
-            raise Puppet::Error, "Revocation requires a CRL, but ca_crl is set to 'false'"
-        end
         time = Time.now
         revoked = OpenSSL::X509::Revoked.new
         revoked.serial = serial
@@ -344,8 +341,6 @@ class Puppet::SSLCertificates::CA
             @crl = OpenSSL::X509::CRL.new(
                 File.read(@config[:cacrl])
             )
-        elsif @config[:cacrl] == 'false'
-            @crl = nil
         else
             # Create new CRL
             @crl = OpenSSL::X509::CRL.new

data/lib/puppet/type/cron.rb

@@ -312,7 +312,7 @@ Puppet::Type.newtype(:cron) do
             the crontab, e.g., ``PATH=/bin:/usr/bin:/usr/sbin``."
 
         validate do |value|
-            unless value =~ /^\s*(\w+)\s*=\s*(.+)\s*$/ or value == :absent or value == "absent"
+            unless value =~ /^\s*(\w+)\s*=\s*(.*)\s*$/ or value == :absent or value == "absent"
                 raise ArgumentError, "Invalid environment setting %s" %
                     value.inspect
             end

data/lib/puppet/type/file/owner.rb

@@ -28,10 +28,7 @@ module Puppet
         end
 
         def insync?(current)
-            unless Puppet::Util::SUIDManager.uid == 0
-                warning "Cannot manage ownership unless running as root"
-                return true
-            end
+            return true unless should
 
             @should.each do |value|
                 if value =~ /^\d+$/
@@ -44,6 +41,12 @@ module Puppet
 
                 return true if uid == current
             end
+
+            unless Puppet::Util::SUIDManager.uid == 0
+                warnonce "Cannot manage ownership unless running as root"
+                return true
+            end
+
             return false
         end
 

data/lib/puppet/type/resources.rb

@@ -85,33 +85,33 @@ Puppet::Type.newtype(:resources) do
         end
     end
 
+    def able_to_ensure_absent?(resource)
+        begin
+            resource[:ensure] = :absent
+        rescue ArgumentError, Puppet::Error => detail
+            err "The 'ensure' attribute on #{self[:name]} resources does not accept 'absent' as a value"
+            false
+        end
+    end
+
     # Generate any new resources we need to manage.  This is pretty hackish
     # right now, because it only supports purging.
     def generate
         return [] unless self.purge?
-        hascheck = false
-        method =
-        resource_type.instances.find_all do |resource|
-            ! resource.managed?
-        end.find_all do |resource|
-            check(resource)
-        end.each do |resource|
-            begin
-                resource[:ensure] = :absent
-            rescue ArgumentError, Puppet::Error => detail
-                err "The 'ensure' attribute on %s resources does not accept 'absent' as a value" %
-                    [self[:name]]
-                return []
-            end
+        resource_type.instances.
+          reject { |r| managed? }.
+          reject { |r| catalog.resources.include? r.ref }.
+          select { |r| check(r) }.
+          select { |r| able_to_ensure_absent?(r) }.
+          each { |resource|
             @parameters.each do |name, param|
-                next unless param.metaparam?
-                resource[name] = param.value
+                resource[name] = param.value if param.metaparam?
             end
 
             # Mark that we're purging, so transactions can handle relationships
             # correctly
             resource.purging
-        end
+          }
     end
 
     def resource_type