puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,247 @@
+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
+
+  # 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 (#{header}) are functional on this machine"
+  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 (#{header}) that doesn't correspond to a format we support" 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)
+    indirection, method, key, params = uri2indirection(http_method(request), path(request), params(request))
+
+    check_authorization(indirection, method, key, params)
+
+    send("do_#{method}", indirection, key, params, request, response)
+  rescue SystemExit,NoMemoryError
+    raise
+  rescue Exception => e
+    return do_exception(response, e)
+  end
+
+  # Set the response up, with the body and status.
+  def set_response(response, body, status = 200)
+    raise NotImplementedError
+  end
+
+  # Set the specified format as the content type of the response.
+  def set_content_type(response, format)
+    raise NotImplementedError
+  end
+
+  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)
+      if Puppet[:trace] then
+        puts exception.backtrace
+        Puppet.err(exception.backtrace.join("\n"))
+      end
+      Puppet.err(exception)
+    end
+    set_content_type(response, "text/plain")
+    set_response(response, exception.to_s, status)
+  end
+
+  def model(indirection_name)
+    raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless indirection = Puppet::Indirector::Indirection.instance(indirection_name.to_sym)
+    indirection.model
+  end
+
+  # Execute our find.
+  def do_find(indirection_name, key, params, request, response)
+    unless result = model(indirection_name).indirection.find(key, params)
+      Puppet.info("Could not find #{indirection_name} for '#{key}'")
+      return do_exception(response, "Could not find #{indirection_name} #{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)
+
+    if result.respond_to?(:render)
+      set_response(response, result.render(format))
+    else
+      set_response(response, result)
+    end
+  end
+
+  # Execute our head.
+  def do_head(indirection_name, key, params, request, response)
+    unless self.model(indirection_name).indirection.head(key, params)
+      Puppet.info("Could not find #{indirection_name} for '#{key}'")
+      return do_exception(response, "Could not find #{indirection_name} #{key}", 404)
+    end
+
+    # No need to set a response because no response is expected from a
+    # HEAD request.  All we need to do is not die.
+  end
+
+  # Execute our search.
+  def do_search(indirection_name, key, params, request, response)
+    model  = self.model(indirection_name)
+    result = model.indirection.search(key, params)
+
+    if result.nil?
+      return do_exception(response, "Could not find instances in #{indirection_name} with '#{key}'", 404)
+    end
+
+    format = format_to_use(request)
+    set_content_type(response, format)
+
+    set_response(response, model.render_multiple(format, result))
+  end
+
+  # Execute our destroy.
+  def do_destroy(indirection_name, key, params, request, response)
+    result = model(indirection_name).indirection.destroy(key, params)
+
+    return_yaml_response(response, result)
+  end
+
+  # Execute our save.
+  def do_save(indirection_name, key, params, request, response)
+    data = body(request).to_s
+    raise ArgumentError, "No data to save" if !data or data.empty?
+
+    format = request_format(request)
+    obj = model(indirection_name).convert_from(format, data)
+    result = model(indirection_name).indirection.save(obj, key)
+    return_yaml_response(response, result)
+  end
+
+  # 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 #{result[:ip]}: #{detail}"
+    end
+    result[:ip]
+  end
+
+  private
+
+  def return_yaml_response(response, body)
+    set_content_type(response, Puppet::Network::FormatHandler.format("yaml"))
+    set_response(response, body.to_yaml)
+  end
+
+  def get?(request)
+    http_method(request) == 'GET'
+  end
+
+  def put?(request)
+    http_method(request) == 'PUT'
+  end
+
+  def delete?(request)
+    http_method(request) == 'DELETE'
+  end
+
+  # methods to be overridden by the including web server class
+
+  def http_method(request)
+    raise NotImplementedError
+  end
+
+  def path(request)
+    raise NotImplementedError
+  end
+
+  def request_key(request)
+    raise NotImplementedError
+  end
+
+  def body(request)
+    raise NotImplementedError
+  end
+
+  def params(request)
+    raise NotImplementedError
+  end
+
+  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

data/lib/vendor/puppet/network/http/mongrel/rest.rb

@@ -0,0 +1,99 @@
+require 'puppet/network/http/handler'
+
+class Puppet::Network::HTTP::MongrelREST < Mongrel::HttpHandler
+
+  include Puppet::Network::HTTP::Handler
+
+  ACCEPT_HEADER = "HTTP_ACCEPT".freeze # yay, zed's a crazy-man
+
+  def initialize(args={})
+    super()
+    initialize_for_puppet(args)
+  end
+
+  def accept_header(request)
+    request.params[ACCEPT_HEADER]
+  end
+
+  def content_type_header(request)
+    request.params["HTTP_CONTENT_TYPE"]
+  end
+
+  # which HTTP verb was used in this request
+  def http_method(request)
+    request.params[Mongrel::Const::REQUEST_METHOD]
+  end
+
+  # Return the query params for this request.  We had to expose this method for
+  # testing purposes.
+  def params(request)
+    params = Mongrel::HttpRequest.query_parse(request.params["QUERY_STRING"])
+    params.merge!(Mongrel::HttpRequest.query_parse(body(request))) if http_method(request).upcase == 'POST'
+
+    params = decode_params(params)
+    params.merge(client_info(request))
+  end
+
+  # what path was requested?
+  def path(request)
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    #x = '/' + request.params[Mongrel::Const::REQUEST_PATH]
+    request.params[Mongrel::Const::REQUEST_PATH]
+  end
+
+  # return the request body
+  def body(request)
+    body = request.body.read
+    # We rewind the body, since read on a StringIO is destructive, and
+    # subsequent reads will return an empty string.
+    request.body.rewind
+
+    body
+  end
+
+  def set_content_type(response, format)
+    response.header['Content-Type'] = format_to_mime(format)
+  end
+
+  # produce the body of the response
+  def set_response(response, result, status = 200)
+    # Set the 'reason' (or 'message', as it's called in Webrick), when
+    # we have a failure, unless we're on a version of mongrel that doesn't
+    # support this.
+    if status < 300
+      unless result.is_a?(File)
+        response.start(status) { |head, body| body.write(result) }
+      else
+        response.start(status) { |head, body| }
+        response.send_status(result.stat.size)
+        response.send_header
+        response.send_file(result.path)
+      end
+    else
+      begin
+        response.start(status,false,result) { |head, body| body.write(result) }
+      rescue ArgumentError
+        response.start(status)              { |head, body| body.write(result) }
+      end
+    end
+  end
+
+  def client_info(request)
+    result = {}
+    params = request.params
+    result[:ip] = params["HTTP_X_FORWARDED_FOR"] ? params["HTTP_X_FORWARDED_FOR"].split(',').last.strip : params["REMOTE_ADDR"]
+
+    # JJM #906 The following dn.match regular expression is forgiving
+    # enough to match the two Distinguished Name string contents
+    # coming from Apache, Pound or other reverse SSL proxies.
+    if dn = params[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
+      result[:node] = dn_matchdata[1].to_str
+      result[:authenticated] = (params[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
+    else
+      result[:node] = resolve_node(result)
+      result[:authenticated] = false
+    end
+
+    result
+  end
+end

data/lib/vendor/puppet/network/http/mongrel.rb

@@ -0,0 +1,55 @@
+require 'mongrel' if Puppet.features.mongrel?
+
+require 'puppet/network/http/mongrel/rest'
+
+class Puppet::Network::HTTP::Mongrel
+  def initialize(args = {})
+    @listening = false
+  end
+
+  def listen(args = {})
+    raise ArgumentError, ":protocols must be specified." if !args[:protocols] or args[:protocols].empty?
+    raise ArgumentError, ":address must be specified." unless args[:address]
+    raise ArgumentError, ":port must be specified." unless args[:port]
+    raise "Mongrel server is already listening" if listening?
+
+    @protocols = args[:protocols]
+    @xmlrpc_handlers = args[:xmlrpc_handlers]
+    @server = Mongrel::HttpServer.new(args[:address], args[:port])
+    setup_handlers
+
+    @listening = true
+    @server.run
+  end
+
+  def unlisten
+    raise "Mongrel server is not listening" unless listening?
+    @server.stop
+    @server = nil
+    @listening = false
+  end
+
+  def listening?
+    @listening
+  end
+
+  private
+
+  def setup_handlers
+    # Register our REST support at /
+    klass = class_for_protocol(:rest)
+    @server.register('/', klass.new(:server => @server))
+
+    setup_xmlrpc_handlers if @protocols.include?(:xmlrpc) and ! @xmlrpc_handlers.empty?
+  end
+
+  # Use our existing code to provide the xmlrpc backward compatibility.
+  def setup_xmlrpc_handlers
+    @server.register('/RPC2', Puppet::Network::HTTPServer::Mongrel.new(@xmlrpc_handlers))
+  end
+
+  def class_for_protocol(protocol)
+    return Puppet::Network::HTTP::MongrelREST if protocol.to_sym == :rest
+    raise ArgumentError, "Unknown protocol [#{protocol}]."
+  end
+end

data/lib/vendor/puppet/network/http/rack/httphandler.rb

@@ -0,0 +1,16 @@
+require 'openssl'
+require 'puppet/ssl/certificate'
+
+class Puppet::Network::HTTP::RackHttpHandler
+
+  def initialize
+  end
+
+  # do something useful with request (a Rack::Request) and use
+  # response to fill your Rack::Response
+  def process(request, response)
+    raise NotImplementedError, "Your RackHttpHandler subclass is supposed to override service(request)"
+  end
+
+end
+

data/lib/vendor/puppet/network/http/rack/rest.rb

@@ -0,0 +1,100 @@
+require 'puppet/network/http/handler'
+require 'puppet/network/http/rack/httphandler'
+
+class Puppet::Network::HTTP::RackREST < Puppet::Network::HTTP::RackHttpHandler
+
+  include Puppet::Network::HTTP::Handler
+
+  HEADER_ACCEPT = 'HTTP_ACCEPT'.freeze
+  ContentType = 'Content-Type'.freeze
+
+  CHUNK_SIZE = 8192
+
+  class RackFile
+    def initialize(file)
+      @file = file
+    end
+
+    def each
+      while chunk = @file.read(CHUNK_SIZE)
+        yield chunk
+      end
+    end
+
+    def close
+      @file.close
+    end
+  end
+
+  def initialize(args={})
+    super()
+    initialize_for_puppet(args)
+  end
+
+  def set_content_type(response, format)
+    response[ContentType] = format_to_mime(format)
+  end
+
+  # produce the body of the response
+  def set_response(response, result, status = 200)
+    response.status = status
+    unless result.is_a?(File)
+      response.write result
+    else
+      response["Content-Length"] = result.stat.size.to_s
+      response.body = RackFile.new(result)
+    end
+  end
+
+  # Retrieve the accept header from the http request.
+  def accept_header(request)
+    request.env[HEADER_ACCEPT]
+  end
+
+  # Retrieve the accept header from the http request.
+  def content_type_header(request)
+    request.content_type
+  end
+
+  # Return which HTTP verb was used in this request.
+  def http_method(request)
+    request.request_method
+  end
+
+  # Return the query params for this request.
+  def params(request)
+    result = decode_params(request.params)
+    result.merge(extract_client_info(request))
+  end
+
+  # what path was requested? (this is, without any query parameters)
+  def path(request)
+    request.path
+  end
+
+  # return the request body
+  # request.body has some limitiations, so we need to concat it back
+  # into a regular string, which is something puppet can use.
+  def body(request)
+    request.body.read
+  end
+
+  def extract_client_info(request)
+    result = {}
+    result[:ip] = request.ip
+
+    # if we find SSL info in the headers, use them to get a hostname.
+    # try this with :ssl_client_header, which defaults should work for
+    # Apache with StdEnvVars.
+    if dn = request.env[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
+      result[:node] = dn_matchdata[1].to_str
+      result[:authenticated] = (request.env[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
+    else
+      result[:node] = resolve_node(result)
+      result[:authenticated] = false
+    end
+
+    result
+  end
+
+end

data/lib/vendor/puppet/network/http/rack/xmlrpc.rb

@@ -0,0 +1,65 @@
+require 'puppet/network/http/rack/httphandler'
+require 'puppet/network/xmlrpc/server'
+require 'resolv'
+
+class Puppet::Network::HTTP::RackXMLRPC < Puppet::Network::HTTP::RackHttpHandler
+  def initialize(handlers)
+    @xmlrpc_server = Puppet::Network::XMLRPCServer.new
+    handlers.each do |name|
+      Puppet.debug "  -> register xmlrpc namespace #{name}"
+      unless handler = Puppet::Network::Handler.handler(name)
+        raise ArgumentError, "Invalid XMLRPC handler #{name}"
+      end
+      @xmlrpc_server.add_handler(handler.interface, handler.new({}))
+    end
+    super()
+  end
+
+  def process(request, response)
+    # errors are sent as text/plain
+    response['Content-Type'] = 'text/plain'
+    if not request.post?
+      response.status = 405
+      response.write 'Method Not Allowed'
+      return
+    end
+    if request.media_type != "text/xml"
+      response.status = 400
+      response.write 'Bad Request'
+      return
+    end
+
+    # get auth/certificate data
+    client_request = build_client_request(request)
+
+    response_body = @xmlrpc_server.process(request.body.read, client_request)
+
+    response.status = 200
+    response['Content-Type'] =  'text/xml; charset=utf-8'
+    response.write response_body
+  end
+
+  def build_client_request(request)
+    ip = request.ip
+
+    # if we find SSL info in the headers, use them to get a hostname.
+    # try this with :ssl_client_header, which defaults should work for
+    # Apache with StdEnvVars.
+    if dn = request.env[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
+      node = dn_matchdata[1].to_str
+      authenticated = (request.env[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
+    else
+      begin
+        node = Resolv.getname(ip)
+      rescue => detail
+        Puppet.err "Could not resolve #{ip}: #{detail}"
+        node = "unknown"
+      end
+      authenticated = false
+    end
+
+    Puppet::Network::ClientRequest.new(node, ip, authenticated)
+  end
+
+end
+

data/lib/vendor/puppet/network/http/rack.rb

@@ -0,0 +1,65 @@
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+
+require 'puppet/network/http'
+require 'puppet/network/http/rack/rest'
+require 'puppet/network/http/rack/xmlrpc'
+
+# An rack application, for running the Puppet HTTP Server.
+class Puppet::Network::HTTP::Rack
+
+  def initialize(args)
+    raise ArgumentError, ":protocols must be specified." if !args[:protocols] or args[:protocols].empty?
+    protocols = args[:protocols]
+
+    # Always prepare a REST handler
+    @rest_http_handler = Puppet::Network::HTTP::RackREST.new
+    protocols.delete :rest
+
+    # Prepare the XMLRPC handler, for backward compatibility (if requested)
+    @xmlrpc_path = '/RPC2'
+    if args[:protocols].include?(:xmlrpc)
+      raise ArgumentError, "XMLRPC was requested, but no handlers were given" if !args.include?(:xmlrpc_handlers)
+
+      @xmlrpc_http_handler = Puppet::Network::HTTP::RackXMLRPC.new(args[:xmlrpc_handlers])
+      protocols.delete :xmlrpc
+    end
+
+    raise ArgumentError, "there were unknown :protocols specified." if !protocols.empty?
+  end
+
+  # The real rack application (which needs to respond to call).
+  # The work we need to do, roughly is:
+  # * Read request (from env) and prepare a response
+  # * Route the request to the correct handler
+  # * Return the response (in rack-format) to our caller.
+  def call(env)
+    request = Rack::Request.new(env)
+    response = Rack::Response.new
+    Puppet.debug 'Handling request: %s %s' % [request.request_method, request.fullpath]
+
+    # if we shall serve XMLRPC, have /RPC2 go to the xmlrpc handler
+    if @xmlrpc_http_handler and @xmlrpc_path == request.path_info[0, @xmlrpc_path.size]
+      handler = @xmlrpc_http_handler
+    else
+      # everything else is handled by the new REST handler
+      handler = @rest_http_handler
+    end
+
+    begin
+      handler.process(request, response)
+    rescue => detail
+      # Send a Status 500 Error on unhandled exceptions.
+      response.status = 500
+      response['Content-Type'] = 'text/plain'
+      response.write 'Internal Server Error: "%s"' % detail.message
+      # log what happened
+      Puppet.err "Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"" % detail.message
+      Puppet.err "Backtrace:"
+      detail.backtrace.each { |line| Puppet.err " > #{line}" }
+    end
+    response.finish
+  end
+end
+