puppet 0.25.5 → 2.6.0

data/lib/puppet/indirector/node/memory.rb

@@ -2,9 +2,9 @@ require 'puppet/node'
 require 'puppet/indirector/memory'
 
 class Puppet::Node::Memory < Puppet::Indirector::Memory
-    desc "Keep track of nodes in memory but nowhere else.  This is used for
-        one-time compiles, such as what the stand-alone ``puppet`` does.
-        To use this terminus, you must load it with the data you want it
-        to contain; it is only useful for developers and should generally not
-        be chosen by a normal user."
+  desc "Keep track of nodes in memory but nowhere else.  This is used for
+    one-time compiles, such as what the stand-alone ``puppet`` does.
+    To use this terminus, you must load it with the data you want it
+    to contain; it is only useful for developers and should generally not
+    be chosen by a normal user."
 end

data/lib/puppet/indirector/node/plain.rb

@@ -2,18 +2,18 @@ require 'puppet/node'
 require 'puppet/indirector/plain'
 
 class Puppet::Node::Plain < Puppet::Indirector::Plain
-    desc "Always return an empty node object. Assumes you keep track of nodes
-        in flat file manifests.  You should use it when you don't have some other,
-        functional source you want to use, as the compiler will not work without a
-        valid node terminus.
+  desc "Always return an empty node object. Assumes you keep track of nodes
+    in flat file manifests.  You should use it when you don't have some other,
+    functional source you want to use, as the compiler will not work without a
+    valid node terminus.
 
-        Note that class is responsible for merging the node's facts into the
-        node instance before it is returned."
+    Note that class is responsible for merging the node's facts into the
+    node instance before it is returned."
 
-    # Just return an empty node.
-    def find(request)
-        node = super
-        node.fact_merge
-        node
-    end
+  # Just return an empty node.
+  def find(request)
+    node = super
+    node.fact_merge
+    node
+  end
 end

data/lib/puppet/indirector/node/rest.rb

@@ -2,6 +2,6 @@ require 'puppet/node'
 require 'puppet/indirector/rest'
 
 class Puppet::Node::Rest < Puppet::Indirector::REST
-    desc "This will eventually be a REST-based mechanism for finding nodes.  It is currently non-functional."
-    # TODO/FIXME
+  desc "This will eventually be a REST-based mechanism for finding nodes.  It is currently non-functional."
+  # TODO/FIXME
 end

data/lib/puppet/indirector/node/yaml.rb

@@ -2,6 +2,6 @@ require 'puppet/node'
 require 'puppet/indirector/yaml'
 
 class Puppet::Node::Yaml < Puppet::Indirector::Yaml
-    desc "Store node information as flat files, serialized using YAML,
-        or deserialize stored YAML nodes."
+  desc "Store node information as flat files, serialized using YAML,
+    or deserialize stored YAML nodes."
 end

data/lib/puppet/indirector/plain.rb

@@ -2,8 +2,8 @@ require 'puppet/indirector/terminus'
 
 # An empty terminus type, meant to just return empty objects.
 class Puppet::Indirector::Plain < Puppet::Indirector::Terminus
-    # Just return nothing.
-    def find(request)
-        indirection.model.new(request.key)
-    end
+  # Just return nothing.
+  def find(request)
+    indirection.model.new(request.key)
+  end
 end

data/lib/puppet/indirector/queue.rb

@@ -19,65 +19,63 @@ require 'puppet/util'
 # client library to handle queue creation as necessary (for a number of popular queuing solutions, queue
 # creation is automatic and not a concern).
 class Puppet::Indirector::Queue < Puppet::Indirector::Terminus
-    extend ::Puppet::Util::Queue
-    include Puppet::Util
+  extend ::Puppet::Util::Queue
+  include Puppet::Util
 
-    def initialize(*args)
-        super
-        raise ArgumentError, "Queueing requires pson support" unless Puppet.features.pson?
-    end
+  def initialize(*args)
+    super
+    raise ArgumentError, "Queueing requires pson support" unless Puppet.features.pson?
+  end
 
-    # Queue has no idiomatic "find"
-    def find(request)
-        nil
-    end
+  # Queue has no idiomatic "find"
+  def find(request)
+    nil
+  end
 
-    # Place the request on the queue
-    def save(request)
-        begin
-            result = nil
-            benchmark :info, "Queued %s for %s" % [indirection.name, request.key] do
-                result = client.send_message(queue, request.instance.render(:pson))
-            end
-            result
-        rescue => detail
-            raise Puppet::Error, "Could not write %s to queue: %s\nInstance::%s\n client : %s" % [request.key, detail,request.instance.to_s,client.to_s]
-        end
-    end
+  # Place the request on the queue
+  def save(request)
+      result = nil
+      benchmark :info, "Queued #{indirection.name} for #{request.key}" do
+        result = client.send_message(queue, request.instance.render(:pson))
+      end
+      result
+  rescue => detail
+      raise Puppet::Error, "Could not write #{request.key} to queue: #{detail}\nInstance::#{request.instance}\n client : #{client}"
+  end
 
-    def self.queue
-        indirection_name
-    end
+  def self.queue
+    indirection_name
+  end
 
-    def queue
-        self.class.queue
-    end
+  def queue
+    self.class.queue
+  end
 
-    # Returns the singleton queue client object.
-    def client
-        self.class.client
-    end
+  # Returns the singleton queue client object.
+  def client
+    self.class.client
+  end
 
-    # converts the _message_ from deserialized format to an actual model instance.
-    def self.intern(message)
-        result = nil
-        benchmark :info, "Loaded queued %s" % [indirection.name] do
-            result = model.convert_from(:pson, message)
-        end
-        result
+  # converts the _message_ from deserialized format to an actual model instance.
+  def self.intern(message)
+    result = nil
+    benchmark :info, "Loaded queued #{indirection.name}" do
+      result = model.convert_from(:pson, message)
     end
+    result
+  end
 
-    # Provides queue subscription functionality; for a given indirection, use this method on the terminus
-    # to subscribe to the indirection-specific queue.  Your _block_ will be executed per new indirection
-    # model received from the queue, with _obj_ being the model instance.
-    def self.subscribe
-        client.subscribe(queue) do |msg|
-            begin
-                yield(self.intern(msg))
-            rescue => detail
-                puts detail.backtrace if Puppet[:trace]
-                Puppet.err "Error occured with subscription to queue %s for indirection %s: %s" % [queue, indirection_name, detail]
-            end
-        end
+  # Provides queue subscription functionality; for a given indirection, use this method on the terminus
+  # to subscribe to the indirection-specific queue.  Your _block_ will be executed per new indirection
+  # model received from the queue, with _obj_ being the model instance.
+  def self.subscribe
+    client.subscribe(queue) do |msg|
+      begin
+        yield(self.intern(msg))
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err "Error occured with subscription to queue #{queue} for indirection #{indirection_name}: #{detail}"
+      end
     end
+  end
 end

data/lib/puppet/indirector/report/processor.rb

@@ -3,49 +3,46 @@ require 'puppet/indirector/code'
 require 'puppet/reports'
 
 class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
-    desc "Puppet's report processor.  Processes the report with each of
-        the report types listed in the 'reports' setting."
+  desc "Puppet's report processor.  Processes the report with each of
+    the report types listed in the 'reports' setting."
 
-    def initialize
-        Puppet.settings.use(:main, :reporting, :metrics)
-    end
+  def initialize
+    Puppet.settings.use(:main, :reporting, :metrics)
+  end
 
-    def save(request)
-        process(request.instance)
-    end
+  def save(request)
+    process(request.instance)
+  end
 
-    private
+  private
 
-    # Process the report with each of the configured report types.
-    # LAK:NOTE This isn't necessarily the best design, but it's backward
-    # compatible and that's good enough for now.
-    def process(report)
-        return if Puppet[:reports] == "none"
+  # Process the report with each of the configured report types.
+  # LAK:NOTE This isn't necessarily the best design, but it's backward
+  # compatible and that's good enough for now.
+  def process(report)
+    return if Puppet[:reports] == "none"
 
-        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
+    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

data/lib/puppet/indirector/report/rest.rb

@@ -1,7 +1,7 @@
 require 'puppet/indirector/rest'
 
 class Puppet::Transaction::Report::Rest < Puppet::Indirector::REST
-    desc "Get server report over HTTP via REST."
-    use_server_setting(:report_server)
-    use_port_setting(:report_port)
+  desc "Get server report over HTTP via REST."
+  use_server_setting(:report_server)
+  use_port_setting(:report_port)
 end

data/lib/puppet/indirector/request.rb

@@ -6,180 +6,194 @@ require 'puppet/indirector'
 # Indirection call, and as a a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
-    attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
+  attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
 
-    attr_accessor :server, :port, :uri, :protocol
+  attr_accessor :server, :port, :uri, :protocol
 
-    attr_reader :indirection_name
+  attr_reader :indirection_name
 
-    OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
+  OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
 
-    # Is this an authenticated request?
-    def authenticated?
-        # Double negative, so we just get true or false
-        ! ! authenticated
-    end
-
-    def environment
-        unless defined?(@environment) and @environment
-            @environment = Puppet::Node::Environment.new()
-        end
-        @environment
-    end
+  # Is this an authenticated request?
+  def authenticated?
+    # Double negative, so we just get true or false
+    ! ! authenticated
+  end
 
-    def environment=(env)
-        @environment = if env.is_a?(Puppet::Node::Environment)
-            env
-        else
-            Puppet::Node::Environment.new(env)
-        end
-    end
+  def environment
+    @environment ||= Puppet::Node::Environment.new
+  end
+
+  def environment=(env)
+    @environment = if env.is_a?(Puppet::Node::Environment)
+      env
+    else
+      Puppet::Node::Environment.new(env)
+    end
+  end
+
+  def escaped_key
+    URI.escape(key)
+  end
+
+  # LAK:NOTE This is a messy interface to the cache, and it's only
+  # used by the Configurer class.  I decided it was better to implement
+  # it now and refactor later, when we have a better design, than
+  # to spend another month coming up with a design now that might
+  # not be any better.
+  def ignore_cache?
+    ignore_cache
+  end
+
+  def ignore_terminus?
+    ignore_terminus
+  end
+
+  def initialize(indirection_name, method, key_or_instance, options_or_instance = {})
+    if options_or_instance.is_a? Hash
+      options = options_or_instance
+      @instance = nil
+    else
+      options  = {}
+      @instance = options_or_instance
+    end
+
+    self.indirection_name = indirection_name
+    self.method = method
+
+    set_attributes(options)
+
+    @options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
+
+    if key_or_instance.is_a?(String) || key_or_instance.is_a?(Symbol)
+      key = key_or_instance
+    else
+      @instance ||= key_or_instance
+    end
+
+    if key
+      # If the request key is a URI, then we need to treat it specially,
+      # because it rewrites the key.  We could otherwise strip server/port/etc
+      # info out in the REST class, but it seemed bad design for the REST
+      # class to rewrite the key.
+      if key.to_s =~ /^\w+:\/\// # it's a URI
+        set_uri_key(key)
+      else
+        @key = key
+      end
+    end
+
+    @key = @instance.name if ! @key and @instance
+  end
+
+  # Look up the indirection based on the name provided.
+  def indirection
+    Puppet::Indirector::Indirection.instance(indirection_name)
+  end
 
-    def escaped_key
-        URI.escape(key)
-    end
+  def indirection_name=(name)
+    @indirection_name = name.to_sym
+  end
 
-    # LAK:NOTE This is a messy interface to the cache, and it's only
-    # used by the Configurer class.  I decided it was better to implement
-    # it now and refactor later, when we have a better design, than
-    # to spend another month coming up with a design now that might
-    # not be any better.
-    def ignore_cache?
-        ignore_cache
-    end
 
-    def ignore_terminus?
-        ignore_terminus
-    end
-
-    def initialize(indirection_name, method, key, options = {})
-        options ||= {}
-        raise ArgumentError, "Request options must be a hash, not %s" % options.class unless options.is_a?(Hash)
-
-        self.indirection_name = indirection_name
-        self.method = method
-
-        set_attributes(options)
-
-        @options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
-
-        if key.is_a?(String) or key.is_a?(Symbol)
-            # If the request key is a URI, then we need to treat it specially,
-            # because it rewrites the key.  We could otherwise strip server/port/etc
-            # info out in the REST class, but it seemed bad design for the REST
-            # class to rewrite the key.
-            if key.to_s =~ /^\w+:\/\// # it's a URI
-                set_uri_key(key)
-            else
-                @key = key
-            end
-        else
-            @instance = key
-            @key = @instance.name
-        end
-    end
-
-    # Look up the indirection based on the name provided.
-    def indirection
-        Puppet::Indirector::Indirection.instance(indirection_name)
-    end
+  def model
+    raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless i = indirection
+    i.model
+  end
 
-    def indirection_name=(name)
-        @indirection_name = name.to_sym
+  # Should we allow use of the cached object?
+  def use_cache?
+    if defined?(@use_cache)
+      ! ! use_cache
+    else
+      true
     end
+  end
 
+  # Are we trying to interact with multiple resources, or just one?
+  def plural?
+    method == :search
+  end
+
+  # Create the query string, if options are present.
+  def query_string
+    return "" unless options and ! options.empty?
+    "?" + options.collect do |key, value|
+      case value
+      when nil; next
+      when true, false; value = value.to_s
+      when Fixnum, Bignum, Float; value = value # nothing
+      when String; value = CGI.escape(value)
+      when Symbol; value = CGI.escape(value.to_s)
+      when Array; value = CGI.escape(YAML.dump(value))
+      else
+        raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
+      end
 
-    def model
-        raise ArgumentError, "Could not find indirection '%s'" % indirection_name unless i = indirection
-        i.model
+      "#{key}=#{value}"
+    end.join("&")
+  end
+
+  def to_hash
+    result = options.dup
+
+    OPTION_ATTRIBUTES.each do |attribute|
+      if value = send(attribute)
+        result[attribute] = value
+      end
     end
+    result
+  end
 
-    # Should we allow use of the cached object?
-    def use_cache?
-        if defined?(@use_cache)
-            ! ! use_cache
-        else
-            true
-        end
-    end
-
-    # Are we trying to interact with multiple resources, or just one?
-    def plural?
-        method == :search
-    end
-
-    # Create the query string, if options are present.
-    def query_string
-        return "" unless options and ! options.empty?
-        "?" + options.collect do |key, value|
-            case value
-            when nil; next
-            when true, false; value = value.to_s
-            when Fixnum, Bignum, Float; value = value # nothing
-            when String; value = CGI.escape(value)
-            when Symbol; value = CGI.escape(value.to_s)
-            when Array; value = CGI.escape(YAML.dump(value))
-            else
-                raise ArgumentError, "HTTP REST queries cannot handle values of type '%s'" % value.class
-            end
-
-            "%s=%s" % [key, value]
-        end.join("&")
-    end
-
-    def to_hash
-        result = options.dup
-
-        OPTION_ATTRIBUTES.each do |attribute|
-            if value = send(attribute)
-                result[attribute] = value
-            end
-        end
-        result
-    end
-
-    def to_s
-        return uri if uri
-        return "/%s/%s" % [indirection_name, key]
-    end
+  def to_s
+    return(uri ? uri : "/#{indirection_name}/#{key}")
+  end
 
-    private
+  private
 
-    def set_attributes(options)
-        OPTION_ATTRIBUTES.each do |attribute|
-            if options.include?(attribute)
-                send(attribute.to_s + "=", options[attribute])
-                options.delete(attribute)
-            end
-        end
+  def set_attributes(options)
+    OPTION_ATTRIBUTES.each do |attribute|
+      if options.include?(attribute)
+        send(attribute.to_s + "=", options[attribute])
+        options.delete(attribute)
+      end
     end
+  end
 
-    # Parse the key as a URI, setting attributes appropriately.
-    def set_uri_key(key)
-        @uri = key
-        begin
-            uri = URI.parse(URI.escape(key))
-        rescue => detail
-            raise ArgumentError, "Could not understand URL %s: %s" % [key, detail.to_s]
-        end
-
-        # Just short-circuit these to full paths
-        if uri.scheme == "file"
-            @key = URI.unescape(uri.path)
-            return
-        end
-
-        @server = uri.host if uri.host
-
-        # If the URI class can look up the scheme, it will provide a port,
-        # otherwise it will default to '0'.
-        if uri.port.to_i == 0 and uri.scheme == "puppet"
-            @port = Puppet.settings[:masterport].to_i
-        else
-            @port = uri.port.to_i
-        end
-
-        @protocol = uri.scheme
-        @key = URI.unescape(uri.path.sub(/^\//, ''))
+  # Parse the key as a URI, setting attributes appropriately.
+  def set_uri_key(key)
+    @uri = key
+    begin
+      uri = URI.parse(URI.escape(key))
+    rescue => detail
+      raise ArgumentError, "Could not understand URL #{key}: #{detail}"
+    end
+
+    # Just short-circuit these to full paths
+    if uri.scheme == "file"
+      @key = URI.unescape(uri.path)
+      return
+    end
+
+    @server = uri.host if uri.host
+
+    # If the URI class can look up the scheme, it will provide a port,
+    # otherwise it will default to '0'.
+    if uri.port.to_i == 0 and uri.scheme == "puppet"
+      @port = Puppet.settings[:masterport].to_i
+    else
+      @port = uri.port.to_i
+    end
+
+    @protocol = uri.scheme
+
+    if uri.scheme == 'puppet'
+      @key = URI.unescape(uri.path.sub(/^\//, ''))
+      return
     end
+
+    env, indirector, @key = URI.unescape(uri.path.sub(/^\//, '')).split('/',3)
+    @key ||= ''
+    self.environment = env unless env == ''
+  end
 end