puppet 2.7.26 → 3.0.0.rc4

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

@@ -1,87 +0,0 @@
-require 'openssl'
-require 'puppet'
-require 'xmlrpc/server'
-require 'yaml'
-require 'puppet/network/handler'
-
-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."
-
-    include Puppet::Util
-
-    attr_accessor :ast
-    attr_reader :ca
-
-    @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).
-      Time.now.to_i
-    end
-
-    def initialize(hash = {})
-      args = {}
-
-      @local = hash[:Local]
-
-      args[:Local] = true
-
-      # This is only used by the cfengine module, or if --loadclasses was
-      # specified in +puppet+.
-      args[:Classes] = hash[:Classes] if hash.include?(:Classes)
-    end
-
-    # 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"]
-
-      # Pass the facts to the fact handler
-      Puppet::Node::Facts.indirection.save(Puppet::Node::Facts.new(client, facts)) unless local?
-
-      catalog = Puppet::Resource::Catalog.indirection.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
-
-    #
-    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.safely_load(CGI.unescape(facts))
-        rescue => detail
-          raise XMLRPC::FaultException.new(
-            1, "Could not rebuild facts"
-          )
-        end
-      end
-
-      facts
-    end
-
-    # Translate our configuration appropriately for sending back to a client.
-    def translate(config)
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-require 'puppet/util/instance_loader'
-require 'puppet/reports'
-require 'puppet/network/handler'
-require 'xmlrpc/server'
-
-# 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."
-
-    @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 #{name}"
-      Puppet::Reports.register_report(name, options, &block)
-    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
-      report = CGI.unescape(report) unless @local
-
-      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
-
-    # 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.safely_load(yaml)
-      rescue => detail
-        Puppet.warning "Could not load report: #{detail}"
-        return
-      end
-
-      # 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
-            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
-  end
-end
-

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

@@ -1,33 +0,0 @@
-require 'puppet/run'
-require 'puppet/network/handler'
-require 'xmlrpc/server'
-
-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."
-
-    @interface = XMLRPC::Service::Interface.new("puppetrunner") { |iface|
-      iface.add_method("string run(string, string)")
-    }
-
-    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
-
-      runner = Puppet::Run.new(options)
-
-      runner.run
-
-      runner.status
-    end
-  end
-end
-

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

@@ -1,18 +0,0 @@
-require 'puppet/network/handler'
-require 'xmlrpc/server'
-class Puppet::Network::Handler
-  class Status < Handler
-    desc "A simple interface for testing Puppet connectivity."
-
-    side :client
-
-    @interface = XMLRPC::Service::Interface.new("status") { |iface|
-      iface.add_method("int status()")
-    }
-
-    def status(client = nil, clientip = nil)
-      1
-    end
-  end
-end
-

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

@@ -1,65 +0,0 @@
-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/puppet/network/http_server.rb

@@ -1,3 +0,0 @@
-# Just a stub, so we can correctly scope other classes.
-module Puppet::Network::HTTPServer # :nodoc:
-end

data/lib/puppet/network/http_server/mongrel.rb

@@ -1,129 +0,0 @@
-#!/usr/bin/env ruby
-# File:       06-11-14-mongrel_xmlrpc.rb
-# Author:     Manuel Holtgrewe <purestorm at ggnore.net>
-#
-# Copyright (c) 2006 Manuel Holtgrewe, 2007 Luke Kanies
-#
-# This file is based heavily on a file retrieved from
-# http://ttt.ggnore.net/2006/11/15/xmlrpc-with-mongrel-and-ruby-off-rails/
-
-require 'rubygems'
-require 'mongrel'
-require 'xmlrpc/server'
-require 'puppet/network/xmlrpc/server'
-require 'puppet/network/http_server'
-require 'puppet/network/client_request'
-require 'puppet/network/handler'
-
-require 'resolv'
-
-# This handler can be hooked into Mongrel to accept HTTP requests. After
-# checking whether the request itself is sane, the handler forwards it
-# to an internal instance of XMLRPC::BasicServer to process it.
-#
-# You can access the server by calling the Handler's "xmlrpc_server"
-# attribute accessor method and add XMLRPC handlers there. For example:
-#
-# <pre>
-# handler = XmlRpcHandler.new
-# handler.xmlrpc_server.add_handler("my.add") { |a, b| a.to_i + b.to_i }
-# </pre>
-module Puppet::Network
-  class HTTPServer::Mongrel < ::Mongrel::HttpHandler
-    attr_reader :xmlrpc_server
-
-    def initialize(handlers)
-      if Puppet[:debug]
-        $mongrel_debug_client = true
-        Puppet.debug 'Mongrel client debugging enabled. [$mongrel_debug_client = true].'
-      end
-      # Create a new instance of BasicServer. We are supposed to subclass it
-      # but that does not make sense since we would not introduce any new
-      # behaviour and we have to subclass Mongrel::HttpHandler so our handler
-      # works for Mongrel.
-      @xmlrpc_server = Puppet::Network::XMLRPCServer.new
-      handlers.each do |name|
-        unless handler = Puppet::Network::Handler.handler(name)
-          raise ArgumentError, "Invalid handler #{name}"
-        end
-        @xmlrpc_server.add_handler(handler.interface, handler.new({}))
-      end
-    end
-
-    # This method produces the same results as XMLRPC::CGIServer.serve
-    # from Ruby's stdlib XMLRPC implementation.
-    def process(request, response)
-      # Make sure this has been a POST as required for XMLRPC.
-      request_method = request.params[Mongrel::Const::REQUEST_METHOD] || Mongrel::Const::GET
-      if request_method != "POST"
-        response.start(405) { |head, out| out.write("Method Not Allowed") }
-        return
-      end
-
-      # Make sure the user has sent text/xml data.
-      request_mime = request.params["CONTENT_TYPE"] || "text/plain"
-      if parse_content_type(request_mime).first != "text/xml"
-        response.start(400) { |head, out| out.write("Bad Request") }
-        return
-      end
-
-      # Make sure there is data in the body at all.
-      length = request.params[Mongrel::Const::CONTENT_LENGTH].to_i
-      if length <= 0
-        response.start(411) { |head, out| out.write("Length Required") }
-        return
-      end
-
-      # Check the body to be valid.
-      if request.body.nil? or request.body.size != length
-        response.start(400) { |head, out| out.write("Bad Request") }
-        return
-      end
-
-      info = client_info(request)
-
-      # All checks above passed through
-      response.start(200) do |head, out|
-        head["Content-Type"] = "text/xml; charset=utf-8"
-        begin
-          out.write(@xmlrpc_server.process(request.body, info))
-        rescue => detail
-          puts detail.backtrace
-          raise
-        end
-      end
-    end
-
-    private
-
-    def client_info(request)
-      params = request.params
-      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*(.*)/)
-        client = dn_matchdata[1].to_str
-        valid = (params[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
-      else
-        begin
-          client = Resolv.getname(ip)
-        rescue => detail
-          Puppet.err "Could not resolve #{ip}: #{detail}"
-          client = "unknown"
-        end
-        valid = false
-      end
-
-      info = Puppet::Network::ClientRequest.new(client, ip, valid)
-
-      info
-    end
-
-    # Taken from XMLRPC::ParseContentType
-    def parse_content_type(str)
-      a, *b = str.split(";")
-      return a.strip, *b
-    end
-  end
-end

data/lib/puppet/network/rest_authconfig.rb

@@ -1,102 +0,0 @@
-require 'puppet/network/authconfig'
-
-module Puppet
-  class Network::RestAuthConfig < Network::AuthConfig
-
-    extend MonitorMixin
-    attr_accessor :rights
-
-    DEFAULT_ACL = [
-      { :acl => "~ ^\/catalog\/([^\/]+)$", :method => :find, :allow => '$1', :authenticated => true },
-      { :acl => "~ ^\/node\/([^\/]+)$", :method => :find, :allow => '$1', :authenticated => true },
-      # this one will allow all file access, and thus delegate
-      # to fileserver.conf
-      { :acl => "/file" },
-      { :acl => "/certificate_revocation_list/ca", :method => :find, :authenticated => true },
-      { :acl => "~ ^\/report\/([^\/]+)$", :method => :save, :allow => '$1', :authenticated => true },
-      # These allow `auth any`, because if you can do them anonymously you
-      # should probably also be able to do them when trusted.
-      { :acl => "/certificate/ca", :method => :find, :authenticated => :any },
-      { :acl => "/certificate/", :method => :find, :authenticated => :any },
-      { :acl => "/certificate_request", :method => [:find, :save], :authenticated => :any },
-      { :acl => "/status", :method => [:find], :authenticated => true },
-    ]
-
-    def self.main
-      synchronize do
-        add_acl = @main.nil?
-        super
-        @main.insert_default_acl if add_acl and !@main.exists?
-      end
-      @main
-    end
-
-    def allowed?(request)
-      Puppet.deprecation_warning "allowed? should not be called for REST authorization - use check_authorization instead"
-      check_authorization(request)
-    end
-
-    # check wether this request is allowed in our ACL
-    # raise an Puppet::Network::AuthorizedError if the request
-    # is denied.
-    def check_authorization(indirection, method, key, params)
-      read
-
-      # we're splitting the request in part because
-      # fail_on_deny could as well be called in the XMLRPC context
-      # with a ClientRequest.
-
-      if authorization_failure_exception = @rights.is_request_forbidden_and_why?(indirection, method, key, params)
-        Puppet.warning("Denying access: #{authorization_failure_exception}")
-        raise authorization_failure_exception
-      end
-    end
-
-    def initialize(file = nil, parsenow = true)
-      super(file || Puppet[:rest_authconfig], parsenow)
-
-      # if we didn't read a file (ie it doesn't exist)
-      # make sure we can create some default rights
-      @rights ||= Puppet::Network::Rights.new
-    end
-
-    def parse
-      super()
-      insert_default_acl
-    end
-
-    # force regular ACLs to be present
-    def insert_default_acl
-      if exists? then
-        reason = "none were found in '#{@file}'"
-      else
-        reason = "#{Puppet[:rest_authconfig]} doesn't exist"
-      end
-
-      DEFAULT_ACL.each do |acl|
-        unless rights[acl[:acl]]
-          Puppet.info "Inserting default '#{acl[:acl]}' (auth #{acl[:authenticated]}) ACL because #{reason}"
-          mk_acl(acl)
-        end
-      end
-      # queue an empty (ie deny all) right for every other path
-      # actually this is not strictly necessary as the rights system
-      # denies not explicitely allowed paths
-      unless rights["/"]
-        rights.newright("/")
-        rights.restrict_authenticated("/", :any)
-      end
-    end
-
-    def mk_acl(acl)
-      @rights.newright(acl[:acl])
-      @rights.allow(acl[:acl], acl[:allow] || "*")
-
-      if method = acl[:method]
-        method = [method] unless method.is_a?(Array)
-        method.each { |m| @rights.restrict_method(acl[:acl], m) }
-      end
-      @rights.restrict_authenticated(acl[:acl], acl[:authenticated]) unless acl[:authenticated].nil?
-    end
-  end
-end