puppet 0.25.5 → 2.6.0

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

@@ -1,102 +1,89 @@
 require 'openssl'
 require 'puppet'
-require 'puppet/parser/interpreter'
 require 'puppet/sslcertificates'
 require 'xmlrpc/server'
 require 'yaml'
 
 class Puppet::Network::Handler
-    class MasterError < Puppet::Error; end
-    class Master < Handler
-        desc "Puppet's configuration interface.  Used for all interactions related to
-        generating client configurations."
+  class MasterError < Puppet::Error; end
+  class Master < Handler
+    desc "Puppet's configuration interface.  Used for all interactions related to
+    generating client configurations."
 
-        include Puppet::Util
+    include Puppet::Util
 
-        attr_accessor :ast
-        attr_reader :ca
+    attr_accessor :ast
+    attr_reader :ca
 
-        @interface = XMLRPC::Service::Interface.new("puppetmaster") { |iface|
-                iface.add_method("string getconfig(string)")
-                iface.add_method("int freshness()")
-        }
+    @interface = XMLRPC::Service::Interface.new("puppetmaster") { |iface|
+        iface.add_method("string getconfig(string)")
+        iface.add_method("int freshness()")
+    }
 
-        # Tell a client whether there's a fresh config for it
-        def freshness(client = nil, clientip = nil)
-            # Always force a recompile.  Newer clients shouldn't do this (as of April 2008).
-            return Time.now.to_i
-        end
+    # Tell a client whether there's a fresh config for it
+    def freshness(client = nil, clientip = nil)
+      # Always force a recompile.  Newer clients shouldn't do this (as of April 2008).
+      Time.now.to_i
+    end
 
-        def initialize(hash = {})
-            args = {}
+    def initialize(hash = {})
+      args = {}
 
-            if hash[:Local]
-                @local = hash[:Local]
-            else
-                @local = false
-            end
+      @local = hash[:Local]
 
-            args[:Local] = true
+      args[:Local] = true
 
-            if hash.include?(:CA) and hash[:CA]
-                @ca = Puppet::SSLCertificates::CA.new()
-            else
-                @ca = nil
-            end
+      @ca = (hash.include?(:CA) and hash[:CA]) ? Puppet::SSLCertificates::CA.new : nil
 
-            Puppet.debug("Creating interpreter")
+      # This is only used by the cfengine module, or if --loadclasses was
+      # specified in +puppet+.
+      args[:Classes] = hash[:Classes] if hash.include?(:Classes)
+    end
 
-            # This is only used by the cfengine module, or if --loadclasses was
-            # specified in +puppet+.
-            if hash.include?(:Classes)
-                args[:Classes] = hash[:Classes]
-            end
-        end
+    # Call our various handlers; this handler is getting deprecated.
+    def getconfig(facts, format = "marshal", client = nil, clientip = nil)
+      facts = decode_facts(facts)
 
-        # Call our various handlers; this handler is getting deprecated.
-        def getconfig(facts, format = "marshal", client = nil, clientip = nil)
-            facts = decode_facts(facts)
+      client ||= facts["hostname"]
 
-            client ||= facts["hostname"]
+      # Pass the facts to the fact handler
+      Puppet::Node::Facts.new(client, facts).save unless local?
 
-            # Pass the facts to the fact handler
-            Puppet::Node::Facts.new(client, facts).save unless local?
+      catalog = Puppet::Resource::Catalog.find(client)
 
-            catalog = Puppet::Resource::Catalog.find(client)
+      case format
+      when "yaml"
+        return CGI.escape(catalog.extract.to_yaml)
+      when "marshal"
+        return CGI.escape(Marshal.dump(catalog.extract))
+      else
+        raise "Invalid markup format '#{format}'"
+      end
+    end
 
-            case format
-            when "yaml"
-                return CGI.escape(catalog.extract.to_yaml)
-            when "marshal"
-                return CGI.escape(Marshal.dump(catalog.extract))
-            else
-                raise "Invalid markup format '%s'" % format
-            end
+    #
+    def decode_facts(facts)
+      if @local
+        # we don't need to do anything, since we should already
+        # have raw objects
+        Puppet.debug "Our client is local"
+      else
+        Puppet.debug "Our client is remote"
+
+        begin
+          facts = YAML.load(CGI.unescape(facts))
+        rescue => detail
+          raise XMLRPC::FaultException.new(
+            1, "Could not rebuild facts"
+          )
         end
+      end
 
-        #
-        def decode_facts(facts)
-            if @local
-                # we don't need to do anything, since we should already
-                # have raw objects
-                Puppet.debug "Our client is local"
-            else
-                Puppet.debug "Our client is remote"
-
-                begin
-                    facts = YAML.load(CGI.unescape(facts))
-                rescue => detail
-                    raise XMLRPC::FaultException.new(
-                        1, "Could not rebuild facts"
-                    )
-                end
-            end
-
-            return facts
-        end
+      facts
+    end
 
-        # Translate our configuration appropriately for sending back to a client.
-        def translate(config)
-        end
+    # Translate our configuration appropriately for sending back to a client.
+    def translate(config)
     end
+  end
 end

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

@@ -3,85 +3,78 @@ require 'puppet/reports'
 
 # A simple server for triggering a new run on a Puppet client.
 class Puppet::Network::Handler
-    class Report < Handler
-        desc "Accepts a Puppet transaction report and processes it."
+  class Report < Handler
+    desc "Accepts a Puppet transaction report and processes it."
 
-        @interface = XMLRPC::Service::Interface.new("puppetreports") { |iface|
-            iface.add_method("string report(array)")
-        }
+    @interface = XMLRPC::Service::Interface.new("puppetreports") { |iface|
+      iface.add_method("string report(array)")
+    }
 
-        # Add a new report type.
-        def self.newreport(name, options = {}, &block)
-            Puppet.warning "The interface for registering report types has changed; use Puppet::Reports.register_report for report type %s" % name
-            Puppet::Reports.register_report(name, options, &block)
-        end
+    # Add a new report type.
+    def self.newreport(name, options = {}, &block)
+      Puppet.warning "The interface for registering report types has changed; use Puppet::Reports.register_report for report type #{name}"
+      Puppet::Reports.register_report(name, options, &block)
+    end
 
-        def initialize(*args)
-            super
-            Puppet.settings.use(:main, :reporting, :metrics)
-        end
+    def initialize(*args)
+      super
+      Puppet.settings.use(:main, :reporting, :metrics)
+    end
 
-        # Accept a report from a client.
-        def report(report, client = nil, clientip = nil)
-            # Unescape the report
-            unless @local
-                report = CGI.unescape(report)
-            end
+    # Accept a report from a client.
+    def report(report, client = nil, clientip = nil)
+      # Unescape the report
+      report = CGI.unescape(report) unless @local
 
-            Puppet.info "Processing reports %s for %s" % [reports().join(", "), client]
-            begin
-                process(report)
-            rescue => detail
-                Puppet.err "Could not process report for %s: %s" % [client, detail]
-                if Puppet[:trace]
-                    puts detail.backtrace
-                end
-            end
-        end
+      Puppet.info "Processing reports #{reports().join(", ")} for #{client}"
+      begin
+        process(report)
+      rescue => detail
+        Puppet.err "Could not process report for #{client}: #{detail}"
+        puts detail.backtrace if Puppet[:trace]
+      end
+    end
 
-        private
+    private
 
-        # Process the report using all of the existing hooks.
-        def process(yaml)
-            return if Puppet[:reports] == "none"
+    # Process the report using all of the existing hooks.
+    def process(yaml)
+      return if Puppet[:reports] == "none"
 
-            # First convert the report to real objects
-            begin
-                report = YAML.load(yaml)
-            rescue => detail
-                Puppet.warning "Could not load report: %s" % detail
-                return
-            end
+      # First convert the report to real objects
+      begin
+        report = YAML.load(yaml)
+      rescue => detail
+        Puppet.warning "Could not load report: #{detail}"
+        return
+      end
 
-            # Used for those reports that accept yaml
-            client = report.host
+      # Used for those reports that accept yaml
+      client = report.host
 
-            reports().each do |name|
-                if mod = Puppet::Reports.report(name)
-                    # We have to use a dup because we're including a module in the
-                    # report.
-                    newrep = report.dup
-                    begin
-                        newrep.extend(mod)
-                        newrep.process
-                    rescue => detail
-                        if Puppet[:trace]
-                            puts detail.backtrace
-                        end
-                        Puppet.err "Report %s failed: %s" %
-                            [name, detail]
-                    end
-                else
-                    Puppet.warning "No report named '%s'" % name
-                end
-            end
+      reports.each do |name|
+        if mod = Puppet::Reports.report(name)
+          # We have to use a dup because we're including a module in the
+          # report.
+          newrep = report.dup
+          begin
+            newrep.extend(mod)
+            newrep.process
+          rescue => detail
+            puts detail.backtrace if Puppet[:trace]
+            Puppet.err "Report #{name} failed: #{detail}"
+          end
+        else
+          Puppet.warning "No report named '#{name}'"
         end
+      end
+    end
 
-        # Handle the parsing of the reports attribute.
-        def reports
-            # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-            x = Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
-        end
+    # Handle the parsing of the reports attribute.
+    def reports
+      # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+      x = Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
     end
+  end
 end
 

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

@@ -1,31 +1,31 @@
-require 'puppet/agent/runner'
+require 'puppet/run'
 
 class Puppet::Network::Handler
-    class MissingMasterError < RuntimeError; end # Cannot find the master client
-    # A simple server for triggering a new run on a Puppet client.
-    class Runner < Handler
-        desc "An interface for triggering client configuration runs."
+  class MissingMasterError < RuntimeError; end # Cannot find the master client
+  # A simple server for triggering a new run on a Puppet client.
+  class Runner < Handler
+    desc "An interface for triggering client configuration runs."
 
-        @interface = XMLRPC::Service::Interface.new("puppetrunner") { |iface|
-            iface.add_method("string run(string, string)")
-        }
+    @interface = XMLRPC::Service::Interface.new("puppetrunner") { |iface|
+      iface.add_method("string run(string, string)")
+    }
 
-        side :client
+    side :client
 
-        # Run the client configuration right now, optionally specifying
-        # tags and whether to ignore schedules
-        def run(tags = nil, ignoreschedules = false, fg = true, client = nil, clientip = nil)
-            options = {}
-            options[:tags] = tags if tags
-            options[:ignoreschedules] = ignoreschedules if ignoreschedules
-            options[:background] = !fg
+    # Run the client configuration right now, optionally specifying
+    # tags and whether to ignore schedules
+    def run(tags = nil, ignoreschedules = false, fg = true, client = nil, clientip = nil)
+      options = {}
+      options[:tags] = tags if tags
+      options[:ignoreschedules] = ignoreschedules if ignoreschedules
+      options[:background] = !fg
 
-            runner = Puppet::Agent::Runner.new(options)
+      runner = Puppet::Run.new(options)
 
-            runner.run
+      runner.run
 
-            return runner.status
-        end
+      runner.status
     end
+  end
 end
 

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

@@ -1,16 +1,16 @@
 class Puppet::Network::Handler
-    class Status < Handler
-        desc "A simple interface for testing Puppet connectivity."
+  class Status < Handler
+    desc "A simple interface for testing Puppet connectivity."
 
-        side :client
+    side :client
 
-        @interface = XMLRPC::Service::Interface.new("status") { |iface|
-            iface.add_method("int status()")
-        }
+    @interface = XMLRPC::Service::Interface.new("status") { |iface|
+      iface.add_method("int status()")
+    }
 
-        def status(client = nil, clientip = nil)
-            return 1
-        end
+    def status(client = nil, clientip = nil)
+      1
     end
+  end
 end
 

data/lib/puppet/network/http.rb

@@ -1,15 +1,15 @@
 module Puppet::Network::HTTP
-    def self.server_class_by_type(kind)
-        case kind.to_sym
-        when :webrick
-            require 'puppet/network/http/webrick'
-            return Puppet::Network::HTTP::WEBrick
-        when :mongrel
-            raise ArgumentError, "Mongrel is not installed on this platform" unless Puppet.features.mongrel?
-            require 'puppet/network/http/mongrel'
-            return Puppet::Network::HTTP::Mongrel
-        else
-            raise ArgumentError, "Unknown HTTP server name [#{kind}]"
-        end
+  def self.server_class_by_type(kind)
+    case kind.to_sym
+    when :webrick
+      require 'puppet/network/http/webrick'
+      return Puppet::Network::HTTP::WEBrick
+    when :mongrel
+      raise ArgumentError, "Mongrel is not installed on this platform" unless Puppet.features.mongrel?
+      require 'puppet/network/http/mongrel'
+      return Puppet::Network::HTTP::Mongrel
+    else
+      raise ArgumentError, "Unknown HTTP server name [#{kind}]"
     end
+  end
 end

data/lib/puppet/network/http/api/v1.rb

@@ -1,65 +1,70 @@
 require 'puppet/network/http/api'
 
 module Puppet::Network::HTTP::API::V1
-    # How we map http methods and the indirection name in the URI
-    # to an indirection method.
-    METHOD_MAP = {
-        "GET" => {
-            :plural => :search,
-            :singular => :find
-        },
-        "PUT" => {
-            :singular => :save
-        },
-        "DELETE" => {
-            :singular => :destroy
-        }
+  # How we map http methods and the indirection name in the URI
+  # to an indirection method.
+  METHOD_MAP = {
+    "GET" => {
+      :plural => :search,
+      :singular => :find
+    },
+    "PUT" => {
+      :singular => :save
+    },
+    "DELETE" => {
+      :singular => :destroy
     }
+  }
 
-    def uri2indirection(http_method, uri, params)
-        environment, indirection, key = uri.split("/", 4)[1..-1] # the first field is always nil because of the leading slash
+  def uri2indirection(http_method, uri, params)
+    environment, indirection, key = uri.split("/", 4)[1..-1] # the first field is always nil because of the leading slash
 
-        raise ArgumentError, "The environment must be purely alphanumeric, not '%s'" % environment unless environment =~ /^\w+$/
-        raise ArgumentError, "The indirection name must be purely alphanumeric, not '%s'" % indirection unless indirection =~ /^\w+$/
+    raise ArgumentError, "The environment must be purely alphanumeric, not '#{environment}'" unless environment =~ /^\w+$/
+    raise ArgumentError, "The indirection name must be purely alphanumeric, not '#{indirection}'" unless indirection =~ /^\w+$/
 
-        method = indirection_method(http_method, indirection)
+    method = indirection_method(http_method, indirection)
 
-        params[:environment] = environment
+    params[:environment] = environment
 
-        raise ArgumentError, "No request key specified in %s" % uri if key == "" or key.nil?
+    raise ArgumentError, "No request key specified in #{uri}" if key == "" or key.nil?
 
-        key = URI.unescape(key)
+    key = URI.unescape(key)
 
-        Puppet::Indirector::Request.new(indirection, method, key, params)
-    end
+    Puppet::Indirector::Request.new(indirection, method, key, params)
+  end
+
+  def indirection2uri(request)
+    indirection = request.method == :search ? pluralize(request.indirection_name.to_s) : request.indirection_name.to_s
+    "/#{request.environment.to_s}/#{indirection}/#{request.escaped_key}#{request.query_string}"
+  end
+
+  def indirection_method(http_method, indirection)
+    raise ArgumentError, "No support for http method #{http_method}" unless METHOD_MAP[http_method]
 
-    def indirection2uri(request)
-        indirection = request.method == :search ? request.indirection_name.to_s + "s" : request.indirection_name.to_s
-        "/#{request.environment.to_s}/#{indirection}/#{request.escaped_key}#{request.query_string}"
+    unless method = METHOD_MAP[http_method][plurality(indirection)]
+      raise ArgumentError, "No support for plural #{http_method} operations"
     end
 
-    def indirection_method(http_method, indirection)
-        unless METHOD_MAP[http_method]
-            raise ArgumentError, "No support for http method %s" % http_method
-        end
+    method
+  end
 
-        unless method = METHOD_MAP[http_method][plurality(indirection)]
-            raise ArgumentError, "No support for plural %s operations" % http_method
-        end
+  def pluralize(indirection)
+    return(indirection == "status" ? "statuses" : indirection + "s")
+  end
 
-        return method
-    end
+  def plurality(indirection)
+    # NOTE This specific hook for facts is ridiculous, but it's a *many*-line
+    # fix to not need this, and our goal is to move away from the complication
+    # that leads to the fix being too long.
+    return :singular if indirection == "facts"
 
-    def plurality(indirection)
-        # NOTE This specific hook for facts is ridiculous, but it's a *many*-line
-        # fix to not need this, and our goal is to move away from the complication
-        # that leads to the fix being too long.
-        return :singular if indirection == "facts"
+    # "status" really is singular
+    return :singular if indirection == "status"
 
-        result = (indirection =~ /s$/) ? :plural : :singular
+    result = (indirection =~ /s$/) ? :plural : :singular
 
-        indirection.sub!(/s$/, '') if result
+    indirection.sub!(/s$/, '') if result
 
-        result
-    end
+    result
+  end
 end