puppet 0.25.5 → 2.6.0

data/lib/puppet/network/client.rb

@@ -13,178 +13,167 @@ require 'net/http'
 # Some versions of ruby don't have this method defined, which basically causes
 # us to never use ssl.  Yay.
 class Net::HTTP
-    def use_ssl?
-        if defined? @use_ssl
-            @use_ssl
-        else
-            false
-        end
+  def use_ssl?
+    if defined?(@use_ssl)
+      @use_ssl
+    else
+      false
     end
+  end
 
-    # JJM: This is a "backport" of sorts to older ruby versions which
-    # do not have this accessor.  See #896 for more information.
-    unless Net::HTTP.instance_methods.include? "enable_post_connection_check"
-        attr_accessor :enable_post_connection_check
-    end
+  # JJM: This is a "backport" of sorts to older ruby versions which
+  # do not have this accessor.  See #896 for more information.
+  attr_accessor :enable_post_connection_check unless Net::HTTP.instance_methods.include? "enable_post_connection_check"
 end
 
 # The base class for all of the clients.  Many clients just directly
 # call methods, but some of them need to do some extra work or
 # provide a different interface.
 class Puppet::Network::Client
-    Client = self
-    include Puppet::Util
-    extend Puppet::Util::SubclassLoader
-    include Puppet::Util::MethodHelper
-
-    # This handles reading in the key and such-like.
-    include Puppet::SSLCertificates::Support
-
-    attr_accessor :schedule, :lastrun, :local, :stopping
-
-    attr_reader :driver
-
-    # Set up subclass loading
-    handle_subclasses :client, "puppet/network/client"
-
-    # Determine what clients look for when being passed an object for local
-    # client/server stuff.  E.g., you could call Client::CA.new(:CA => ca).
-    def self.drivername
-        unless defined? @drivername
-            @drivername = self.name
-        end
-        @drivername
+  Client = self
+  include Puppet::Util
+  extend Puppet::Util::SubclassLoader
+  include Puppet::Util::MethodHelper
+
+  # This handles reading in the key and such-like.
+  include Puppet::SSLCertificates::Support
+
+  attr_accessor :schedule, :lastrun, :local, :stopping
+
+  attr_reader :driver
+
+  # Set up subclass loading
+  handle_subclasses :client, "puppet/network/client"
+
+  # Determine what clients look for when being passed an object for local
+  # client/server stuff.  E.g., you could call Client::CA.new(:CA => ca).
+  def self.drivername
+    @drivername ||= self.name
+  end
+
+  # Figure out the handler for our client.
+  def self.handler
+    @handler ||= Puppet::Network::Handler.handler(self.name)
+  end
+
+  # The class that handles xmlrpc interaction for us.
+  def self.xmlrpc_client
+    @xmlrpc_client ||= Puppet::Network::XMLRPCClient.handler_class(self.handler)
+  end
+
+  # Create our client.
+  def initialize(hash)
+    # to whom do we connect?
+    @server = nil
+
+    if hash.include?(:Cache)
+      @cache = hash[:Cache]
+    else
+      @cache = true
     end
 
-    # Figure out the handler for our client.
-    def self.handler
-        unless defined? @handler
-            @handler = Puppet::Network::Handler.handler(self.name)
-        end
-        @handler
+    driverparam = self.class.drivername
+    if hash.include?(:Server)
+      args = {:Server => hash[:Server]}
+      @server = hash[:Server]
+      args[:Port] = hash[:Port] || Puppet[:masterport]
+
+      @driver = self.class.xmlrpc_client.new(args)
+
+      self.read_cert
+
+      # We have to start the HTTP connection manually before we start
+      # sending it requests or keep-alive won't work.  Note that with #1010,
+      # we don't currently actually want keep-alive.
+      @driver.start if @driver.respond_to? :start and Puppet::Network::HttpPool.keep_alive?
+
+      @local = false
+    elsif hash.include?(driverparam)
+      @driver = hash[driverparam]
+      if @driver == true
+        @driver = self.class.handler.new
+      end
+      @local = true
+    else
+      raise Puppet::Network::ClientError, "#{self.class} must be passed a Server or #{driverparam}"
     end
-
-    # The class that handles xmlrpc interaction for us.
-    def self.xmlrpc_client
-        unless defined? @xmlrpc_client
-            @xmlrpc_client = Puppet::Network::XMLRPCClient.handler_class(self.handler)
-        end
-        @xmlrpc_client
+  end
+
+  # Are we a local client?
+  def local?
+    if @local
+      true
+    else
+      false
     end
-
-    # Create our client.
-    def initialize(hash)
-        # to whom do we connect?
-        @server = nil
-
-        if hash.include?(:Cache)
-            @cache = hash[:Cache]
-        else
-            @cache = true
-        end
-
-        driverparam = self.class.drivername
-        if hash.include?(:Server)
-            args = {:Server => hash[:Server]}
-            @server = hash[:Server]
-            args[:Port] = hash[:Port] || Puppet[:masterport]
-
-            @driver = self.class.xmlrpc_client.new(args)
-
-            self.read_cert
-
-            # We have to start the HTTP connection manually before we start
-            # sending it requests or keep-alive won't work.  Note that with #1010,
-            # we don't currently actually want keep-alive.
-            @driver.start if @driver.respond_to? :start and Puppet::Network::HttpPool.keep_alive?
-
-            @local = false
-        elsif hash.include?(driverparam)
-            @driver = hash[driverparam]
-            if @driver == true
-                @driver = self.class.handler.new
-            end
-            @local = true
-        else
-            raise Puppet::Network::ClientError, "%s must be passed a Server or %s" % [self.class, driverparam]
-        end
+  end
+
+  # Make sure we set the driver up when we read the cert in.
+  def recycle_connection
+    @driver.recycle_connection if @driver.respond_to?(:recycle_connection)
+  end
+
+  # A wrapper method to run and then store the last run time
+  def runnow
+    if self.stopping
+      Puppet.notice "In shutdown progress; skipping run"
+      return
     end
-
-    # Are we a local client?
-    def local?
-        if defined? @local and @local
-            true
-        else
-            false
-        end
+    begin
+      self.run
+      self.lastrun = Time.now.to_i
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Could not run #{self.class}: #{detail}"
     end
+  end
 
-    # Make sure we set the driver up when we read the cert in.
-    def recycle_connection
-        @driver.recycle_connection if @driver.respond_to?(:recycle_connection)
-    end
+  def run
+    raise Puppet::DevError, "Client type #{self.class} did not override run"
+  end
 
-    # A wrapper method to run and then store the last run time
-    def runnow
-        if self.stopping
-            Puppet.notice "In shutdown progress; skipping run"
-            return
-        end
-        begin
-            self.run
-            self.lastrun = Time.now.to_i
-        rescue => detail
-            puts detail.backtrace if Puppet[:trace]
-            Puppet.err "Could not run %s: %s" % [self.class, detail]
-        end
+  def scheduled?
+    if sched = self.schedule
+      return sched.match?(self.lastrun)
+    else
+      return true
     end
-
-    def run
-        raise Puppet::DevError, "Client type %s did not override run" %
-            self.class
+  end
+
+  def shutdown
+    if self.stopping
+      Puppet.notice "Already in shutdown"
+    else
+      self.stopping = true
+      Puppet::Util::Storage.store if self.respond_to? :running? and self.running?
+      rmpidfile
     end
-
-    def scheduled?
-        if sched = self.schedule
-            return sched.match?(self.lastrun)
-        else
-            return true
-        end
+  end
+
+  # Start listening for events.  We're pretty much just listening for
+  # timer events here.
+  def start
+    # Create our timer.  Puppet will handle observing it and such.
+
+          timer = Puppet.newtimer(
+                
+      :interval => Puppet[:runinterval],
+      :tolerance => 1,
+        
+      :start? => true
+    ) do
+      begin
+        self.runnow if self.scheduled?
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err "Could not run client; got otherwise uncaught exception: #{detail}"
+      end
     end
 
-    def shutdown
-        if self.stopping
-            Puppet.notice "Already in shutdown"
-        else
-            self.stopping = true
-            if self.respond_to? :running? and self.running?
-                Puppet::Util::Storage.store
-            end
-            rmpidfile()
-        end
-    end
-
-    # Start listening for events.  We're pretty much just listening for
-    # timer events here.
-    def start
-        # Create our timer.  Puppet will handle observing it and such.
-        timer = Puppet.newtimer(
-            :interval => Puppet[:runinterval],
-            :tolerance => 1,
-            :start? => true
-        ) do
-            begin
-                self.runnow if self.scheduled?
-            rescue => detail
-                puts detail.backtrace if Puppet[:trace]
-                Puppet.err "Could not run client; got otherwise uncaught exception: %s" % detail
-            end
-        end
-
-        # Run once before we start following the timer
-        self.runnow
-    end
+    # Run once before we start following the timer
+    self.runnow
+  end
 
-    require 'puppet/network/client/proxy'
+  require 'puppet/network/client/proxy'
 end
 

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

@@ -2,57 +2,55 @@ require 'puppet/network/client'
 
 # Request a certificate from the remote system.
 class Puppet::Network::Client::CA < Puppet::Network::Client
-    class InvalidCertificate < Puppet::Error; end
-
-    def initialize(options = {})
-        options = symbolize_options(options)
-        unless options.include?(:Server) or options.include?(:CA)
-            options[:Server] = Puppet[:ca_server]
-            options[:Port] = Puppet[:ca_port]
-        end
-        super(options)
+  class InvalidCertificate < Puppet::Error; end
+
+  def initialize(options = {})
+    options = symbolize_options(options)
+    unless options.include?(:Server) or options.include?(:CA)
+      options[:Server] = Puppet[:ca_server]
+      options[:Port] = Puppet[:ca_port]
+    end
+    super(options)
+  end
+
+  # This client is really only able to request certificates for the
+  # current host.  It uses the Puppet.settings settings to figure everything out.
+  def request_cert
+    Puppet.settings.use(:main, :ssl)
+
+    if cert = read_cert
+      return cert
+    end
+
+    begin
+      cert, cacert = @driver.getcert(csr.to_pem)
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      raise Puppet::Error.new("Certificate retrieval failed: #{detail}")
     end
 
-    # This client is really only able to request certificates for the
-    # current host.  It uses the Puppet.settings settings to figure everything out.
-    def request_cert
-        Puppet.settings.use(:main, :ssl)
-
-        if cert = read_cert
-            return cert
-        end
-
-        begin
-            cert, cacert = @driver.getcert(csr.to_pem)
-        rescue => detail
-            if Puppet[:trace]
-                puts detail.backtrace
-            end
-            raise Puppet::Error.new("Certificate retrieval failed: %s" % detail)
-        end
-
-        if cert.nil? or cert == ""
-            return nil
-        end
-
-        begin
-            @cert = OpenSSL::X509::Certificate.new(cert)
-            @cacert = OpenSSL::X509::Certificate.new(cacert)
-        rescue => detail
-            raise InvalidCertificate.new(
-                "Invalid certificate: %s" % detail
-            )
-        end
-
-        unless @cert.check_private_key(key)
-            raise InvalidCertificate, "Certificate does not match private key.  Try 'puppetca --clean %s' on the server." % Puppet[:certname]
-        end
-
-        # Only write the cert out if it passes validating.
-        Puppet.settings.write(:hostcert) do |f| f.print cert end
-        Puppet.settings.write(:localcacert) do |f| f.print cacert end
-
-        return @cert
+    if cert.nil? or cert == ""
+      return nil
     end
+
+    begin
+      @cert = OpenSSL::X509::Certificate.new(cert)
+      @cacert = OpenSSL::X509::Certificate.new(cacert)
+    rescue => detail
+      raise InvalidCertificate.new(
+        "Invalid certificate: #{detail}"
+      )
+    end
+
+    unless @cert.check_private_key(key)
+      raise InvalidCertificate, "Certificate does not match private key.  Try 'puppetca --clean #{Puppet[:certname]}' on the server."
+    end
+
+    # Only write the cert out if it passes validating.
+    Puppet.settings.write(:hostcert) do |f| f.print cert end
+    Puppet.settings.write(:localcacert) do |f| f.print cacert end
+
+    @cert
+  end
 end
 

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

@@ -1,6 +1,6 @@
 class Puppet::Network::Client::File < Puppet::Network::Client::ProxyClient
-    @handler = Puppet::Network::Handler.handler(:fileserver)
-    @drivername = :FileServer
-    self.mkmethods
+  @handler = Puppet::Network::Handler.handler(:fileserver)
+  @drivername = :FileServer
+  self.mkmethods
 end
 

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

@@ -2,26 +2,26 @@
 # is basically just a proxy class -- it calls its methods on the driver
 # and that's about it
 class Puppet::Network::Client::ProxyClient < Puppet::Network::Client
-    def self.mkmethods
-        interface = self.handler.interface
-        namespace = interface.prefix
+  def self.mkmethods
+    interface = self.handler.interface
+    namespace = interface.prefix
 
 
-        interface.methods.each { |ary|
-            method = ary[0]
-            Puppet.debug "%s: defining %s.%s" % [self, namespace, method]
-            define_method(method) { |*args|
-                begin
-                    @driver.send(method, *args)
-                rescue XMLRPC::FaultException => detail
-                    #Puppet.err "Could not call %s.%s: %s" %
-                    #    [namespace, method, detail.faultString]
-                    #raise NetworkClientError,
-                    #    "XMLRPC Error: %s" % detail.faultString
-                    raise NetworkClientError, detail.faultString
-                end
-            }
-        }
-    end
+    interface.methods.each { |ary|
+      method = ary[0]
+      Puppet.debug "#{self}: defining #{namespace}.#{method}"
+      define_method(method) { |*args|
+        begin
+          @driver.send(method, *args)
+        rescue XMLRPC::FaultException => detail
+          #Puppet.err "Could not call %s.%s: %s" %
+          #    [namespace, method, detail.faultString]
+          #raise NetworkClientError,
+          #    "XMLRPC Error: #{detail.faultString}"
+          raise NetworkClientError, detail.faultString
+        end
+      }
+    }
+  end
 end