puppet 0.25.5 → 2.6.0

data/lib/puppet/network/server.rb

@@ -2,168 +2,164 @@ require 'puppet/network/http'
 require 'puppet/util/pidlock'
 
 class Puppet::Network::Server
-    attr_reader :server_type, :protocols, :address, :port
-
-    # Put the daemon into the background.
-    def daemonize
-        if pid = fork()
-            Process.detach(pid)
-            exit(0)
-        end
-
-        # Get rid of console logging
-        Puppet::Util::Log.close(:console)
-
-        Process.setsid
-        Dir.chdir("/")
-        begin
-            $stdin.reopen "/dev/null"
-            $stdout.reopen "/dev/null", "a"
-            $stderr.reopen $stdout
-            Puppet::Util::Log.reopen
-        rescue => detail
-            Puppet::Util.secure_open("/tmp/daemonout", "w") { |f|
-                f.puts "Could not start %s: %s" % [Puppet[:name], detail]
-            }
-            raise "Could not start %s: %s" % [Puppet[:name], detail]
-        end
+  attr_reader :server_type, :protocols, :address, :port
+
+  # Put the daemon into the background.
+  def daemonize
+    if pid = fork
+      Process.detach(pid)
+      exit(0)
+    end
+
+    # Get rid of console logging
+    Puppet::Util::Log.close(:console)
+
+    Process.setsid
+    Dir.chdir("/")
+    begin
+      $stdin.reopen "/dev/null"
+      $stdout.reopen "/dev/null", "a"
+      $stderr.reopen $stdout
+      Puppet::Util::Log.reopen
+    rescue => detail
+      Puppet::Util.secure_open("/tmp/daemonout", "w") { |f|
+        f.puts "Could not start #{Puppet[:name]}: #{detail}"
+      }
+      raise "Could not start #{Puppet[:name]}: #{detail}"
     end
+  end
 
-    # Create a pidfile for our daemon, so we can be stopped and others
-    # don't try to start.
-    def create_pidfile
-        Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
-            unless Puppet::Util::Pidlock.new(pidfile).lock
-                raise "Could not create PID file: %s" % [pidfile]
-            end
-        end
-    end
-
-    # Remove the pid file for our daemon.
-    def remove_pidfile
-        Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
-            locker = Puppet::Util::Pidlock.new(pidfile)
-            if locker.locked?
-                locker.unlock or Puppet.err "Could not remove PID file %s" % [pidfile]
-            end
-        end
-    end
-
-    # Provide the path to our pidfile.
-    def pidfile
-        Puppet[:pidfile]
-    end
-
-    def initialize(args = {})
-        valid_args = [:handlers, :xmlrpc_handlers, :port]
-        bad_args = args.keys.find_all { |p| ! valid_args.include?(p) }.collect { |p| p.to_s }.join(",")
-        raise ArgumentError, "Invalid argument(s) %s" % bad_args unless bad_args == ""
-        @server_type = Puppet[:servertype] or raise "No servertype configuration found."  # e.g.,  WEBrick, Mongrel, etc.
-        http_server_class || raise(ArgumentError, "Could not determine HTTP Server class for server type [#{@server_type}]")
-
-        @port = args[:port] || Puppet[:masterport] || raise(ArgumentError, "Must specify :port or configure Puppet :masterport")
-        @address = determine_bind_address()
-
-        @protocols = [ :rest, :xmlrpc ]
-        @listening = false
-        @routes = {}
-        @xmlrpc_routes = {}
-        self.register(args[:handlers]) if args[:handlers]
-        self.register_xmlrpc(args[:xmlrpc_handlers]) if args[:xmlrpc_handlers]
-
-        # Make sure we have all of the directories we need to function.
-        Puppet.settings.use(:main, :ssl, Puppet[:name])
-    end
-
-    # Register handlers for REST networking, based on the Indirector.
-    def register(*indirections)
-        raise ArgumentError, "Indirection names are required." if indirections.empty?
-        indirections.flatten.each do |name|
-            Puppet::Indirector::Indirection.model(name) || raise(ArgumentError, "Cannot locate indirection '#{name}'.")
-            @routes[name.to_sym] = true
-        end
-    end
-
-    # Unregister Indirector handlers.
-    def unregister(*indirections)
-        raise "Cannot unregister indirections while server is listening." if listening?
-        indirections = @routes.keys if indirections.empty?
-
-        indirections.flatten.each do |i|
-            raise(ArgumentError, "Indirection [%s] is unknown." % i) unless @routes[i.to_sym]
-        end
-
-        indirections.flatten.each do |i|
-            @routes.delete(i.to_sym)
-        end
-    end
-
-    # Register xmlrpc handlers for backward compatibility.
-    def register_xmlrpc(*namespaces)
-        raise ArgumentError, "XMLRPC namespaces are required." if namespaces.empty?
-        namespaces.flatten.each do |name|
-            Puppet::Network::Handler.handler(name) || raise(ArgumentError, "Cannot locate XMLRPC handler for namespace '#{name}'.")
-            @xmlrpc_routes[name.to_sym] = true
-        end
-    end
-
-    # Unregister xmlrpc handlers.
-    def unregister_xmlrpc(*namespaces)
-        raise "Cannot unregister xmlrpc handlers while server is listening." if listening?
-        namespaces = @xmlrpc_routes.keys if namespaces.empty?
+  # Create a pidfile for our daemon, so we can be stopped and others
+  # don't try to start.
+  def create_pidfile
+    Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
+      raise "Could not create PID file: #{pidfile}" unless Puppet::Util::Pidlock.new(pidfile).lock
+    end
+  end
 
-        namespaces.flatten.each do |i|
-            raise(ArgumentError, "XMLRPC handler '%s' is unknown." % i) unless @xmlrpc_routes[i.to_sym]
-        end
-
-        namespaces.flatten.each do |i|
-            @xmlrpc_routes.delete(i.to_sym)
-        end
-    end
+  # Remove the pid file for our daemon.
+  def remove_pidfile
+    Puppet::Util.sync(Puppet[:name]).synchronize(Sync::EX) do
+      locker = Puppet::Util::Pidlock.new(pidfile)
+      locker.unlock or Puppet.err "Could not remove PID file #{pidfile}" if locker.locked?
+    end
+  end
+
+  # Provide the path to our pidfile.
+  def pidfile
+    Puppet[:pidfile]
+  end
+
+  def initialize(args = {})
+    valid_args = [:handlers, :xmlrpc_handlers, :port]
+    bad_args = args.keys.find_all { |p| ! valid_args.include?(p) }.collect { |p| p.to_s }.join(",")
+    raise ArgumentError, "Invalid argument(s) #{bad_args}" unless bad_args == ""
+    @server_type = Puppet[:servertype] or raise "No servertype configuration found."  # e.g.,  WEBrick, Mongrel, etc.
+    http_server_class || raise(ArgumentError, "Could not determine HTTP Server class for server type [#{@server_type}]")
+
+    @port = args[:port] || Puppet[:masterport] || raise(ArgumentError, "Must specify :port or configure Puppet :masterport")
+    @address = determine_bind_address
+
+    @protocols = [ :rest, :xmlrpc ]
+    @listening = false
+    @routes = {}
+    @xmlrpc_routes = {}
+    self.register(args[:handlers]) if args[:handlers]
+    self.register_xmlrpc(args[:xmlrpc_handlers]) if args[:xmlrpc_handlers]
+
+    # Make sure we have all of the directories we need to function.
+    Puppet.settings.use(:main, :ssl, Puppet[:name])
+  end
+
+  # Register handlers for REST networking, based on the Indirector.
+  def register(*indirections)
+    raise ArgumentError, "Indirection names are required." if indirections.empty?
+    indirections.flatten.each do |name|
+      Puppet::Indirector::Indirection.model(name) || raise(ArgumentError, "Cannot locate indirection '#{name}'.")
+      @routes[name.to_sym] = true
+    end
+  end
+
+  # Unregister Indirector handlers.
+  def unregister(*indirections)
+    raise "Cannot unregister indirections while server is listening." if listening?
+    indirections = @routes.keys if indirections.empty?
+
+    indirections.flatten.each do |i|
+      raise(ArgumentError, "Indirection [#{i}] is unknown.") unless @routes[i.to_sym]
+    end
+
+    indirections.flatten.each do |i|
+      @routes.delete(i.to_sym)
+    end
+  end
+
+  # Register xmlrpc handlers for backward compatibility.
+  def register_xmlrpc(*namespaces)
+    raise ArgumentError, "XMLRPC namespaces are required." if namespaces.empty?
+    namespaces.flatten.each do |name|
+      Puppet::Network::Handler.handler(name) || raise(ArgumentError, "Cannot locate XMLRPC handler for namespace '#{name}'.")
+      @xmlrpc_routes[name.to_sym] = true
+    end
+  end
+
+  # Unregister xmlrpc handlers.
+  def unregister_xmlrpc(*namespaces)
+    raise "Cannot unregister xmlrpc handlers while server is listening." if listening?
+    namespaces = @xmlrpc_routes.keys if namespaces.empty?
+
+    namespaces.flatten.each do |i|
+      raise(ArgumentError, "XMLRPC handler '#{i}' is unknown.") unless @xmlrpc_routes[i.to_sym]
+    end
+
+    namespaces.flatten.each do |i|
+      @xmlrpc_routes.delete(i.to_sym)
+    end
+  end
+
+  def listening?
+    @listening
+  end
 
-    def listening?
-        @listening
-    end
-
-    def listen
-        raise "Cannot listen -- already listening." if listening?
-        @listening = true
-        http_server.listen(:address => address, :port => port, :handlers => @routes.keys, :xmlrpc_handlers => @xmlrpc_routes.keys, :protocols => protocols)
-    end
+  def listen
+    raise "Cannot listen -- already listening." if listening?
+    @listening = true
+    http_server.listen(:address => address, :port => port, :handlers => @routes.keys, :xmlrpc_handlers => @xmlrpc_routes.keys, :protocols => protocols)
+  end
 
-    def unlisten
-        raise "Cannot unlisten -- not currently listening." unless listening?
-        http_server.unlisten
-        @listening = false
-    end
+  def unlisten
+    raise "Cannot unlisten -- not currently listening." unless listening?
+    http_server.unlisten
+    @listening = false
+  end
 
-    def http_server_class
-        http_server_class_by_type(@server_type)
-    end
+  def http_server_class
+    http_server_class_by_type(@server_type)
+  end
 
-    def start
-        create_pidfile
-        listen
-    end
+  def start
+    create_pidfile
+    listen
+  end
 
-    def stop
-        unlisten
-        remove_pidfile
-    end
+  def stop
+    unlisten
+    remove_pidfile
+  end
 
   private
 
-    def http_server
-        @http_server ||= http_server_class.new
-    end
+  def http_server
+    @http_server ||= http_server_class.new
+  end
 
-    def http_server_class_by_type(kind)
-        Puppet::Network::HTTP.server_class_by_type(kind)
-    end
+  def http_server_class_by_type(kind)
+    Puppet::Network::HTTP.server_class_by_type(kind)
+  end
 
-    def determine_bind_address
-        tmp = Puppet[:bindaddress]
-        return tmp if tmp != ""
-        return server_type.to_s == "webrick" ? "0.0.0.0" : "127.0.0.1"
-    end
+  def determine_bind_address
+    tmp = Puppet[:bindaddress]
+    return tmp if tmp != ""
+    server_type.to_s == "webrick" ? "0.0.0.0" : "127.0.0.1"
+  end
 end

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

@@ -8,212 +8,204 @@ require 'net/https'
 require 'yaml'
 
 module Puppet::Network
-    class ClientError < Puppet::Error; end
-    class XMLRPCClientError < Puppet::Error; end
-    class XMLRPCClient < ::XMLRPC::Client
-
-        attr_accessor :puppet_server, :puppet_port
-        @clients = {}
-
-        class << self
-            include Puppet::Util
-            include Puppet::Util::ClassGen
-        end
-
-        # Create a netclient for each handler
-        def self.mkclient(handler)
-            interface = handler.interface
-            namespace = interface.prefix
-
-            # Create a subclass for every client type.  This is
-            # so that all of the methods are on their own class,
-            # so that their namespaces can define the same methods if
-            # they want.
-            constant = handler.name.to_s.capitalize
-            name = namespace.downcase
-            newclient = genclass(name, :hash => @clients, :constant => constant)
-
-            interface.methods.each { |ary|
-                method = ary[0]
-                newclient.send(:define_method,method) { |*args|
-                    make_rpc_call(namespace, method, *args)
-                }
-            }
-
-            return newclient
-        end
-
-        def self.handler_class(handler)
-            @clients[handler] || self.mkclient(handler)
-        end
-
-        class ErrorHandler
-            def initialize(&block)
-                metaclass.define_method(:execute, &block)
-            end
-        end
-
-        # Use a class variable so all subclasses have access to it.
-        @@error_handlers = {}
-
-        def self.error_handler(exception)
-            if handler = @@error_handlers[exception.class]
-                return handler
-            else
-                return @@error_handlers[:default]
-            end
-        end
-
-        def self.handle_error(*exceptions, &block)
-            handler = ErrorHandler.new(&block)
-
-            exceptions.each do |exception|
-                @@error_handlers[exception] = handler
-            end
-        end
-
-        handle_error(OpenSSL::SSL::SSLError) do |client, detail, namespace, method|
-            if detail.message =~ /bad write retry/
-                Puppet.warning "Transient SSL write error; restarting connection and retrying"
-                client.recycle_connection
-                return :retry
-            end
-            ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
-                if detail.message.include?(str)
-                    Puppet.warning "Certificate validation failed; consider using the certname configuration option"
-                end
-            end
-            raise XMLRPCClientError, "Certificates were not trusted: %s" % detail
-        end
-
-        handle_error(:default) do |client, detail, namespace, method|
-            if detail.message.to_s =~ /^Wrong size\. Was \d+, should be \d+$/
-                Puppet.warning "XMLRPC returned wrong size.  Retrying."
-                return :retry
-            end
-            Puppet.err "Could not call %s.%s: %s" % [namespace, method, detail.inspect]
-            error = XMLRPCClientError.new(detail.to_s)
-            error.set_backtrace detail.backtrace
-            raise error
-        end
-
-        handle_error(OpenSSL::SSL::SSLError) do |client, detail, namespace, method|
-            if detail.message =~ /bad write retry/
-                Puppet.warning "Transient SSL write error; restarting connection and retrying"
-                client.recycle_connection
-                return :retry
-            end
-            ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
-                if detail.message.include?(str)
-                    Puppet.warning "Certificate validation failed; consider using the certname configuration option"
-                end
-            end
-            raise XMLRPCClientError, "Certificates were not trusted: %s" % detail
-        end
-
-        handle_error(::XMLRPC::FaultException) do |client, detail, namespace, method|
-            raise XMLRPCClientError, detail.faultString
-        end
-
-        handle_error(Errno::ECONNREFUSED) do |client, detail, namespace, method|
-            msg = "Could not connect to %s on port %s" % [client.host, client.port]
-            raise XMLRPCClientError, msg
-        end
-
-        handle_error(SocketError) do |client, detail, namespace, method|
-            Puppet.err "Could not find server %s: %s" % [@host, detail.to_s]
-            error = XMLRPCClientError.new("Could not find server %s" % client.host)
-            error.set_backtrace detail.backtrace
-            raise error
-        end
-
-        handle_error(Errno::EPIPE, EOFError) do |client, detail, namespace, method|
-            Puppet.info "Other end went away; restarting connection and retrying"
-            client.recycle_connection
-            return :retry
-        end
-
-        handle_error(Timeout::Error) do |client, detail, namespace, method|
-            Puppet.err "Connection timeout calling %s.%s: %s" % [namespace, method, detail.to_s]
-            error = XMLRPCClientError.new("Connection Timeout")
-            error.set_backtrace(detail.backtrace)
-            raise error
-        end
-
-        def make_rpc_call(namespace, method, *args)
-            Puppet.debug "Calling %s.%s" % [namespace, method]
-            begin
-                call("%s.%s" % [namespace, method.to_s],*args)
-            rescue SystemExit,NoMemoryError
-                raise
-            rescue Exception => detail
-                retry if self.class.error_handler(detail).execute(self, detail, namespace, method) == :retry
-            end
-        ensure
-            http.finish if http.started?
-        end
-
-        def http
-            unless @http
-                @http = Puppet::Network::HttpPool.http_instance(host, port, true)
-            end
-            @http
-        end
-
-        attr_reader :host, :port
-
-        def initialize(hash = {})
-            hash[:Path] ||= "/RPC2"
-            hash[:Server] ||= Puppet[:server]
-            hash[:Port] ||= Puppet[:masterport]
-            hash[:HTTPProxyHost] ||= Puppet[:http_proxy_host]
-            hash[:HTTPProxyPort] ||= Puppet[:http_proxy_port]
-
-            if "none" == hash[:HTTPProxyHost]
-                hash[:HTTPProxyHost] = nil
-                hash[:HTTPProxyPort] = nil
-            end
+  class ClientError < Puppet::Error; end
+  class XMLRPCClientError < Puppet::Error; end
+  class XMLRPCClient < ::XMLRPC::Client
+
+    attr_accessor :puppet_server, :puppet_port
+    @clients = {}
+
+    class << self
+      include Puppet::Util
+      include Puppet::Util::ClassGen
+    end
+
+    # Create a netclient for each handler
+    def self.mkclient(handler)
+      interface = handler.interface
+      namespace = interface.prefix
+
+      # Create a subclass for every client type.  This is
+      # so that all of the methods are on their own class,
+      # so that their namespaces can define the same methods if
+      # they want.
+      constant = handler.name.to_s.capitalize
+      name = namespace.downcase
+      newclient = genclass(name, :hash => @clients, :constant => constant)
+
+      interface.methods.each { |ary|
+        method = ary[0]
+        newclient.send(:define_method,method) { |*args|
+          make_rpc_call(namespace, method, *args)
+        }
+      }
+
+      newclient
+    end
+
+    def self.handler_class(handler)
+      @clients[handler] || self.mkclient(handler)
+    end
+
+    class ErrorHandler
+      def initialize(&block)
+        singleton_class.define_method(:execute, &block)
+      end
+    end
+
+    # Use a class variable so all subclasses have access to it.
+    @@error_handlers = {}
+
+    def self.error_handler(exception)
+      if handler = @@error_handlers[exception.class]
+        return handler
+      else
+        return @@error_handlers[:default]
+      end
+    end
+
+    def self.handle_error(*exceptions, &block)
+      handler = ErrorHandler.new(&block)
+
+      exceptions.each do |exception|
+        @@error_handlers[exception] = handler
+      end
+    end
+
+    handle_error(OpenSSL::SSL::SSLError) do |client, detail, namespace, method|
+      if detail.message =~ /bad write retry/
+        Puppet.warning "Transient SSL write error; restarting connection and retrying"
+        client.recycle_connection
+        return :retry
+      end
+      ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
+        Puppet.warning "Certificate validation failed; consider using the certname configuration option" if detail.message.include?(str)
+      end
+      raise XMLRPCClientError, "Certificates were not trusted: #{detail}"
+    end
+
+    handle_error(:default) do |client, detail, namespace, method|
+      if detail.message.to_s =~ /^Wrong size\. Was \d+, should be \d+$/
+        Puppet.warning "XMLRPC returned wrong size.  Retrying."
+        return :retry
+      end
+      Puppet.err "Could not call #{namespace}.#{method}: #{detail.inspect}"
+      error = XMLRPCClientError.new(detail.to_s)
+      error.set_backtrace detail.backtrace
+      raise error
+    end
+
+    handle_error(OpenSSL::SSL::SSLError) do |client, detail, namespace, method|
+      if detail.message =~ /bad write retry/
+        Puppet.warning "Transient SSL write error; restarting connection and retrying"
+        client.recycle_connection
+        return :retry
+      end
+      ["certificate verify failed", "hostname was not match", "hostname not match"].each do |str|
+        Puppet.warning "Certificate validation failed; consider using the certname configuration option" if detail.message.include?(str)
+      end
+      raise XMLRPCClientError, "Certificates were not trusted: #{detail}"
+    end
+
+    handle_error(::XMLRPC::FaultException) do |client, detail, namespace, method|
+      raise XMLRPCClientError, detail.faultString
+    end
+
+    handle_error(Errno::ECONNREFUSED) do |client, detail, namespace, method|
+      msg = "Could not connect to #{client.host} on port #{client.port}"
+      raise XMLRPCClientError, msg
+    end
+
+    handle_error(SocketError) do |client, detail, namespace, method|
+      Puppet.err "Could not find server #{@host}: #{detail}"
+      error = XMLRPCClientError.new("Could not find server #{client.host}")
+      error.set_backtrace detail.backtrace
+      raise error
+    end
+
+    handle_error(Errno::EPIPE, EOFError) do |client, detail, namespace, method|
+      Puppet.info "Other end went away; restarting connection and retrying"
+      client.recycle_connection
+      return :retry
+    end
+
+    handle_error(Timeout::Error) do |client, detail, namespace, method|
+      Puppet.err "Connection timeout calling #{namespace}.#{method}: #{detail}"
+      error = XMLRPCClientError.new("Connection Timeout")
+      error.set_backtrace(detail.backtrace)
+      raise error
+    end
+
+    def make_rpc_call(namespace, method, *args)
+      Puppet.debug "Calling #{namespace}.#{method}"
+      begin
+        call("#{namespace}.#{method}",*args)
+      rescue SystemExit,NoMemoryError
+        raise
+      rescue Exception => detail
+        retry if self.class.error_handler(detail).execute(self, detail, namespace, method) == :retry
+      end
+    ensure
+      http.finish if http.started?
+    end
+
+    def http
+      @http ||= Puppet::Network::HttpPool.http_instance(host, port, true)
+    end
+
+    attr_reader :host, :port
+
+    def initialize(hash = {})
+      hash[:Path] ||= "/RPC2"
+      hash[:Server] ||= Puppet[:server]
+      hash[:Port] ||= Puppet[:masterport]
+      hash[:HTTPProxyHost] ||= Puppet[:http_proxy_host]
+      hash[:HTTPProxyPort] ||= Puppet[:http_proxy_port]
+
+      if "none" == hash[:HTTPProxyHost]
+        hash[:HTTPProxyHost] = nil
+        hash[:HTTPProxyPort] = nil
+      end
+
 
             super(
-                hash[:Server],
-                hash[:Path],
-                hash[:Port],
-                hash[:HTTPProxyHost],
-                hash[:HTTPProxyPort],
-                nil, # user
-                nil, # password
-                true, # use_ssl
-                Puppet[:configtimeout] # use configured timeout (#1176)
-            )
-            @http = Puppet::Network::HttpPool.http_instance(@host, @port)
-        end
-
-        # Get rid of our existing connection, replacing it with a new one.
-        # This should only happen if we lose our connection somehow (e.g., an EPIPE)
-        # or we've just downloaded certs and we need to create new http instances
-        # with the certs added.
-        def recycle_connection
-            if http.started?
-                http.finish
-            end
-            @http = nil
-            self.http # force a new one
-        end
-
-        def start
-            begin
-                @http.start unless @http.started?
-            rescue => detail
-                Puppet.err "Could not connect to server: %s" % detail
-            end
-        end
-
-        def local
-            false
-        end
-
-        def local?
-            false
-        end
+                
+        hash[:Server],
+        hash[:Path],
+        hash[:Port],
+        hash[:HTTPProxyHost],
+        hash[:HTTPProxyPort],
+        
+        nil, # user
+        nil, # password
+        true, # use_ssl
+        Puppet[:configtimeout] # use configured timeout (#1176)
+      )
+      @http = Puppet::Network::HttpPool.http_instance(@host, @port)
+    end
+
+    # Get rid of our existing connection, replacing it with a new one.
+    # This should only happen if we lose our connection somehow (e.g., an EPIPE)
+    # or we've just downloaded certs and we need to create new http instances
+    # with the certs added.
+    def recycle_connection
+      http.finish if http.started?
+      @http = nil
+      self.http # force a new one
+    end
+
+    def start
+        @http.start unless @http.started?
+    rescue => detail
+        Puppet.err "Could not connect to server: #{detail}"
+    end
+
+    def local
+      false
+    end
+
+    def local?
+      false
     end
+  end
 end