puppet 0.18.4 → 0.22.4

data/lib/puppet/server/rights.rb

@@ -1,78 +0,0 @@
-require 'ipaddr'
-require 'puppet/server/authstore'
-
-module Puppet
-class Server
-    # Define a set of rights and who has access to them.
-    class 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 < 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
-end
-end
-#
-# $Id: rights.rb 1129 2006-04-21 19:14:59Z luke $

data/lib/puppet/server/servlet.rb

@@ -1,274 +0,0 @@
-require 'xmlrpc/server'
-
-module Puppet
-class Server
-    class ServletError < RuntimeError; end
-    class Servlet < XMLRPC::WEBrickServlet
-        ERR_UNAUTHORIZED = 30
-
-        attr_accessor :request
-
-        # this is just a duplicate of the normal method; it's here for
-        # debugging when i need it
-        def self.get_instance(server, *options)
-            self.new(server, *options)
-        end
-
-        # This is a hackish way to avoid an auth message every time we have a
-        # normal operation
-        def self.log(msg)
-            unless defined? @logs
-                @logs = {}
-            end
-            if @logs.include?(msg)
-                @logs[msg] += 1
-            else
-                Puppet.info msg
-                @logs[msg] = 1
-            end
-        end
-
-        def add_handler(interface, handler)
-            @loadedhandlers << interface.prefix
-            super
-        end
-
-        # Verify that our client has access.  We allow untrusted access to
-        # puppetca methods but no others.
-        def authorize(request, method)
-            namespace = method.sub(/\..+/, '')
-            client = request.peeraddr[2]
-            if defined? @client and @client
-                client = @client
-            end
-            ip = request.peeraddr[3]
-            if request.client_cert
-                begin
-                if @puppetserver.authconfig.exists?
-                    allowed = @puppetserver.authconfig.allowed?(method, client, ip)
-
-                    if allowed
-                        Puppet.info "Allowing %s(%s) trusted access to %s" %
-                            [client, ip, method]
-                        return true
-                    else
-                        Puppet.info "Denying %s(%s) trusted access to %s" %
-                            [client, ip, method]
-                        return false
-                    end
-                else
-                    # This is pretty hackish, but...
-                    # This means we can't actually test this method at this point.
-                    # The next release of Puppet will almost definitely require
-                    # this file to exist or will default to denying all access.
-                    if Puppet.name == "puppetmasterd" or defined? Test::Unit::TestCase
-                        Puppet.info "Allowing %s(%s) trusted access to %s" %
-                            [client, ip, method]
-                        return true
-                    else
-                        Puppet.info "Denying %s(%s) trusted access to %s on %s" %
-                            [client, ip, method, Puppet.name]
-                        return false
-                    end
-                end
-                rescue => detail
-                    puts detail
-                    puts detail.backtrace
-                    raise
-                end
-            else
-                if method =~ /^puppetca\./
-                    Puppet.notice "Allowing %s(%s) untrusted access to CA methods" %
-                        [client, ip]
-                else
-                    Puppet.err "Unauthenticated client %s(%s) cannot call %s" %
-                        [client, ip, method]
-                    return false
-                end
-            end
-        end
-
-        def available?(method)
-            namespace = method.sub(/\..+/, '')
-            client = request.peeraddr[2]
-            ip = request.peeraddr[3]
-            if @loadedhandlers.include?(namespace)
-                return true
-            else
-                Puppet.warning "Client %s(%s) requested unavailable functionality %s" %
-                    [client, ip, namespace]
-                return false
-            end
-        end
-
-        def initialize(server, handlers)
-            @puppetserver = server
-            @notified = {}
-            # the servlet base class does not consume any arguments
-            # and its BasicServer base class only accepts a 'class_delim'
-            # option which won't change in Puppet at all
-            # thus, we don't need to pass any args to our base class,
-            # and we can consume them all ourselves
-            super()
-
-            @loadedhandlers = []
-            handlers.each { |handler|
-                #Puppet.debug "adding handler for %s" % handler.class
-                self.add_handler(handler.class.interface, handler)
-            }
-
-            # Initialize these to nil, but they will get set to values
-            # by the 'service' method.  These have to instance variables
-            # because I don't have a clear line from the service method to
-            # the service hook.
-            @request = nil
-            @client = nil
-            @clientip = nil
-
-            self.set_service_hook { |obj, *args|
-                if @client and @clientip
-                    args.push(@client, @clientip)
-                end
-                begin
-                    obj.call(*args)
-                rescue XMLRPC::FaultException
-                    raise
-                rescue Puppet::Server::AuthorizationError => detail
-                    #Puppet.warning obj.inspect
-                    #Puppet.warning args.inspect
-                    Puppet.err "Permission denied: %s" % detail.to_s
-                    raise XMLRPC::FaultException.new(
-                        1, detail.to_s
-                    )
-                rescue Puppet::Error => detail
-                    #Puppet.warning obj.inspect
-                    #Puppet.warning args.inspect
-                    Puppet.err detail.to_s
-                    raise XMLRPC::FaultException.new(
-                        1, detail.to_s
-                    )
-                rescue => detail
-                    #Puppet.warning obj.inspect
-                    #Puppet.warning args.inspect
-                    puts detail.inspect
-                    Puppet.err "Could not call: %s" % detail.to_s
-                    raise XMLRPC::FaultException.new(1, detail.to_s)
-                end
-            }
-        end
-
-        # Handle the actual request.  This does some basic collection of
-        # data, and then just calls the parent method.
-        def service(request, response)
-            @request = request
-
-            # The only way that @client can be nil is if the request is local.
-            if peer = request.peeraddr
-                @client = peer[2]
-                @clientip = peer[3]
-            else
-                raise XMLRPC::FaultException.new(
-                    ERR_UNCAUGHT_EXCEPTION,
-                    "Could not retrieve client information"
-                )
-            end
-
-            # If they have a certificate (which will almost always be true)
-            # then we get the hostname from the cert, instead of via IP
-            # info
-            if cert = request.client_cert
-                nameary = cert.subject.to_a.find { |ary|
-                    ary[0] == "CN"
-                }   
-
-                if nameary.nil?
-                    Puppet.warning "Could not retrieve server name from cert"
-                else
-                    unless @client == nameary[1]
-                        Puppet.debug "Overriding %s with cert name %s" %
-                            [@client, nameary[1]]
-                        @client = nameary[1]
-                    end
-                end
-            end
-            begin
-                super
-            rescue => detail
-                Puppet.err "Could not service request: %s: %s" %
-                    [detail.class, detail]
-            end
-            @client = nil
-            @clientip = nil
-            @request = nil
-        end
-
-        private
-
-        # this is pretty much just a copy of the original method but with more
-        # feedback
-        # here's where we have our authorization hooks
-        def dispatch(methodname, *args)
-
-            if defined? @request and @request
-                unless self.available?(methodname)
-                    raise XMLRPC::FaultException.new(
-                        ERR_UNAUTHORIZED,
-                        "Functionality %s not available" %
-                            methodname.sub(/\..+/, '')
-                    )
-                end
-                unless self.authorize(@request, methodname)
-                    raise XMLRPC::FaultException.new(
-                        ERR_UNAUTHORIZED,
-                        "Host %s not authorized to call %s" %
-                            [@request.host, methodname]
-                    )
-                end
-            else
-                raise Puppet::DevError, "Did not get request in dispatch"
-            end
-
-            #Puppet.warning "dispatch on %s called with %s" %
-            #    [methodname, args.inspect]
-            for name, obj in @handler
-                if obj.kind_of? Proc
-                    unless methodname == name
-                        #Puppet.debug "obj is proc but %s != %s" %
-                        #    [methodname, name]
-                        next
-                    end
-                else
-                    unless methodname =~ /^#{name}(.+)$/
-                        #Puppet.debug "methodname did not match"
-                        next
-                    end
-                    unless obj.respond_to? $1
-                        #Puppet.debug "methodname does not respond to %s" % $1
-                        next
-                    end
-                    obj = obj.method($1)
-                end
-
-                if check_arity(obj, args.size)
-                    if @service_hook.nil?
-                        return obj.call(*args) 
-                    else
-                        return @service_hook.call(obj, *args)
-                    end
-                else
-                    Puppet.debug "arity is incorrect"
-                end
-            end 
-
-            if @default_handler.nil?
-                raise XMLRPC::FaultException.new(
-                    ERR_METHOD_MISSING,
-                    "Method #{methodname} missing or wrong number of parameters!"
-                )
-            else
-                @default_handler.call(methodname, *args) 
-            end
-        end
-    end
-end
-end

data/lib/puppet/statechange.rb

@@ -1,129 +0,0 @@
-# the class responsible for actually doing any work
-
-# enables no-op and logging/rollback
-
-module Puppet
-    # Handle all of the work around performing an actual change,
-    # including calling 'sync' on the states and producing events.
-	class StateChange
-        attr_accessor :is, :should, :type, :path, :state, :transaction, :changed
-        
-        # The log file generated when this object was changed.
-        attr_reader :report
-
-        def initialize(state)
-            @state = state
-            @path = [state.path,"change"].flatten
-            @is = state.is
-
-            if state.insync?
-                raise Puppet::Error.new(
-                    "Tried to create a change for in-sync state %s" % state.name
-                )
-            end
-            @should = state.should
-
-            @changed = false
-        end
-
-        # Perform the actual change.  This method can go either forward or
-        # backward, and produces an event.
-        def go
-            if @state.insync?
-                @state.info "Already in sync"
-                return nil
-            end
-
-            if @state.noop
-                @state.log "is %s, should be %s (noop)" %
-                    [state.is_to_s, state.should_to_s]
-                #@state.debug "%s is noop" % @state
-                return nil
-            end
-
-            #@state.info "Is: %s, Should: %s" %
-            #    [@state.is.inspect, @state.should.inspect]
-
-            # The transaction catches any exceptions here.
-            events = @state.sync
-            if events.nil?
-                return nil
-            end
-
-            if events.is_a?(Array)
-                if events.empty?
-                    return nil
-                end
-            else
-                events = [events]
-            end
-            
-            return events.collect { |event|
-                # default to a simple event type
-                if ! event.is_a?(Symbol)
-                    @state.warning("State '%s' returned invalid event '%s'; resetting to default" %
-                        [@state.class,event])
-
-                    event = @state.parent.class.name.id2name + "_changed"
-                end
-
-                # i should maybe include object type, but the event type
-                # should basically point to that, right?
-                    #:state => @state,
-                    #:object => @state.parent,
-                @report = @state.log(@state.change_to_s)
-                Puppet::Event.new(
-                    :event => event,
-                    :change => self,
-                    :transaction => @transaction,
-                    :source => @state.parent,
-                    :message => self.to_s
-                )
-            }
-        end
-
-        def forward
-            #@state.debug "moving change forward"
-
-            unless defined? @transaction
-                raise Puppet::Error,
-                    "StateChange '%s' tried to be executed outside of transaction" %
-                    self
-            end
-
-            return self.go
-        end
-
-        # Switch the goals of the state, thus running the change in reverse.
-        def backward
-            @state.should = @is
-            @state.retrieve
-
-            unless defined? @transaction
-                raise Puppet::Error,
-                    "StateChange '%s' tried to be executed outside of transaction" %
-                    self
-            end
-            unless @state.insync?
-                @state.info "Backing %s" % self
-                return self.go
-            else
-                @state.debug "rollback is already in sync: %s vs. %s" %
-                    [@state.is.inspect, @state.should.inspect]
-                return nil
-            end
-        end
-        
-        def noop
-            return @state.noop
-        end
-
-        def to_s
-            return "change %s.%s(%s)" %
-                [@transaction.object_id, self.object_id, @state.change_to_s]
-            #return "change %s.%s" % [@transaction.object_id, self.object_id]
-        end
-	end
-end
-
-# $Id: statechange.rb 1336 2006-06-29 16:05:52Z luke $