puppet 0.25.5 → 2.6.0

data/lib/puppet/network/xmlrpc/processor.rb

@@ -3,88 +3,84 @@ require 'xmlrpc/server'
 
 # Just silly.
 class ::XMLRPC::FaultException
-    def to_s
-        self.message
-    end
+  def to_s
+    self.message
+  end
 end
 
 module Puppet::Network
-    # Most of our subclassing is just so that we can get
-    # access to information from the request object, like
-    # the client name and IP address.
-    module XMLRPCProcessor
-        include Puppet::Network::Authorization
+  # Most of our subclassing is just so that we can get
+  # access to information from the request object, like
+  # the client name and IP address.
+  module XMLRPCProcessor
+    include Puppet::Network::Authorization
 
-        ERR_UNAUTHORIZED = 30
+    ERR_UNAUTHORIZED = 30
 
-        def add_handler(interface, handler)
-            @loadedhandlers << interface.prefix
-            super(interface, handler)
-        end
+    def add_handler(interface, handler)
+      @loadedhandlers << interface.prefix
+      super(interface, handler)
+    end
 
-        def handler_loaded?(handler)
-            @loadedhandlers.include?(handler.to_s)
-        end
+    def handler_loaded?(handler)
+      @loadedhandlers.include?(handler.to_s)
+    end
 
-        # Convert our data and client request into xmlrpc calls, and verify
-        # they're authorized and such-like.  This method differs from the
-        # default in that it expects a ClientRequest object in addition to the
-        # data.
-        def process(data, request)
-            call, params = parser().parseMethodCall(data)
-            params << request.name << request.ip
-            handler, method = call.split(".")
-            request.handler = handler
-            request.method = method
-            begin
-                verify(request)
-            rescue InvalidClientRequest => detail
-                raise ::XMLRPC::FaultException.new(ERR_UNAUTHORIZED, detail.to_s)
-            end
-            handle(request.call, *params)
-        end
+    # Convert our data and client request into xmlrpc calls, and verify
+    # they're authorized and such-like.  This method differs from the
+    # default in that it expects a ClientRequest object in addition to the
+    # data.
+    def process(data, request)
+      call, params = parser.parseMethodCall(data)
+      params << request.name << request.ip
+      handler, method = call.split(".")
+      request.handler = handler
+      request.method = method
+      begin
+        verify(request)
+      rescue InvalidClientRequest => detail
+        raise ::XMLRPC::FaultException.new(ERR_UNAUTHORIZED, detail.to_s)
+      end
+      handle(request.call, *params)
+    end
 
-        private
+    private
 
-        # Provide error handling for method calls.
-        def protect_service(obj, *args)
-            begin
-                obj.call(*args)
-            rescue ::XMLRPC::FaultException
-                raise
-            rescue Puppet::AuthorizationError => detail
-                Puppet.err "Permission denied: %s" % detail.to_s
-                raise ::XMLRPC::FaultException.new(
-                    1, detail.to_s
-                )
-            rescue Puppet::Error => detail
-                if Puppet[:trace]
-                    puts detail.backtrace
-                end
-                Puppet.err detail.to_s
-                error = ::XMLRPC::FaultException.new(
-                    1, detail.to_s
-                )
-                error.set_backtrace detail.backtrace
-                raise error
-            rescue => detail
-                if Puppet[:trace]
-                    puts detail.backtrace
-                end
-                Puppet.err "Could not call: %s" % detail.to_s
-                error = ::XMLRPC::FaultException.new(1, detail.to_s)
-                error.set_backtrace detail.backtrace
-                raise error
-            end
-        end
+    # Provide error handling for method calls.
+    def protect_service(obj, *args)
+      begin
+        obj.call(*args)
+      rescue ::XMLRPC::FaultException
+        raise
+      rescue Puppet::AuthorizationError => detail
+        Puppet.err "Permission denied: #{detail}"
+        raise ::XMLRPC::FaultException.new(
+          1, detail.to_s
+        )
+      rescue Puppet::Error => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err detail.to_s
+        error = ::XMLRPC::FaultException.new(
+          1, detail.to_s
+        )
+        error.set_backtrace detail.backtrace
+        raise error
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err "Could not call: #{detail}"
+        error = ::XMLRPC::FaultException.new(1, detail.to_s)
+        error.set_backtrace detail.backtrace
+        raise error
+      end
+    end
 
-        # Set up our service hook and init our handler list.
-        def setup_processor
-            @loadedhandlers = []
-            self.set_service_hook do |obj, *args|
-                protect_service(obj, *args)
-            end
-        end
+    # Set up our service hook and init our handler list.
+    def setup_processor
+      @loadedhandlers = []
+      self.set_service_hook do |obj, *args|
+        protect_service(obj, *args)
+      end
     end
+  end
 end
 

data/lib/puppet/network/xmlrpc/server.rb

@@ -3,17 +3,17 @@ require 'puppet/network/authorization'
 require 'puppet/network/xmlrpc/processor'
 
 module Puppet::Network
-    # Most of our subclassing is just so that we can get
-    # access to information from the request object, like
-    # the client name and IP address.
-    class XMLRPCServer < ::XMLRPC::BasicServer
-        include Puppet::Util
-        include Puppet::Network::XMLRPCProcessor
+  # Most of our subclassing is just so that we can get
+  # access to information from the request object, like
+  # the client name and IP address.
+  class XMLRPCServer < ::XMLRPC::BasicServer
+    include Puppet::Util
+    include Puppet::Network::XMLRPCProcessor
 
-        def initialize
-            super()
-            setup_processor()
-        end
+    def initialize
+      super()
+      setup_processor
     end
+  end
 end
 

data/lib/puppet/network/xmlrpc/webrick_servlet.rb

@@ -3,118 +3,112 @@ require 'puppet/network/authorization'
 require 'puppet/network/xmlrpc/processor'
 
 module Puppet::Network::XMLRPC
-    class ServletError < RuntimeError; end
-    class WEBrickServlet < ::XMLRPC::WEBrickServlet
-        include Puppet::Network::XMLRPCProcessor
-
-        # This is a hackish way to avoid an auth message every time we have a
-        # normal operation
-        def self.log(msg)
-            unless defined? @logs
-                @logs = {}
-            end
-            if @logs.include?(msg)
-                @logs[msg] += 1
-            else
-                Puppet.info msg
-                @logs[msg] = 1
-            end
-        end
+  class ServletError < RuntimeError; end
+  class WEBrickServlet < ::XMLRPC::WEBrickServlet
+    include Puppet::Network::XMLRPCProcessor
+
+    # This is a hackish way to avoid an auth message every time we have a
+    # normal operation
+    def self.log(msg)
+      @logs ||= {}
+      if @logs.include?(msg)
+        @logs[msg] += 1
+      else
+        Puppet.info msg
+        @logs[msg] = 1
+      end
+    end
 
-        # Accept a list of handlers and register them all.
-        def initialize(handlers)
-            # the servlet base class does not consume any arguments
-            # and its BasicServer base class only accepts a 'class_delim'
-            # option which won't change in Puppet at all
-            # thus, we don't need to pass any args to our base class,
-            # and we can consume them all ourselves
-            super()
-
-            setup_processor()
-
-            # Set up each of the passed handlers.
-            handlers.each do |handler|
-                add_handler(handler.class.interface, handler)
-            end
-        end
+    # Accept a list of handlers and register them all.
+    def initialize(handlers)
+      # the servlet base class does not consume any arguments
+      # and its BasicServer base class only accepts a 'class_delim'
+      # option which won't change in Puppet at all
+      # thus, we don't need to pass any args to our base class,
+      # and we can consume them all ourselves
+      super()
+
+      setup_processor
+
+      # Set up each of the passed handlers.
+      handlers.each do |handler|
+        add_handler(handler.class.interface, handler)
+      end
+    end
 
-        # Handle the actual request.  We can't use the super() method, because
-        # we need to pass a ClientRequest object to process() so we can do
-        # authorization.  It's the only way to stay thread-safe.
-        def service(request, response)
-            if @valid_ip
-                raise WEBrick::HTTPStatus::Forbidden unless @valid_ip.any? { |ip| request.peeraddr[3] =~ ip }
-            end
+    # Handle the actual request.  We can't use the super() method, because
+    # we need to pass a ClientRequest object to process so we can do
+    # authorization.  It's the only way to stay thread-safe.
+    def service(request, response)
+      if @valid_ip
+        raise WEBrick::HTTPStatus::Forbidden unless @valid_ip.any? { |ip| request.peeraddr[3] =~ ip }
+      end
 
-            if request.request_method != "POST"
-                raise WEBrick::HTTPStatus::MethodNotAllowed,
-                    "unsupported method `#{request.request_method}'."
-            end
+      if request.request_method != "POST"
+        raise WEBrick::HTTPStatus::MethodNotAllowed,
+          "unsupported method `#{request.request_method}'."
+      end
 
-            if parse_content_type(request['Content-type']).first != "text/xml"
-                raise WEBrick::HTTPStatus::BadRequest
-            end
+      raise WEBrick::HTTPStatus::BadRequest if parse_content_type(request['Content-type']).first != "text/xml"
 
-            length = (request['Content-length'] || 0).to_i
+      length = (request['Content-length'] || 0).to_i
 
-            raise WEBrick::HTTPStatus::LengthRequired unless length > 0
+      raise WEBrick::HTTPStatus::LengthRequired unless length > 0
 
-            data = request.body
+      data = request.body
 
-            if data.nil? or data.size != length
-                raise WEBrick::HTTPStatus::BadRequest
-            end
+      raise WEBrick::HTTPStatus::BadRequest if data.nil? or data.size != length
 
-            resp = process(data, client_request(request))
-            if resp.nil? or resp.size <= 0
-                raise WEBrick::HTTPStatus::InternalServerError
-            end
+      resp = process(data, client_request(request))
+      raise WEBrick::HTTPStatus::InternalServerError if resp.nil? or resp.size <= 0
 
-            response.status = 200
-            response['Content-Length'] = resp.size
-            response['Content-Type']   = "text/xml; charset=utf-8"
-            response.body = resp
-        end
+      response.status = 200
+      response['Content-Length'] = resp.size
+      response['Content-Type']   = "text/xml; charset=utf-8"
+      response.body = resp
+    end
 
-        private
-
-        # Generate a ClientRequest object for later validation.
-        def client_request(request)
-            if peer = request.peeraddr
-                client = peer[2]
-                clientip = peer[3]
-            else
-                raise ::XMLRPC::FaultException.new(
-                    ERR_UNCAUGHT_EXCEPTION,
-                    "Could not retrieve client information"
-                )
-            end
-
-            # If they have a certificate (which will almost always be true)
-            # then we get the hostname from the cert, instead of via IP
-            # info
-            valid = false
-            if cert = request.client_cert
-                nameary = cert.subject.to_a.find { |ary|
-                    ary[0] == "CN"
-                }
-
-                if nameary.nil?
-                    Puppet.warning "Could not retrieve server name from cert"
-                else
-                    unless client == nameary[1]
-                        Puppet.debug "Overriding %s with cert name %s" %
-                            [client, nameary[1]]
-                        client = nameary[1]
-                    end
-                    valid = true
-                end
-            end
-
-            info = Puppet::Network::ClientRequest.new(client, clientip, valid)
-
-            return info
+    private
+
+    # Generate a ClientRequest object for later validation.
+    def client_request(request)
+      if peer = request.peeraddr
+        client = peer[2]
+        clientip = peer[3]
+      else
+
+              raise ::XMLRPC::FaultException.new(
+                
+          ERR_UNCAUGHT_EXCEPTION,
+        
+          "Could not retrieve client information"
+        )
+      end
+
+      # If they have a certificate (which will almost always be true)
+      # then we get the hostname from the cert, instead of via IP
+      # info
+      valid = false
+      if cert = request.client_cert
+        nameary = cert.subject.to_a.find { |ary|
+          ary[0] == "CN"
+        }
+
+        if nameary.nil?
+          Puppet.warning "Could not retrieve server name from cert"
+        else
+          unless client == nameary[1]
+            Puppet.debug "Overriding #{client} with cert name #{nameary[1]}"
+            client = nameary[1]
+          end
+          valid = true
         end
+      end
+
+      info = Puppet::Network::ClientRequest.new(client, clientip, valid)
+
+      info
     end
+  end
 end
 

data/lib/puppet/node.rb

@@ -2,126 +2,118 @@ require 'puppet/indirector'
 
 # A class for managing nodes, including their facts and environment.
 class Puppet::Node
-    require 'puppet/node/facts'
-    require 'puppet/node/environment'
-
-    # Set up indirection, so that nodes can be looked for in
-    # the node sources.
-    extend Puppet::Indirector
-
-    # Use the node source as the indirection terminus.
-    indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
-        A node is composed of its name, its facts, and its environment."
-
-    attr_accessor :name, :classes, :parameters, :source, :ipaddress
-    attr_reader :time
-    attr_writer :environment
-
-    # Do not return environments that are the empty string, and use
-    # explicitly set environments, then facts, then a central env
-    # value.
-    def environment
-        unless @environment
-            if env = parameters["environment"]
-                @environment = env
-            else
-                @environment = Puppet::Node::Environment.new.name.to_s
-            end
-        end
-        @environment
-    end
+  require 'puppet/node/facts'
+  require 'puppet/node/environment'
+
+  # Set up indirection, so that nodes can be looked for in
+  # the node sources.
+  extend Puppet::Indirector
 
-    def initialize(name, options = {})
-        unless name
-            raise ArgumentError, "Node names cannot be nil"
-        end
-        @name = name
+  # Adds the environment getter and setter, with some instance/string conversion
+  include Puppet::Node::Environment::Helper
 
-        if classes = options[:classes]
-            if classes.is_a?(String)
-                @classes = [classes]
-            else
-                @classes = classes
-            end
-        else
-            @classes = []
-        end
+  # Use the node source as the indirection terminus.
+  indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
+    A node is composed of its name, its facts, and its environment."
 
-        @parameters = options[:parameters] || {}
+  attr_accessor :name, :classes, :source, :ipaddress, :parameters
+  attr_reader :time
 
-        self.environment = options[:environment] if options[:environment]
+  def environment
+    return super if @environment
 
-        @time = Time.now
+    if env = parameters["environment"]
+      self.environment = env
+      return super
     end
 
-    # Merge the node facts with parameters from the node source.
-    def fact_merge
-        begin
-            if facts = Puppet::Node::Facts.find(name)
-                merge(facts.values)
-            end
-        rescue => detail
-            error = Puppet::Error.new("Could not retrieve facts for %s: %s" % [name, detail])
-            error.set_backtrace(detail.backtrace)
-            raise error
-        end
+    # Else, return the default
+    Puppet::Node::Environment.new
+  end
+
+  def initialize(name, options = {})
+    raise ArgumentError, "Node names cannot be nil" unless name
+    @name = name
+
+    if classes = options[:classes]
+      if classes.is_a?(String)
+        @classes = [classes]
+      else
+        @classes = classes
+      end
+    else
+      @classes = []
     end
 
-    # Merge any random parameters into our parameter list.
-    def merge(params)
-        params.each do |name, value|
-            @parameters[name] = value unless @parameters.include?(name)
-        end
+    @parameters = options[:parameters] || {}
 
-        @parameters["environment"] ||= self.environment if self.environment
+    if env = options[:environment]
+      self.environment = env
     end
 
-    # Calculate the list of names we might use for looking
-    # up our node.  This is only used for AST nodes.
-    def names
-        if Puppet.settings[:strict_hostname_checking]
-            return [name]
-        end
-
-        names = []
-
-        if name.include?(".")
-            names += split_name(name)
-        end
-
-        # First, get the fqdn
-        unless fqdn = parameters["fqdn"]
-            if parameters["hostname"] and parameters["domain"]
-                 fqdn = parameters["hostname"] + "." + parameters["domain"]
-            else
-                 Puppet.warning "Host is missing hostname and/or domain: %s" % name
-            end
-        end
-
-        # Now that we (might) have the fqdn, add each piece to the name
-        # list to search, in order of longest to shortest.
-        if fqdn
-            names += split_name(fqdn)
-        end
-
-        # And make sure the node name is first, since that's the most
-        # likely usage.
-        #   The name is usually the Certificate CN, but it can be
-        # set to the 'facter' hostname instead.
-        if Puppet[:node_name] == 'cert'
-            names.unshift name
-        else
-            names.unshift parameters["hostname"]
-        end
-        names.uniq
+    @time = Time.now
+  end
+
+  # Merge the node facts with parameters from the node source.
+  def fact_merge
+      if facts = Puppet::Node::Facts.find(name)
+        merge(facts.values)
+      end
+  rescue => detail
+      error = Puppet::Error.new("Could not retrieve facts for #{name}: #{detail}")
+      error.set_backtrace(detail.backtrace)
+      raise error
+  end
+
+  # Merge any random parameters into our parameter list.
+  def merge(params)
+    params.each do |name, value|
+      @parameters[name] = value unless @parameters.include?(name)
     end
 
-    def split_name(name)
-        list = name.split(".")
-        tmp = []
-        list.each_with_index do |short, i|
-            tmp << list[0..i].join(".")
-        end
-        tmp.reverse
+    @parameters["environment"] ||= self.environment.name.to_s if self.environment
+  end
+
+  # Calculate the list of names we might use for looking
+  # up our node.  This is only used for AST nodes.
+  def names
+    return [name] if Puppet.settings[:strict_hostname_checking]
+
+    names = []
+
+    names += split_name(name) if name.include?(".")
+
+    # First, get the fqdn
+    unless fqdn = parameters["fqdn"]
+      if parameters["hostname"] and parameters["domain"]
+        fqdn = parameters["hostname"] + "." + parameters["domain"]
+      else
+        Puppet.warning "Host is missing hostname and/or domain: #{name}"
+      end
+    end
+
+    # Now that we (might) have the fqdn, add each piece to the name
+    # list to search, in order of longest to shortest.
+    names += split_name(fqdn) if fqdn
+
+    # And make sure the node name is first, since that's the most
+    # likely usage.
+    #   The name is usually the Certificate CN, but it can be
+    # set to the 'facter' hostname instead.
+    if Puppet[:node_name] == 'cert'
+      names.unshift name
+    else
+      names.unshift parameters["hostname"]
+    end
+    names.uniq
+  end
+
+  def split_name(name)
+    list = name.split(".")
+    tmp = []
+    list.each_with_index do |short, i|
+      tmp << list[0..i].join(".")
     end
+    tmp.reverse
+  end
 end