puppet 0.24.9 → 0.25.0

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

@@ -62,19 +62,19 @@ class Puppet::Network::Handler
             # Pass the facts to the fact handler
             Puppet::Node::Facts.new(client, facts).save unless local?
 
-            catalog = Puppet::Node::Catalog.find(client)
+            catalog = Puppet::Resource::Catalog.find(client)
 
             case format
-            when "yaml":
+            when "yaml"
                 return CGI.escape(catalog.extract.to_yaml(:UseBlock => true))
-            when "marshal":
+            when "marshal"
                 return CGI.escape(Marshal.dump(catalog.extract))
             else
                 raise "Invalid markup format '%s'" % format
             end
         end
 
-        # 
+        #
         def decode_facts(facts)
             if @local
                 # we don't need to do anything, since we should already

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

@@ -79,7 +79,7 @@ class Puppet::Network::Handler
 
         # 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/network/handler/resource.rb

@@ -7,7 +7,7 @@ class Puppet::Network::Handler
         desc "An interface for interacting with client-based resources that can
         be used for querying or managing remote machines without using Puppet's
         central server tools.
-        
+
         The ``describe`` and ``list`` methods return TransBuckets containing
         TransObject instances (``describe`` returns a single TransBucket),
         and the ``apply`` method accepts a TransBucket of TransObjects and
@@ -29,7 +29,7 @@ class Puppet::Network::Handler
             unless local?
                 begin
                     case format
-                    when "yaml":
+                    when "yaml"
                         bucket = YAML::load(Base64.decode64(bucket))
                     else
                         raise Puppet::Error, "Unsupported format '%s'" % format
@@ -44,7 +44,7 @@ class Puppet::Network::Handler
             # And then apply the catalog.  This way we're reusing all
             # the code in there.  It should probably just be separated out, though.
             transaction = catalog.apply
-            
+
             # And then clean up
             catalog.clear(true)
 
@@ -59,7 +59,7 @@ class Puppet::Network::Handler
             Puppet.info "Describing %s[%s]" % [type.to_s.capitalize, name]
             @local = true unless client
             typeklass = nil
-            unless typeklass = Puppet.type(type)
+            unless typeklass = Puppet::Type.type(type)
                 raise Puppet::Error, "Puppet type %s is unsupported" % type
             end
 
@@ -68,15 +68,11 @@ class Puppet::Network::Handler
             retrieve ||= :all
             ignore ||= []
 
-            if obj = typeklass[name]
-                obj[:check] = retrieve
-            else
-                begin
-                    obj = typeklass.create(:name => name, :check => retrieve)
-                rescue Puppet::Error => detail
-                    raise Puppet::Error, "%s[%s] could not be created: %s" %
-                        [type, name, detail]
-                end
+            begin
+                obj = typeklass.create(:name => name, :check => retrieve)
+            rescue Puppet::Error => detail
+                raise Puppet::Error, "%s[%s] could not be created: %s" %
+                    [type, name, detail]
             end
 
             unless obj
@@ -103,7 +99,7 @@ class Puppet::Network::Handler
 
             unless @local
                 case format
-                when "yaml":
+                when "yaml"
                     trans = Base64.encode64(YAML::dump(trans))
                 else
                     raise XMLRPC::FaultException.new(
@@ -128,7 +124,7 @@ class Puppet::Network::Handler
         def list(type, ignore = [], base = nil, format = "yaml", client = nil, clientip = nil)
             @local = true unless client
             typeklass = nil
-            unless typeklass = Puppet.type(type)
+            unless typeklass = Puppet::Type.type(type)
                 raise Puppet::Error, "Puppet type %s is unsupported" % type
             end
 
@@ -147,7 +143,7 @@ class Puppet::Network::Handler
 
             unless @local
                 case format
-                when "yaml":
+                when "yaml"
                     begin
                     bucket = Base64.encode64(YAML::dump(bucket))
                     rescue => detail
@@ -177,14 +173,14 @@ class Puppet::Network::Handler
         end
 
         # Deal with ignore parameters.
-        def handleignore(children, path, ignore)            
-            ignore.each { |ignore|                
+        def handleignore(children, path, ignore)
+            ignore.each { |ignore|
                 Dir.glob(File.join(path,ignore), File::FNM_DOTMATCH) { |match|
                     children.delete(File.basename(match))
-                }                
+                }
             }
             return children
-        end  
+        end
 
         def to_s
             "resource"

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

@@ -1,3 +1,5 @@
+require 'puppet/agent/runner'
+
 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.
@@ -13,51 +15,16 @@ class Puppet::Network::Handler
         # 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)
-            # We need to retrieve the client
-            master = Puppet::Network::Client.client(:Master).instance
-
-            unless master
-                raise MissingMasterError, "Could not find the master client"
-            end
-
-            if Puppet::Util::Pidlock.new(Puppet[:puppetdlockfile]).locked?
-                Puppet.notice "Could not trigger run; already running"
-                return "running"
-            end
-
-            if tags == ""
-                tags = nil
-            end
-
-            if ignoreschedules == ""
-                ignoreschedules == nil
-            end
-
-            msg = ""
-            if client
-                msg = "%s(%s) " % [client, clientip]
-            end
-            msg += "triggered run" %
-            if tags
-                msg += " with tags %s" % tags
-            end
-
-            if ignoreschedules
-                msg += " ignoring schedules"
-            end
+            options = {}
+            options[:tags] = tags if tags
+            options[:ignoreschedules] = ignoreschedules if ignoreschedules
+            options[:background] = !fg
 
-            Puppet.notice msg
+            runner = Puppet::Agent::Runner.new(options)
 
-            # And then we need to tell it to run, with this extra info.
-            if fg
-                master.run(:tags => tags, :ignoreschedules => ignoreschedules)
-            else
-                Puppet.newthread do
-                    master.run(:tags => tags, :ignoreschedules => ignoreschedules)
-                end
-            end
+            runner.run
 
-            return "success"
+            return runner.status
         end
     end
 end

data/lib/puppet/network/http.rb

@@ -1,13 +1,13 @@
-class Puppet::Network::HTTP
+module Puppet::Network::HTTP
     def self.server_class_by_type(kind)
         case kind.to_sym
-        when :webrick:
+        when :webrick
             require 'puppet/network/http/webrick'
             return Puppet::Network::HTTP::WEBrick
-        when :mongrel:
+        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 
+            return Puppet::Network::HTTP::Mongrel
         else
             raise ArgumentError, "Unknown HTTP server name [#{kind}]"
         end

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

@@ -0,0 +1,4 @@
+require 'puppet/network/http'
+
+class Puppet::Network::HTTP::API
+end

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

@@ -0,0 +1,65 @@
+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
+        }
+    }
+
+    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+$/
+
+        method = indirection_method(http_method, indirection)
+
+        params[:environment] = environment
+
+        raise ArgumentError, "No request key specified in %s" % uri if key == "" or key.nil?
+
+        key = URI.unescape(key)
+
+        Puppet::Indirector::Request.new(indirection, method, key, params)
+    end
+
+    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}"
+    end
+
+    def indirection_method(http_method, indirection)
+        unless METHOD_MAP[http_method]
+            raise ArgumentError, "No support for http method %s" % http_method
+        end
+
+        unless method = METHOD_MAP[http_method][plurality(indirection)]
+            raise ArgumentError, "No support for plural %s operations" % http_method
+        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"
+
+        result = (indirection =~ /s$/) ? :plural : :singular
+
+        indirection.sub!(/s$/, '') if result
+
+        result
+    end
+end

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

@@ -1,70 +1,168 @@
+module Puppet::Network::HTTP
+end
+
+require 'puppet/network/http/api/v1'
+require 'puppet/network/rest_authorization'
+require 'puppet/network/rights'
+require 'resolv'
+
 module Puppet::Network::HTTP::Handler
+    include Puppet::Network::HTTP::API::V1
+    include Puppet::Network::RestAuthorization
+
+    attr_reader :server, :handler
 
-    def initialize_for_puppet(args = {})
-        raise ArgumentError unless @server = args[:server]
-        raise ArgumentError unless @handler = args[:handler]
-        @model = find_model_for_handler(@handler)
+    # Retrieve the accept header from the http request.
+    def accept_header(request)
+        raise NotImplementedError
+    end
+
+    # Retrieve the Content-Type header from the http request.
+    def content_type_header(request)
+        raise NotImplementedError
+    end
+
+    # Which format to use when serializing our response or interpreting the request.  
+    # IF the client provided a Content-Type use this, otherwise use the Accept header
+    # and just pick the first value.
+    def format_to_use(request)
+        unless header = accept_header(request)
+            raise ArgumentError, "An Accept header must be provided to pick the right format"
+        end
+
+        format = nil
+        header.split(/,\s*/).each do |name|
+            next unless format = Puppet::Network::FormatHandler.format(name)
+            next unless format.suitable?
+            return format
+        end
+
+        raise "No specified acceptable formats (%s) are functional on this machine" % header
+    end
+
+    def request_format(request)
+        if header = content_type_header(request)
+            header.gsub!(/\s*;.*$/,'') # strip any charset
+            format = Puppet::Network::FormatHandler.mime(header)
+            raise "Client sent a mime-type (%s) that doesn't correspond to a format we support" % header if format.nil?
+            return format.name.to_s if format.suitable?
+        end
+
+        raise "No Content-Type header was received, it isn't possible to unserialize the request"
+    end
+
+    def format_to_mime(format)
+        format.is_a?(Puppet::Network::Format) ? format.mime : format
+    end
+
+    def initialize_for_puppet(server)
+        @server = server
     end
 
     # handle an HTTP request
     def process(request, response)
-        return do_find(request, response)       if get?(request)    and singular?(request)
-        return do_search(request, response)     if get?(request)    and plural?(request)
-        return do_destroy(request, response)    if delete?(request) and singular?(request)
-        return do_save(request, response)       if put?(request)    and singular?(request)
-        raise ArgumentError, "Did not understand HTTP #{http_method(request)} request for '#{path(request)}'"
+        indirection_request = uri2indirection(http_method(request), path(request), params(request))
+
+        check_authorization(indirection_request)
+
+        send("do_%s" % indirection_request.method, indirection_request, request, response)
     rescue Exception => e
-        return do_exception(request, response, e)
+        return do_exception(response, e)
     end
 
-  private
+    # Set the response up, with the body and status.
+    def set_response(response, body, status = 200)
+        raise NotImplementedError
+    end
 
-    def model
-        @model
+    # Set the specified format as the content type of the response.
+    def set_content_type(response, format)
+        raise NotImplementedError
     end
 
-    def do_find(request, response)
-        key = request_key(request) || raise(ArgumentError, "Could not locate lookup key in request path [#{path(request)}]")
-        args = params(request)
-        result = model.find(key, args).to_yaml
-        encode_result(request, response, result)
+    def do_exception(response, exception, status=400)
+        if exception.is_a?(Puppet::Network::AuthorizationError)
+            # make sure we return the correct status code
+            # for authorization issues
+            status = 403 if status == 400
+        end
+        if exception.is_a?(Exception)
+            puts exception.backtrace if Puppet[:trace]
+            Puppet.err(exception)
+        end
+        set_content_type(response, "text/plain")
+        set_response(response, exception.to_s, status)
     end
 
-    def do_search(request, response)
-        args = params(request)
-        result = model.search(args).collect {|result| result.to_yaml }.to_yaml
-        encode_result(request, response, result) 
+    # Execute our find.
+    def do_find(indirection_request, request, response)
+        unless result = indirection_request.model.find(indirection_request.key, indirection_request.to_hash)
+            return do_exception(response, "Could not find %s %s" % [indirection_request.indirection_name, indirection_request.key], 404)
+        end
+
+        # The encoding of the result must include the format to use,
+        # and it needs to be used for both the rendering and as
+        # the content type.
+        format = format_to_use(request)
+        set_content_type(response, format)
+
+        set_response(response, result.render(format))
+    end
+
+    # Execute our search.
+    def do_search(indirection_request, request, response)
+        result = indirection_request.model.search(indirection_request.key, indirection_request.to_hash)
+
+        if result.nil? or (result.is_a?(Array) and result.empty?)
+            return do_exception(response, "Could not find instances in %s with '%s'" % [indirection_request.indirection_name, indirection_request.to_hash.inspect], 404)
+        end
+
+        format = format_to_use(request)
+        set_content_type(response, format)
+
+        set_response(response, indirection_request.model.render_multiple(format, result))
     end
 
-    def do_destroy(request, response)
-        key = request_key(request) || raise(ArgumentError, "Could not locate lookup key in request path [#{path(request)}]")
-        args = params(request)
-        result = model.destroy(key, args)
-        encode_result(request, response, YAML.dump(result))
+    # Execute our destroy.
+    def do_destroy(indirection_request, request, response)
+        result = indirection_request.model.destroy(indirection_request.key, indirection_request.to_hash)
+
+        return_yaml_response(response, result)
     end
 
-    def do_save(request, response)
+    # Execute our save.
+    def do_save(indirection_request, request, response)
         data = body(request).to_s
         raise ArgumentError, "No data to save" if !data or data.empty?
-        args = params(request)
-        obj = model.from_yaml(data)
-        result = save_object(obj, args).to_yaml
-        encode_result(request, response, result)
+
+        format = request_format(request)
+        obj = indirection_request.model.convert_from(format, data)
+        result = save_object(indirection_request, obj)
+        return_yaml_response(response, result)
     end
 
-    # LAK:NOTE This has to be here for testing; it's a stub-point so
-    # we keep infinite recursion from happening.
-    def save_object(object, args)
-        object.save(args)
+    # resolve node name from peer's ip address
+    # this is used when the request is unauthenticated
+    def resolve_node(result)
+        begin
+            return Resolv.getname(result[:ip])
+        rescue => detail
+            Puppet.err "Could not resolve %s: %s" % [result[:ip], detail]
+        end
+        return result[:ip]
     end
 
-    def do_exception(request, response, exception, status=404)
-        encode_result(request, response, exception.to_yaml, status)
+  private
+
+    def return_yaml_response(response, body)
+        set_content_type(response, Puppet::Network::FormatHandler.format("yaml"))
+        set_response(response, body.to_yaml)
     end
 
-    def find_model_for_handler(handler)
-        Puppet::Indirector::Indirection.model(handler) || 
-            raise(ArgumentError, "Cannot locate indirection [#{handler}].")
+    # LAK:NOTE This has to be here for testing; it's a stub-point so
+    # we keep infinite recursion from happening.
+    def save_object(ind_request, object)
+        object.save(ind_request.to_hash)
     end
 
     def get?(request)
@@ -79,27 +177,15 @@ module Puppet::Network::HTTP::Handler
         http_method(request) == 'DELETE'
     end
 
-    def singular?(request)
-        %r{/#{@handler.to_s}$}.match(path(request))
-    end
-
-    def plural?(request)
-        %r{/#{@handler.to_s}s$}.match(path(request))
-    end
-
     # methods to be overridden by the including web server class
 
-    def register_handler
-        raise NotImplementedError
-    end
-
     def http_method(request)
         raise NotImplementedError
     end
 
     def path(request)
         raise NotImplementedError
-    end    
+    end
 
     def request_key(request)
         raise NotImplementedError
@@ -113,7 +199,28 @@ module Puppet::Network::HTTP::Handler
         raise NotImplementedError
     end
 
-    def encode_result(request, response, result, status = 200)
-        raise NotImplementedError
+    def decode_params(params)
+        params.inject({}) do |result, ary|
+            param, value = ary
+            next result if param.nil? || param.empty?
+
+            param = param.to_sym
+
+            # These shouldn't be allowed to be set by clients
+            # in the query string, for security reasons.
+            next result if param == :node
+            next result if param == :ip
+            value = CGI.unescape(value)
+            if value =~ /^---/
+                value = YAML.load(value)
+            else
+                value = true if value == "true"
+                value = false if value == "false"
+                value = Integer(value) if value =~ /^\d+$/
+                value = value.to_f if value =~ /^\d+\.\d+$/
+            end
+            result[param] = value
+            result
+        end
     end
 end