puppet 0.18.4 → 0.22.4

data/lib/puppet/{server → network/handler}/runner.rb

@@ -1,7 +1,5 @@
-module Puppet
-class Server
-    class MissingMasterError < RuntimeError # Cannot find the master client
-    end
+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
         @interface = XMLRPC::Service::Interface.new("puppetrunner") { |iface|
@@ -10,15 +8,15 @@ class Server
 
         # Run the client configuration right now, optionally specifying
         # tags and whether to ignore schedules
-        def run(tags = [], ignoreschedules = false, fg = true, client = nil, clientip = nil)
+        def run(tags = nil, ignoreschedules = false, fg = true, client = nil, clientip = nil)
             # We need to retrieve the client
-            master = Puppet::Client::MasterClient.instance
+            master = Puppet::Network::Client.client(:Master).instance
 
             unless master
                 raise MissingMasterError, "Could not find the master client"
             end
 
-            if master.locked?
+            if Puppet::Util::Pidlock.new(Puppet[:puppetdlockfile]).locked?
                 Puppet.notice "Could not trigger run; already running"
                 return "running"
             end
@@ -31,19 +29,21 @@ class Server
                 ignoreschedules == nil
             end
 
+            msg = ""
             if client
-                msg = "%s(%s) triggered run" % [client, clientip]
-                if tags
-                    msg += " with tags %s" % tags.join(", ")
-                end
-
-                if ignoreschedules
-                    msg += " without schedules"
-                end
+                msg = "%s(%s) " % [client, clientip]
+            end
+            msg += "triggered run" %
+            if tags
+                msg += " with tags %s" % tags
+            end
 
-                Puppet.notice msg
+            if ignoreschedules
+                msg += " without schedules"
             end
 
+            Puppet.notice msg
+
             # And then we need to tell it to run, with this extra info.
             if fg
                 master.run(tags, ignoreschedules)
@@ -57,6 +57,5 @@ class Server
         end
     end
 end
-end
 
-# $Id: runner.rb 1325 2006-06-28 15:17:56Z luke $
+# $Id: runner.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -0,0 +1,13 @@
+class Puppet::Network::Handler
+    class Status < Handler
+        @interface = XMLRPC::Service::Interface.new("status") { |iface|
+            iface.add_method("int status()")
+        }
+
+        def status(client = nil, clientip = nil)
+            return 1
+        end
+    end
+end
+
+# $Id: status.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/network/rights.rb

@@ -0,0 +1,74 @@
+require 'ipaddr'
+require 'puppet/network/authstore'
+
+# Define a set of rights and who has access to them.
+class Puppet::Network::Rights < Hash
+    # We basically just proxy directly to our rights.  Each Right stores
+    # its own auth abilities.
+    [:allow, :allowed?, :deny].each do |method|
+        define_method(method) do |name, *args|
+            name = name.intern if name.is_a? String
+
+            if obj = right(name)
+                obj.send(method, *args)
+            else
+                raise ArgumentError, "Unknown right '%s'" % name
+            end
+        end
+    end
+
+    def [](name)
+        name = name.intern if name.is_a? String
+        super(name)
+    end
+
+    # Define a new right to which access can be provided.
+    def newright(name)
+        name = name.intern if name.is_a? String
+        shortname = Right.shortname(name)
+        if self.include? name
+            raise ArgumentError, "Right '%s' is already defined" % name
+        else
+            self[name] = Right.new(name, shortname)
+        end
+    end
+
+    private
+
+    # Retrieve a right by name.
+    def right(name)
+        name = name.intern if name.is_a? String
+        self[name]
+    end
+
+    # A right.
+    class Right < Puppet::Network::AuthStore
+        attr_accessor :name, :shortname
+
+        Puppet::Util.logmethods(self, true)
+
+        def self.shortname(name)
+            name.to_s[0..0]
+        end
+
+        def initialize(name, shortname = nil)
+            @name = name
+            @shortname = shortname
+            unless @shortname
+                @shortname = Right.shortname(name)
+            end
+            super()
+        end
+
+        def to_s
+            "access[%s]" % @name
+        end
+
+        # There's no real check to do at this point
+        def valid?
+            true
+        end
+    end
+end
+
+# $Id: rights.rb 2180 2007-02-08 02:22:57Z luke $

data/lib/puppet/network/server.rb

@@ -0,0 +1,5 @@
+# Just a stub, so we can correctly scope other classes.
+module Puppet::Network::Server # :nodoc:
+end
+
+# $Id: server.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -0,0 +1,138 @@
+#!/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
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# 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/server'
+require 'puppet/network/xmlrpc/server'
+require 'puppet/network/client_request'
+
+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>
+class Puppet::Network::Server
+    class MongrelHandler < Mongrel::HttpHandler
+        attr_reader :xmlrpc_server
+
+        def initialize(handlers)
+            # 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, args|
+                unless handler = Puppet::Network::Handler.handler(name)
+                    raise ArgumentError, "Invalid handler %s" % name
+                end
+                @xmlrpc_server.add_handler(handler.interface, handler.new(args))
+            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" then
+                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" then
+                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 then
+                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 then
+                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["REMOTE_ADDR"]
+            if dn = params["HTTP_X_CLIENT_DN"]
+                client = dn.sub("/CN=", '')
+                valid = true
+            else
+                client = Resolv.getname(ip)
+                valid = false
+            end
+
+            info = Puppet::Network::ClientRequest.new(client, ip, valid)
+
+            return info
+        end
+
+        # Taken from XMLRPC::ParseContentType
+        def parse_content_type(str)
+            a, *b = str.split(";")
+            return a.strip, *b
+        end  
+    end
+end
+
+# $Id: mongrel.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/network/server/webrick.rb

@@ -0,0 +1,153 @@
+require 'puppet'
+require 'puppet/daemon'
+require 'webrick'
+require 'webrick/https'
+
+require 'puppet/sslcertificates/support'
+require 'puppet/network/xmlrpc/webrick_servlet'
+require 'puppet/network/server'
+require 'puppet/network/client'
+
+module Puppet
+    class ServerError < RuntimeError; end
+    module Network
+        # The old-school, pure ruby webrick server, which is the default serving
+        # mechanism.
+        class Server::WEBrick < WEBrick::HTTPServer
+            include Puppet::Daemon
+            include Puppet::SSLCertificates::Support
+
+            # Read the CA cert and CRL and populate an OpenSSL::X509::Store
+            # with them, with flags appropriate for checking client 
+            # certificates for revocation
+            def x509store
+                if Puppet[:cacrl] == 'none'
+                    # No CRL, no store needed
+                    return nil
+                end
+                unless File.exist?(Puppet[:cacrl])
+                    raise Puppet::Error, "Could not find CRL"
+                end
+                crl = OpenSSL::X509::CRL.new(File.read(Puppet[:cacrl]))
+                store = OpenSSL::X509::Store.new
+                store.purpose = OpenSSL::X509::PURPOSE_ANY
+                store.flags = OpenSSL::X509::V_FLAG_CRL_CHECK_ALL|OpenSSL::X509::V_FLAG_CRL_CHECK
+                unless self.ca_cert
+                    raise Puppet::Error, "No CA certificate"
+                end
+
+                store.add_file(Puppet[:localcacert])
+                store.add_crl(crl)
+                return store
+            end
+
+            # Set up the http log.
+            def httplog
+                args = []
+
+                # yuck; separate http logs
+                file = nil
+                Puppet.config.use(:puppet, :certificates, Puppet.name)
+                if Puppet[:name] == "puppetmasterd"
+                    file = Puppet[:masterhttplog]
+                else
+                    file = Puppet[:httplog]
+                end
+
+                args << file
+                if Puppet[:debug]
+                    args << WEBrick::Log::DEBUG
+                end
+
+                log = WEBrick::Log.new(*args)
+
+
+                return log
+            end
+
+            # Create our server, yo.
+            def initialize(hash = {})
+                Puppet.info "Starting server for Puppet version %s" % Puppet.version
+
+                if handlers = hash[:Handlers]
+                    handler_instances = setup_handlers(handlers)
+                else
+                    raise ServerError, "A server must have handlers"
+                end
+
+                unless self.read_cert
+                    if ca = handler_instances.find { |handler| handler.is_a?(Puppet::Network::Handler.ca) }
+                        request_cert(ca)
+                    else
+                        raise Puppet::Error, "No certificate and no CA; cannot get cert"
+                    end
+                end
+
+                setup_webrick(hash)
+
+                super(hash)
+
+                Puppet.info "Listening on port %s" % hash[:Port]
+
+                # this creates a new servlet for every connection,
+                # but all servlets have the same list of handlers
+                # thus, the servlets can have their own state -- passing
+                # around the requests and such -- but the handlers
+                # have a global state
+
+                # mount has to be called after the server is initialized
+                servlet = Puppet::Network::XMLRPC::WEBrickServlet.new(
+                    handler_instances)
+                self.mount("/RPC2", servlet)
+            end
+
+            # Create a ca client to set up our cert for us.
+            def request_cert(ca)
+                client = Puppet::Network::Client.ca.new(:CA => ca)
+                unless client.request_cert
+                    raise Puppet::Error, "Could get certificate"
+                end
+            end
+
+            # Create all of our handler instances.
+            def setup_handlers(handlers)
+                unless handlers.is_a?(Hash)
+                    raise ServerError, "Handlers must have arguments"
+                end
+
+                handlers.collect { |handler, args|
+                    hclass = nil
+                    unless hclass = Handler.handler(handler)
+                        raise ServerError, "Invalid handler %s" % handler
+                    end
+                    hclass.new(args)
+                }
+            end
+
+            # Handle all of the many webrick arguments.
+            def setup_webrick(hash)
+                hash[:Port] ||= Puppet[:masterport]
+                hash[:Logger] ||= self.httplog
+                hash[:AccessLog] ||= [
+                    [ self.httplog, WEBrick::AccessLog::COMMON_LOG_FORMAT ],
+                    [ self.httplog, WEBrick::AccessLog::REFERER_LOG_FORMAT ]
+                ]
+
+                hash[:SSLCertificateStore] = x509store
+                hash[:SSLCertificate] = self.cert
+                hash[:SSLPrivateKey] = self.key
+                hash[:SSLStartImmediately] = true
+                hash[:SSLEnable] = true
+                hash[:SSLCACertificateFile] = Puppet[:localcacert]
+                hash[:SSLVerifyClient] = OpenSSL::SSL::VERIFY_PEER
+                hash[:SSLCertName] = nil
+
+                if addr = Puppet[:bindaddress] and addr != ""
+                    hash[:BindAddress] = addr
+                end
+            end
+        end
+    end
+end
+
+# $Id: webrick.rb 2259 2007-03-06 19:03:05Z luke $