puppet 0.25.5 → 2.6.0

data/lib/puppet/network/formats.rb

@@ -1,188 +1,162 @@
 require 'puppet/network/format_handler'
 
 Puppet::Network::FormatHandler.create(:yaml, :mime => "text/yaml") do
-    # Yaml doesn't need the class name; it's serialized.
-    def intern(klass, text)
-        YAML.load(text)
-    end
-
-    # Yaml doesn't need the class name; it's serialized.
-    def intern_multiple(klass, text)
-        YAML.load(text)
-    end
-
-    def render(instance)
-        yaml = instance.to_yaml
-
-        yaml = fixup(yaml) unless yaml.nil?
-        yaml
-    end
-
-    # Yaml monkey-patches Array, so this works.
-    def render_multiple(instances)
-        yaml = instances.to_yaml
-
-        yaml = fixup(yaml) unless yaml.nil?
-        yaml
-    end
-
-    # Everything's supported unless you're on 1.8.1
-    def supported?(klass)
-        RUBY_VERSION != '1.8.1'
-    end
-
-    # fixup invalid yaml as per:
-    # http://redmine.ruby-lang.org/issues/show/1331
-    def fixup(yaml)
-        yaml.gsub!(/((?:&id\d+\s+)?!ruby\/object:.*?)\s*\?/) { "? #{$1}" }
-        yaml
-    end
+  # Yaml doesn't need the class name; it's serialized.
+  def intern(klass, text)
+    YAML.load(text)
+  end
+
+  # Yaml doesn't need the class name; it's serialized.
+  def intern_multiple(klass, text)
+    YAML.load(text)
+  end
+
+  def render(instance)
+    instance.to_yaml
+  end
+
+  # Yaml monkey-patches Array, so this works.
+  def render_multiple(instances)
+    instances.to_yaml
+  end
+
+  # Unlike core's yaml, ZAML should support 1.8.1 just fine
+  def supported?(klass)
+    true
+  end
 end
 
 # This is a "special" format which is used for the moment only when sending facts
 # as REST GET parameters (see Puppet::Configurer::FactHandler).
 # This format combines a yaml serialization, then zlib compression and base64 encoding.
 Puppet::Network::FormatHandler.create(:b64_zlib_yaml, :mime => "text/b64_zlib_yaml") do
-    require 'base64'
-
-    def use_zlib?
-        Puppet.features.zlib? && Puppet[:zlib]
-    end
+  require 'base64'
 
-    def requiring_zlib
-        if use_zlib?
-            yield
-        else
-            raise Puppet::Error, "the zlib library is not installed or is disabled."
-        end
-    end
+  def use_zlib?
+    Puppet.features.zlib? && Puppet[:zlib]
+  end
 
-    def intern(klass, text)
-        decode(text)
+  def requiring_zlib
+    if use_zlib?
+      yield
+    else
+      raise Puppet::Error, "the zlib library is not installed or is disabled."
     end
+  end
 
-    def intern_multiple(klass, text)
-        decode(text)
-    end
+  def intern(klass, text)
+    decode(text)
+  end
 
-    def render(instance)
-        yaml = instance.to_yaml
+  def intern_multiple(klass, text)
+    decode(text)
+  end
 
-        yaml = encode(fixup(yaml)) unless yaml.nil?
-        yaml
-    end
+  def render(instance)
+    encode(instance.to_yaml)
+  end
 
-    def render_multiple(instances)
-        yaml = instances.to_yaml
+  def render_multiple(instances)
+    encode(instances.to_yaml)
+  end
 
-        yaml = encode(fixup(yaml)) unless yaml.nil?
-        yaml
-    end
-
-    # Because of yaml issue in ruby 1.8.1...
-    def supported?(klass)
-        RUBY_VERSION != '1.8.1' and use_zlib?
-    end
-
-    # fixup invalid yaml as per:
-    # http://redmine.ruby-lang.org/issues/show/1331
-    def fixup(yaml)
-        yaml.gsub!(/((?:&id\d+\s+)?!ruby\/object:.*?)\s*\?/) { "? #{$1}" }
-        yaml
-    end
+  def supported?(klass)
+    true
+  end
 
-    def encode(text)
-        requiring_zlib do 
-            Base64.encode64(Zlib::Deflate.deflate(text, Zlib::BEST_COMPRESSION))
-        end
+  def encode(text)
+    requiring_zlib do
+      Base64.encode64(Zlib::Deflate.deflate(text, Zlib::BEST_COMPRESSION))
     end
+  end
 
-    def decode(yaml)
-        requiring_zlib do 
-            YAML.load(Zlib::Inflate.inflate(Base64.decode64(yaml)))
-        end
+  def decode(yaml)
+    requiring_zlib do
+      YAML.load(Zlib::Inflate.inflate(Base64.decode64(yaml)))
     end
+  end
 end
 
 
 Puppet::Network::FormatHandler.create(:marshal, :mime => "text/marshal") do
-    # Marshal doesn't need the class name; it's serialized.
-    def intern(klass, text)
-        Marshal.load(text)
-    end
-
-    # Marshal doesn't need the class name; it's serialized.
-    def intern_multiple(klass, text)
-        Marshal.load(text)
-    end
-
-    def render(instance)
-        Marshal.dump(instance)
-    end
-
-    # Marshal monkey-patches Array, so this works.
-    def render_multiple(instances)
-        Marshal.dump(instances)
-    end
-
-    # Everything's supported
-    def supported?(klass)
-        true
-    end
+  # Marshal doesn't need the class name; it's serialized.
+  def intern(klass, text)
+    Marshal.load(text)
+  end
+
+  # Marshal doesn't need the class name; it's serialized.
+  def intern_multiple(klass, text)
+    Marshal.load(text)
+  end
+
+  def render(instance)
+    Marshal.dump(instance)
+  end
+
+  # Marshal monkey-patches Array, so this works.
+  def render_multiple(instances)
+    Marshal.dump(instances)
+  end
+
+  # Everything's supported
+  def supported?(klass)
+    true
+  end
 end
 
-Puppet::Network::FormatHandler.create(:s, :mime => "text/plain")
+Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :extension => "txt")
 
 # A very low-weight format so it'll never get chosen automatically.
 Puppet::Network::FormatHandler.create(:raw, :mime => "application/x-raw", :weight => 1) do
-    def intern_multiple(klass, text)
-        raise NotImplementedError
-    end
-
-    def render_multiple(instances)
-        raise NotImplementedError
-    end
-
-    # LAK:NOTE The format system isn't currently flexible enough to handle
-    # what I need to support raw formats just for individual instances (rather
-    # than both individual and collections), but we don't yet have enough data
-    # to make a "correct" design.
-    #   So, we hack it so it works for singular but fail if someone tries it
-    # on plurals.
-    def supported?(klass)
-        true
-    end
+  def intern_multiple(klass, text)
+    raise NotImplementedError
+  end
+
+  def render_multiple(instances)
+    raise NotImplementedError
+  end
+
+  # LAK:NOTE The format system isn't currently flexible enough to handle
+  # what I need to support raw formats just for individual instances (rather
+  # than both individual and collections), but we don't yet have enough data
+  # to make a "correct" design.
+  #   So, we hack it so it works for singular but fail if someone tries it
+  # on plurals.
+  def supported?(klass)
+    true
+  end
 end
 
 Puppet::Network::FormatHandler.create(:pson, :mime => "text/pson", :weight => 10, :required_methods => [:render_method, :intern_method]) do
-    confine :true => Puppet.features.pson?
-
-    def intern(klass, text)
-        data_to_instance(klass, PSON.parse(text))
-    end
-
-    def intern_multiple(klass, text)
-        PSON.parse(text).collect do |data|
-            data_to_instance(klass, data)
-        end
-    end
-
-    # PSON monkey-patches Array, so this works.
-    def render_multiple(instances)
-        instances.to_pson
-    end
-
-    # If they pass class information, we want to ignore it.  By default,
-    # we'll include class information but we won't rely on it - we don't
-    # want class names to be required because we then can't change our
-    # internal class names, which is bad.
-    def data_to_instance(klass, data)
-        if data.is_a?(Hash) and d = data['data']
-            data = d
-        end
-        if data.is_a?(klass)
-            return data
-        end
-        klass.from_pson(data)
-    end
+  confine :true => Puppet.features.pson?
+
+  def intern(klass, text)
+    data_to_instance(klass, PSON.parse(text))
+  end
+
+  def intern_multiple(klass, text)
+    PSON.parse(text).collect do |data|
+      data_to_instance(klass, data)
+    end
+  end
+
+  # PSON monkey-patches Array, so this works.
+  def render_multiple(instances)
+    instances.to_pson
+  end
+
+  # If they pass class information, we want to ignore it.  By default,
+  # we'll include class information but we won't rely on it - we don't
+  # want class names to be required because we then can't change our
+  # internal class names, which is bad.
+  def data_to_instance(klass, data)
+    if data.is_a?(Hash) and d = data['data']
+      data = d
+    end
+    return data if data.is_a?(klass)
+    klass.from_pson(data)
+  end
 end
+
+# This is really only ever going to be used for Catalogs.
+Puppet::Network::FormatHandler.create(:dot, :mime => "text/dot", :required_methods => [:render_method])

data/lib/puppet/network/handler.rb

@@ -2,52 +2,49 @@ require 'puppet/util/docs'
 require 'puppet/util/subclass_loader'
 
 module Puppet::Network
-    # The base class for the different handlers.  The handlers are each responsible
-    # for separate xmlrpc namespaces.
-    class Handler
-        extend Puppet::Util::Docs
-
-        # This is so that the handlers can subclass just 'Handler', rather
-        # then having to specify the full class path.
-        Handler = self
-        attr_accessor :server, :local
-
-        extend Puppet::Util::SubclassLoader
-        extend Puppet::Util
-
-        handle_subclasses :handler, "puppet/network/handler"
-
-        # Return the xmlrpc interface.
-        def self.interface
-            if defined? @interface
-                return @interface
-            else
-                raise Puppet::DevError, "Handler %s has no defined interface" %
-                    self
-            end
-        end
-
-        # Set/Determine whether we're a client- or server-side handler.
-        def self.side(side = nil)
-            if side
-                side = side.intern if side.is_a?(String)
-                unless [:client, :server].include?(side)
-                    raise ArgumentError, "Invalid side registration '%s' for %s" % [side, self.name]
-                end
-                @side = side
-            else
-                @side ||= :server
-                return @side
-            end
-        end
-
-        # Create an empty init method with the same signature.
-        def initialize(hash = {})
-        end
-
-        def local?
-            self.local
-        end
+  # The base class for the different handlers.  The handlers are each responsible
+  # for separate xmlrpc namespaces.
+  class Handler
+    extend Puppet::Util::Docs
+
+    # This is so that the handlers can subclass just 'Handler', rather
+    # then having to specify the full class path.
+    Handler = self
+    attr_accessor :server, :local
+
+    extend Puppet::Util::SubclassLoader
+    extend Puppet::Util
+
+    handle_subclasses :handler, "puppet/network/handler"
+
+    # Return the xmlrpc interface.
+    def self.interface
+      if defined?(@interface)
+        return @interface
+      else
+        raise Puppet::DevError, "Handler #{self} has no defined interface"
+      end
     end
+
+    # Set/Determine whether we're a client- or server-side handler.
+    def self.side(side = nil)
+      if side
+        side = side.intern if side.is_a?(String)
+        raise ArgumentError, "Invalid side registration '#{side}' for #{self.name}" unless [:client, :server].include?(side)
+        @side = side
+      else
+        @side ||= :server
+        return @side
+      end
+    end
+
+    # Create an empty init method with the same signature.
+    def initialize(hash = {})
+    end
+
+    def local?
+      self.local
+    end
+  end
 end
 

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

@@ -7,151 +7,145 @@ require 'xmlrpc/server'
 #   http://segment7.net/projects/ruby/QuickCert/
 
 class Puppet::Network::Handler
-    class CA < Handler
-        attr_reader :ca
-
-        desc "Provides an interface for signing CSRs.  Accepts a CSR and returns
-        the CA certificate and the signed certificate, or returns nil if
-        the cert is not signed."
+  class CA < Handler
+    attr_reader :ca
+
+    desc "Provides an interface for signing CSRs.  Accepts a CSR and returns
+    the CA certificate and the signed certificate, or returns nil if
+    the cert is not signed."
+
+    @interface = XMLRPC::Service::Interface.new("puppetca") { |iface|
+      iface.add_method("array getcert(csr)")
+    }
+
+    def autosign
+      if defined?(@autosign)
+        @autosign
+      else
+        Puppet[:autosign]
+      end
+    end
 
-        @interface = XMLRPC::Service::Interface.new("puppetca") { |iface|
-            iface.add_method("array getcert(csr)")
+    # FIXME autosign? should probably accept both hostnames and IP addresses
+    def autosign?(hostname)
+      # simple values are easy
+      if autosign == true or autosign == false
+        return autosign
+      end
+
+      # we only otherwise know how to handle files
+      unless autosign =~ /^\//
+        raise Puppet::Error, "Invalid autosign value #{autosign.inspect}"
+      end
+
+      unless FileTest.exists?(autosign)
+        unless defined?(@@warnedonautosign)
+          @@warnedonautosign = true
+          Puppet.info "Autosign is enabled but #{autosign} is missing"
+        end
+        return false
+      end
+      auth = Puppet::Network::AuthStore.new
+      File.open(autosign) { |f|
+        f.each { |line|
+          next if line =~ /^\s*#/
+          next if line =~ /^\s*$/
+          auth.allow(line.chomp)
         }
+      }
 
-        def autosign
-            if defined? @autosign
-                @autosign
-            else
-                Puppet[:autosign]
-            end
-        end
+      # for now, just cheat and pass a fake IP address to allowed?
+      auth.allowed?(hostname, "127.1.1.1")
+    end
 
-        # FIXME autosign? should probably accept both hostnames and IP addresses
-        def autosign?(hostname)
-            # simple values are easy
-            if autosign == true or autosign == false
-                return autosign
-            end
-
-            # we only otherwise know how to handle files
-            unless autosign =~ /^\//
-                raise Puppet::Error, "Invalid autosign value %s" %
-                    autosign.inspect
-            end
-
-            unless FileTest.exists?(autosign)
-                unless defined? @@warnedonautosign
-                    @@warnedonautosign = true
-                    Puppet.info "Autosign is enabled but %s is missing" % autosign
-                end
-                return false
-            end
-            auth = Puppet::Network::AuthStore.new
-            File.open(autosign) { |f|
-                f.each { |line|
-                    next if line =~ /^\s*#/
-                    next if line =~ /^\s*$/
-                    auth.allow(line.chomp)
-                }
-            }
-
-            # for now, just cheat and pass a fake IP address to allowed?
-            return auth.allowed?(hostname, "127.1.1.1")
-        end
+    def initialize(hash = {})
+      Puppet.settings.use(:main, :ssl, :ca)
+      @autosign = hash[:autosign] if hash.include? :autosign
 
-        def initialize(hash = {})
-            Puppet.settings.use(:main, :ssl, :ca)
-            if hash.include? :autosign
-                @autosign = hash[:autosign]
-            end
+      @ca = Puppet::SSLCertificates::CA.new(hash)
+    end
 
-            @ca = Puppet::SSLCertificates::CA.new(hash)
-        end
+    # our client sends us a csr, and we either store it for later signing,
+    # or we sign it right away
+    def getcert(csrtext, client = nil, clientip = nil)
+      csr = OpenSSL::X509::Request.new(csrtext)
+
+      # Use the hostname from the CSR, not from the network.
+      subject = csr.subject
+
+      nameary = subject.to_a.find { |ary|
+        ary[0] == "CN"
+      }
 
-        # our client sends us a csr, and we either store it for later signing,
-        # or we sign it right away
-        def getcert(csrtext, client = nil, clientip = nil)
-            csr = OpenSSL::X509::Request.new(csrtext)
-
-            # Use the hostname from the CSR, not from the network.
-            subject = csr.subject
-
-            nameary = subject.to_a.find { |ary|
-                ary[0] == "CN"
-            }
-
-            if nameary.nil?
-                Puppet.err(
-                    "Invalid certificate request: could not retrieve server name"
-                )
-                return "invalid"
-            end
-
-            hostname = nameary[1]
-
-            unless @ca
-                Puppet.notice "Host %s asked for signing from non-CA master" % hostname
-                return ""
-            end
-
-            # We used to save the public key, but it's basically unnecessary
-            # and it mucks with the permissions requirements.
-            # save_pk(hostname, csr.public_key)
-
-            certfile = File.join(Puppet[:certdir], [hostname, "pem"].join("."))
-
-            # first check to see if we already have a signed cert for the host
-            cert, cacert = ca.getclientcert(hostname)
-            if cert and cacert
-                Puppet.info "Retrieving existing certificate for %s" % hostname
-                unless csr.public_key.to_s == cert.public_key.to_s
-                    raise Puppet::Error, "Certificate request does not match existing certificate; run 'puppetca --clean %s'." % hostname
-                end
-                return [cert.to_pem, cacert.to_pem]
-            elsif @ca
-                if self.autosign?(hostname) or client.nil?
-                    if client.nil?
-                        Puppet.info "Signing certificate for CA server"
-                    end
-                    # okay, we don't have a signed cert
-                    # if we're a CA and autosign is turned on, then go ahead and sign
-                    # the csr and return the results
-                    Puppet.info "Signing certificate for %s" % hostname
-                    cert, cacert = @ca.sign(csr)
-                    #Puppet.info "Cert: %s; Cacert: %s" % [cert.class, cacert.class]
-                    return [cert.to_pem, cacert.to_pem]
-                else # just write out the csr for later signing
-                    if @ca.getclientcsr(hostname)
-                        Puppet.info "Not replacing existing request from %s" % hostname
-                    else
-                        Puppet.notice "Host %s has a waiting certificate request" %
-                            hostname
-                        @ca.storeclientcsr(csr)
-                    end
-                    return ["", ""]
-                end
-            else
-                raise "huh?"
-            end
+      if nameary.nil?
+        Puppet.err(
+          "Invalid certificate request: could not retrieve server name"
+        )
+        return "invalid"
+      end
+
+      hostname = nameary[1]
+
+      unless @ca
+        Puppet.notice "Host #{hostname} asked for signing from non-CA master"
+        return ""
+      end
+
+      # We used to save the public key, but it's basically unnecessary
+      # and it mucks with the permissions requirements.
+      # save_pk(hostname, csr.public_key)
+
+      certfile = File.join(Puppet[:certdir], [hostname, "pem"].join("."))
+
+      # first check to see if we already have a signed cert for the host
+      cert, cacert = ca.getclientcert(hostname)
+      if cert and cacert
+        Puppet.info "Retrieving existing certificate for #{hostname}"
+        unless csr.public_key.to_s == cert.public_key.to_s
+          raise Puppet::Error, "Certificate request does not match existing certificate; run 'puppetca --clean #{hostname}'."
         end
+        return [cert.to_pem, cacert.to_pem]
+      elsif @ca
+        if self.autosign?(hostname) or client.nil?
+          Puppet.info "Signing certificate for CA server" if client.nil?
+          # okay, we don't have a signed cert
+          # if we're a CA and autosign is turned on, then go ahead and sign
+          # the csr and return the results
+          Puppet.info "Signing certificate for #{hostname}"
+          cert, cacert = @ca.sign(csr)
+          #Puppet.info "Cert: #{cert.class}; Cacert: #{cacert.class}"
+          return [cert.to_pem, cacert.to_pem]
+        else # just write out the csr for later signing
+          if @ca.getclientcsr(hostname)
+            Puppet.info "Not replacing existing request from #{hostname}"
+          else
+            Puppet.notice "Host #{hostname} has a waiting certificate request"
+            @ca.storeclientcsr(csr)
+          end
+          return ["", ""]
+        end
+      else
+        raise "huh?"
+      end
+    end
+
+    private
 
-        private
-
-        # Save the public key.
-        def save_pk(hostname, public_key)
-            pkeyfile = File.join(Puppet[:publickeydir], [hostname, "pem"].join('.'))
-
-            if FileTest.exists?(pkeyfile)
-                currentkey = File.open(pkeyfile) { |k| k.read }
-                unless currentkey == public_key.to_s
-                    raise Puppet::Error, "public keys for %s differ" % hostname
-                end
-            else
-                File.open(pkeyfile, "w", 0644) { |f|
-                    f.print public_key.to_s
-                }
-            end
+    # Save the public key.
+    def save_pk(hostname, public_key)
+      pkeyfile = File.join(Puppet[:publickeydir], [hostname, "pem"].join('.'))
+
+      if FileTest.exists?(pkeyfile)
+        currentkey = File.open(pkeyfile) { |k| k.read }
+        unless currentkey == public_key.to_s
+          raise Puppet::Error, "public keys for #{hostname} differ"
         end
+      else
+        File.open(pkeyfile, "w", 0644) { |f|
+          f.print public_key.to_s
+        }
+      end
     end
+  end
 end