puppet 0.24.9 → 0.25.0

data/lib/puppet/indirector/key/ca.rb

@@ -0,0 +1,12 @@
+require 'puppet/indirector/ssl_file'
+require 'puppet/ssl/key'
+
+class Puppet::SSL::Key::Ca < Puppet::Indirector::SslFile
+    desc "Manage the CA's private on disk.  This terminus *only* works
+        with the CA key, because that's the only key that the CA ever interacts
+        with."
+
+    store_in :privatekeydir
+
+    store_ca_at :cakey
+end

data/lib/puppet/indirector/key/file.rb

@@ -0,0 +1,42 @@
+require 'puppet/indirector/ssl_file'
+require 'puppet/ssl/key'
+
+class Puppet::SSL::Key::File < Puppet::Indirector::SslFile
+    desc "Manage SSL private and public keys on disk."
+
+    store_in :privatekeydir
+    store_ca_at :cakey
+
+    # Where should we store the public key?
+    def public_key_path(name)
+        if ca?(name)
+            Puppet[:capub]
+        else
+            File.join(Puppet[:publickeydir], name.to_s + ".pem")
+        end
+    end
+
+    # Remove the public key, in addition to the private key
+    def destroy(request)
+        super
+
+        return unless FileTest.exist?(public_key_path(request.key))
+
+        begin
+            File.unlink(public_key_path(request.key))
+        rescue => detail
+            raise Puppet::Error, "Could not remove %s public key: %s" % [request.key, detail]
+        end
+    end
+
+    # Save the public key, in addition to the private key.
+    def save(request)
+        super
+
+        begin
+            Puppet.settings.writesub(:publickeydir, public_key_path(request.key)) { |f| f.print request.instance.content.public_key.to_pem }
+        rescue => detail
+            raise Puppet::Error, "Could not write %s: %s" % [request.key, detail]
+        end
+    end
+end

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

@@ -0,0 +1,13 @@
+require 'puppet/rails/host'
+require 'puppet/indirector/active_record'
+require 'puppet/node'
+
+class Puppet::Node::ActiveRecord < Puppet::Indirector::ActiveRecord
+    use_ar_model Puppet::Rails::Host
+
+    def find(request)
+        node = super
+        node.fact_merge
+        node
+    end
+end

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

@@ -9,7 +9,7 @@ class Puppet::Node::Ldap < Puppet::Indirector::Ldap
 
     # The attributes that Puppet class information is stored in.
     def class_attributes
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
+        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
         x = Puppet[:ldapclassattrs].split(/\s*,\s*/)
     end
 

data/lib/puppet/indirector/queue.rb

@@ -0,0 +1,83 @@
+require 'puppet/indirector/terminus'
+require 'puppet/util/queue'
+require 'puppet/util'
+
+# Implements the <tt>:queue</tt> abstract indirector terminus type, for storing
+# model instances to a message queue, presumably for the purpose of out-of-process
+# handling of changes related to the model.
+#
+# Relies upon Puppet::Util::Queue for registry and client object management,
+# and specifies a default queue type of <tt>:stomp</tt>, appropriate for use with a variety of message brokers.
+#
+# It's up to the queue client type to instantiate itself correctly based on Puppet configuration information.
+#
+# A single queue client is maintained for the abstract terminus, meaning that you can only use one type
+# of queue client, one message broker solution, etc., with the indirection mechanism.
+#
+# Per-indirection queues are assumed, based on the indirection name.  If the <tt>:catalog</tt> indirection makes
+# use of this <tt>:queue</tt> terminus, queue operations work against the "catalog" queue.  It is up to the queue
+# 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
+
+    def initialize(*args)
+        super
+        raise ArgumentError, "Queueing requires json support" unless Puppet.features.json?
+    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(:json))
+            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
+
+    def self.queue
+        indirection_name
+    end
+
+    def queue
+        self.class.queue
+    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(:json, 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
+    end
+end

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

@@ -45,7 +45,7 @@ class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
 
     # Handle the parsing of the reports attribute.
     def reports
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
+        # 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

@@ -0,0 +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)
+end

data/lib/puppet/indirector/request.rb

@@ -1,9 +1,18 @@
+require 'cgi'
+require 'uri'
 require 'puppet/indirector'
 
-# Provide any attributes or functionality needed for indirected
-# instances.
+# This class encapsulates all of the information you need to make an
+# 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 :indirection_name, :key, :method, :options, :instance, :node, :ip, :authenticated
+    attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
+
+    attr_accessor :server, :port, :uri, :protocol
+
+    attr_reader :indirection_name
+
+    OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
 
     # Is this an authenticated request?
     def authenticated?
@@ -11,24 +20,59 @@ class Puppet::Indirector::Request
         ! ! authenticated
     end
 
+    def environment
+        unless defined?(@environment) and @environment
+            @environment = Puppet::Node::Environment.new()
+        end
+        @environment
+    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, options = {})
         options ||= {}
         raise ArgumentError, "Request options must be a hash, not %s" % options.class unless options.is_a?(Hash)
 
-        @indirection_name, @method = indirection_name, method
+        self.indirection_name = indirection_name
+        self.method = method
 
-        @options = options.inject({}) do |result, ary|
-            param, value = ary
-            if respond_to?(param.to_s + "=")
-                send(param.to_s + "=", value)
-            else
-                result[param] = value
-            end
-            result
-        end
+        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)
-            @key = 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
         else
             @instance = key
             @key = @instance.name
@@ -37,6 +81,105 @@ class Puppet::Indirector::Request
 
     # Look up the indirection based on the name provided.
     def indirection
-        Puppet::Indirector::Indirection.instance(@indirection_name)
+        Puppet::Indirector::Indirection.instance(indirection_name)
+    end
+
+    def indirection_name=(name)
+        @indirection_name = name.to_sym
+    end
+
+
+    def model
+        raise ArgumentError, "Could not find indirection '%s'" % indirection_name unless i = indirection
+        i.model
+    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
+
+    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
+    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(/^\//, ''))
     end
 end

data/lib/puppet/indirector/rest.rb

@@ -1,56 +1,94 @@
 require 'net/http'
 require 'uri'
 
+require 'puppet/network/http_pool'
+require 'puppet/network/http/api/v1'
+
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
+    include Puppet::Network::HTTP::API::V1
+
+    class << self
+        attr_reader :server_setting, :port_setting
+    end
+
+    # Specify the setting that we should use to get the server name.
+    def self.use_server_setting(setting)
+        @server_setting = setting
+    end
 
-    def rest_connection_details
-        { :host => Puppet[:server], :port => Puppet[:masterport].to_i }
+    def self.server
+        return Puppet.settings[server_setting || :server]
     end
 
-    def network_fetch(path)
-        network {|conn| conn.get("/#{path}").body }
+    # Specify the setting that we should use to get the port.
+    def self.use_port_setting(setting)
+        @port_setting = setting
+    end
+
+    def self.port
+        return Puppet.settings[port_setting || :masterport].to_i
+    end
+
+    # Figure out the content type, turn that into a format, and use the format
+    # to extract the body of the response.
+    def deserialize(response, multiple = false)
+        case response.code
+        when "404"
+            return nil
+        when /^2/
+            unless response['content-type']
+                raise "No content type in http response; cannot parse"
+            end
+
+            content_type = response['content-type'].gsub(/\s*;.*$/,'') # strip any appended charset
+
+            # Convert the response to a deserialized object.
+            if multiple
+                model.convert_from_multiple(content_type, response.body)
+            else
+                model.convert_from(content_type, response.body)
+            end
+        else
+            # Raise the http error if we didn't get a 'success' of some kind.
+            message = "Error %s on SERVER: %s" % [response.code, response.message]
+            raise Net::HTTPError.new(message, response)
+        end
     end
-    
-    def network_delete(path)
-        network {|conn| conn.delete("/#{path}").body }
+
+    # Provide appropriate headers.
+    def headers
+        {"Accept" => model.supported_formats.join(", ")}
     end
-    
-    def network_put(path, data)
-        network {|conn| conn.put("/#{path}", data).body }
+
+    def network(request)
+        Puppet::Network::HttpPool.http_instance(request.server || self.class.server, request.port || self.class.port)
     end
-    
+
     def find(request)
-        network_result = network_fetch("#{indirection.name}/#{request.key}")
-        raise YAML.load(network_result) if exception?(network_result)
-        indirection.model.from_yaml(network_result)
+        deserialize network(request).get(indirection2uri(request), headers)
     end
-    
+
     def search(request)
-        network_results = network_fetch("#{indirection.name}s/#{request.key}")
-        raise YAML.load(network_results) if exception?(network_results)
-        YAML.load(network_results.to_s).collect {|result| indirection.model.from_yaml(result) }
+        unless result = deserialize(network(request).get(indirection2uri(request), headers), true)
+            return []
+        end
+        return result
     end
-    
+
     def destroy(request)
-        network_result = network_delete("#{indirection.name}/#{request.key}")
-        raise YAML.load(network_result) if exception?(network_result)
-        YAML.load(network_result.to_s)      
+        raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
+        deserialize network(request).delete(indirection2uri(request), headers)
     end
-    
+
     def save(request)
-        network_result = network_put("#{indirection.name}/", request.instance.to_yaml)
-        raise YAML.load(network_result) if exception?(network_result)
-        indirection.model.from_yaml(network_result)
-    end
-    
-  private
-  
-    def network(&block)
-        Net::HTTP.start(rest_connection_details[:host], rest_connection_details[:port]) {|conn| yield(conn) }
-    end
-  
-    def exception?(yaml_string)
-        yaml_string =~ %r{--- !ruby/exception}
+        raise ArgumentError, "PUT does not accept options" unless request.options.empty?
+        deserialize network(request).put(indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
+    end
+
+    private
+
+    def environment
+        Puppet::Node::Environment.new
     end
 end