puppet 0.18.4 → 0.22.4

data/lib/puppet/rails/rails_object.rb

@@ -1,42 +0,0 @@
-require 'puppet'
-require 'puppet/rails/rails_parameter'
-
-#RailsParameter = Puppet::Rails::RailsParameter
-class Puppet::Rails::RailsObject < ActiveRecord::Base
-    has_many :rails_parameters, :dependent => :delete_all
-    serialize :tags, Array
-
-    belongs_to :host
-
-    # Add a set of parameters.
-    def addparams(params)
-        params.each do |pname, pvalue|
-            rails_parameters.build(
-                :name => pname,
-                :value => pvalue
-            )
-
-            #self.rails_parameters << pobj
-        end
-    end
-
-    # Convert our object to a trans_object.  Do not retain whether the object
-    # is collectable, though, since that would cause it to get stripped
-    # from the configuration.
-    def to_trans
-        obj = Puppet::TransObject.new(name(), ptype())
-
-        [:file, :line, :tags].each do |method|
-            if val = send(method)
-                obj.send(method.to_s + "=", val)
-            end
-        end
-        rails_parameters.each do |param|
-            obj[param.name] = param.value
-        end
-
-        return obj
-    end
-end
-
-# $Id: rails_object.rb 1192 2006-05-14 02:42:21Z luke $

data/lib/puppet/rails/rails_parameter.rb

@@ -1,5 +0,0 @@
-class Puppet::Rails::RailsParameter < ActiveRecord::Base
-    belongs_to :rails_objects
-end
-
-# $Id: rails_parameter.rb 1187 2006-05-13 04:52:34Z luke $

data/lib/puppet/server.rb

@@ -1,196 +0,0 @@
-# the server
-#
-# allow things to connect to us and communicate, and stuff
-
-require 'puppet'
-require 'puppet/daemon'
-
-$noservernetworking = false
-
-begin
-    require 'webrick'
-    require 'webrick/https'
-    require 'cgi'
-    require 'xmlrpc/server'
-    require 'xmlrpc/client'
-rescue LoadError => detail
-    $noservernetworking = detail
-end
-
-module Puppet
-    class ServerError < RuntimeError; end
-    #---------------------------------------------------------------
-    if $noservernetworking
-        Puppet.err "Could not create server: %s" % $noservernetworking
-        class Server; end
-    else
-        class Server < WEBrick::HTTPServer
-            include Puppet::Daemon
-
-            Puppet.config.setdefaults(:puppetd,
-                :listen => [false, "Whether puppetd should listen for
-                    connections.  If this is true, then by default only the
-                    ``runner`` server is started, which allows remote authorized
-                    and authenticated nodes to connect and trigger ``puppetd``
-                    runs."]
-            )
-
-            # Create our config object if necessary.  This works even if
-            # there's no configuration file.
-            def authconfig
-                unless defined? @authconfig
-                    @authconfig = Puppet::Server::AuthConfig.new()
-                end
-
-                @authconfig
-            end
-
-            def initialize(hash = {})
-                Puppet.info "Starting server for Puppet version %s" % Puppet.version
-                daemonize = nil
-                if hash.include?(:Daemonize)
-                    daemonize = hash[:Daemonize]
-                end
-
-                # FIXME we should have some kind of access control here, using
-                # :RequestHandler
-                hash[:Port] ||= Puppet[:masterport]
-                hash[:Logger] ||= self.httplog
-                hash[:AccessLog] ||= [
-                    [ self.httplog, WEBrick::AccessLog::COMMON_LOG_FORMAT ],
-                    [ self.httplog, WEBrick::AccessLog::REFERER_LOG_FORMAT ]
-                ]
-
-                if hash.include?(:Handlers)
-                    unless hash[:Handlers].is_a?(Hash)
-                        raise ServerError, "Handlers must have arguments"
-                    end
-
-                    @handlers = hash[:Handlers].collect { |handler, args|
-                        hclass = nil
-                        unless hclass = Handler.handler(handler)
-                            raise ServerError, "Invalid handler %s" % handler
-                        end
-                        hclass.new(args)
-                    }
-                else
-                    raise ServerError, "A server must have handlers"
-                end
-
-                # okay, i need to retrieve my cert and set it up, somehow
-                # the default case will be that i'm also the ca
-                if ca = @handlers.find { |handler| handler.is_a?(Puppet::Server::CA) }
-                    @driver = ca
-                    @secureinit = true
-                    self.fqdn
-                else
-                    if hash.include?(:NoSecureInit)
-                        @secureinit = false
-                    else
-                        @secureinit = true
-                    end
-                end
-
-                unless self.readcert
-                    unless self.requestcert
-                        raise Puppet::Error, "Cannot start without certificates"
-                    end
-                end
-
-                hash[:SSLCertificate] = @cert
-                hash[:SSLPrivateKey] = @key
-                hash[:SSLStartImmediately] = true
-                hash[:SSLEnable] = true
-                hash[:SSLCACertificateFile] = @cacertfile
-                hash[:SSLVerifyClient] = OpenSSL::SSL::VERIFY_PEER
-                hash[:SSLCertName] = nil
-
-                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
-                self.mount("/RPC2", Puppet::Server::Servlet, @handlers)
-            end
-
-            # the base class for the different handlers
-            class Handler
-                attr_accessor :server
-                @subclasses = []
-
-                def self.each
-                    @subclasses.each { |c| yield c }
-                end
-
-                def self.handler(name)
-                    name = name.to_s.downcase
-                    @subclasses.find { |h|
-                        h.name.to_s.downcase == name
-                    }
-                end
-
-                def self.inherited(sub)
-                    @subclasses << sub
-                end
-
-                def self.interface
-                    if defined? @interface
-                        return @interface
-                    else
-                        raise Puppet::DevError, "Handler %s has no defined interface" %
-                            self
-                    end
-                end
-
-                def self.name
-                    unless defined? @name
-                        @name = self.to_s.sub(/.+::/, '').intern
-                    end
-
-                    return @name
-                end
-
-                def initialize(hash = {})
-                end
-            end
-
-            
-            class ServerStatus < Handler
-
-                @interface = XMLRPC::Service::Interface.new("status") { |iface|
-                    iface.add_method("int status()")
-                }
-
-                @name = :Status
-
-                def status(status = nil, client = nil, clientip = nil)
-                    return 1
-                end
-            end
-
-        end
-    end
-
-    #---------------------------------------------------------------
-end
-
-require 'puppet/server/authstore'
-require 'puppet/server/authconfig'
-require 'puppet/server/servlet'
-require 'puppet/server/master'
-require 'puppet/server/ca'
-require 'puppet/server/fileserver'
-require 'puppet/server/filebucket'
-require 'puppet/server/pelement'
-require 'puppet/server/runner'
-require 'puppet/server/logger'
-require 'puppet/server/report'
-require 'puppet/client'
-
-# $Id: server.rb 1339 2006-06-29 20:32:17Z luke $

data/lib/puppet/server/authconfig.rb

@@ -1,177 +0,0 @@
-require 'puppet/parsedfile'
-require 'puppet/server/rights'
-
-module Puppet
-class Server
-
-class ConfigurationError < Puppet::Error; end
-
-class AuthConfig < Puppet::ParsedFile
-    Puppet.config.setdefaults(:puppet,
-        :authconfig => [ "$confdir/namespaceauth.conf",
-            "The configuration file that defines the rights to the different
-            namespaces and methods.  This can be used as a coarse-grained
-            authorization system for both ``puppetd`` and ``puppetmasterd``."
-        ]
-    )
-
-    # Just proxy the setting methods to our rights stuff
-    [:allow, :deny].each do |method|
-        define_method(method) do |*args|
-            @rights.send(method, *args)
-        end         
-    end
-
-    # Here we add a little bit of semantics.  They can set auth on a whole namespace
-    # or on just a single method in the namespace.
-    def allowed?(name, host, ip)
-        namespace, method = name.to_s.split(".")
-        unless namespace and method
-            raise ArgumentError, "Invalid method name %s" % name
-        end
-
-        name        = name.intern if name.is_a? String
-        namespace   = namespace.intern
-        method      = method.intern
-
-        read()
-
-        if @rights.include?(name)
-            return @rights[name].allowed?(host, ip)
-        elsif @rights.include?(namespace)
-            return @rights[namespace].allowed?(host, ip)
-        else
-            return false
-        end
-    end
-
-    # Does the file exist?  Puppetmasterd does not require it, but
-    # puppetd does.
-    def exists?
-        FileTest.exists?(@file)
-    end
-
-    def initialize(file = nil, parsenow = true)
-        @file ||= Puppet[:authconfig]
-
-        unless @file
-            raise Puppet::DevError, "No authconfig file defined"
-        end
-        return unless self.exists?
-        super(@file)
-        @rights = Rights.new
-        @configstamp = @configstatted = nil
-        @configtimeout = 60
-
-        if parsenow
-            read()
-        end
-    end
-
-    # Read the configuration file.
-    def read
-        return unless FileTest.exists?(@file)
-
-        if @configstamp
-            if @configtimeout and @configstatted
-                if Time.now - @configstatted > @configtimeout
-                    @configstatted = Time.now
-                    tmp = File.stat(@file).ctime
-
-                    if tmp == @configstamp
-                        return
-                    else
-                        Puppet.notice "%s vs %s" % [tmp, @configstamp]
-                    end
-                else
-                    return
-                end
-            else    
-                Puppet.notice "%s and %s" % [@configtimeout, @configstatted]
-            end
-        end
-
-        parse()
-
-        @configstamp = File.stat(@file).ctime
-        @configstatted = Time.now
-    end
-
-    private
-
-    def parse
-        newrights = Puppet::Server::Rights.new
-        begin
-            File.open(@file) { |f|
-                right = nil
-                count = 1
-                f.each { |line|
-                    case line
-                    when /^\s*#/: next # skip comments
-                    when /^\s*$/: next # skip blank lines
-                    when /\[([\w.]+)\]/: # "namespace" or "namespace.method"
-                        name = $1
-                        if newrights.include?(name)
-                            raise FileServerError, "%s is already set at %s" %
-                                [newrights[name], name]
-                        end
-                        newrights.newright(name)
-                        right = newrights[name]
-                    when /^\s*(\w+)\s+(.+)$/:
-                        var = $1
-                        value = $2
-                        case var
-                        when "allow":
-                            value.split(/\s*,\s*/).each { |val|
-                                begin
-                                    right.info "allowing %s access" % val
-                                    right.allow(val)
-                                rescue AuthStoreError => detail
-                                    raise ConfigurationError, "%s at line %s of %s" %
-                                        [detail.to_s, count, @config]
-                                end
-                            }
-                        when "deny":
-                            value.split(/\s*,\s*/).each { |val|
-                                begin
-                                    right.info "denying %s access" % val
-                                    right.deny(val)
-                                rescue AuthStoreError => detail
-                                    raise ConfigurationError, "%s at line %s of %s" %
-                                        [detail.to_s, count, @config]
-                                end
-                            }
-                        else
-                            raise ConfigurationError,
-                                "Invalid argument '%s' at line %s" % [var, count]
-                        end
-                    else
-                        raise ConfigurationError, "Invalid line %s: %s" % [count, line]
-                    end
-                    count += 1
-                }
-            }
-        rescue Errno::EACCES => detail
-            Puppet.err "Configuration error: Cannot read %s; cannot serve" % @file
-            #raise Puppet::Error, "Cannot read %s" % @config
-        rescue Errno::ENOENT => detail
-            Puppet.err "Configuration error: '%s' does not exit; cannot serve" %
-                @file
-            #raise Puppet::Error, "%s does not exit" % @config
-        #rescue FileServerError => detail
-        #    Puppet.err "FileServer error: %s" % detail
-        end
-
-        # Verify each of the rights are valid.
-        # We let the check raise an error, so that it can raise an error
-        # pointing to the specific problem.
-        newrights.each { |name, right|
-            right.valid?
-        }
-        @rights = newrights
-    end
-end
-end
-end
-
-# $Id: authconfig.rb 1148 2006-04-28 19:46:04Z luke $

data/lib/puppet/server/authstore.rb

@@ -1,226 +0,0 @@
-# standard module for determining whether a given hostname or IP has access to
-# the requested resource
-
-require 'ipaddr'
-
-module Puppet
-class Server
-    class AuthStoreError < Puppet::Error; end
-    class AuthorizationError < Puppet::Error; end
-
-    class AuthStore
-        # This has to be an array, not a hash, else it loses its ordering.
-        ORDER = [
-            [:ip, [:ip]],
-            [:name, [:hostname, :domain]]
-        ]
-
-        Puppet::Util.logmethods(self, true)
-
-        def allow(pattern)
-            # a simple way to allow anyone at all to connect
-            if pattern == "*"
-                @globalallow = true
-            else
-                store(pattern, @allow)
-            end
-        end
-
-        def allowed?(name, ip)
-            if name or ip
-                unless name and ip
-                    raise Puppet::DevError, "Name and IP must be passed to 'allowed?'"
-                end
-                # else, we're networked and such
-            else
-                # we're local
-                return true
-            end
-
-            # yay insecure overrides
-            if @globalallow
-                return true
-            end
-
-            value = nil
-            ORDER.each { |nametype, array|
-                if nametype == :ip
-                    value = IPAddr.new(ip)
-                else
-                    value = name.split(".").reverse
-                end
-
-
-                array.each { |type|
-                    [[@deny, false], [@allow, true]].each { |ary|
-                        hash, retval = ary
-                        if hash.include?(type)
-                            hash[type].each { |pattern|
-                                if match?(nametype, value, pattern)
-                                    return retval
-                                end
-                            }
-                        end
-                    }
-                }
-            }
-
-            self.info "defaulting to no access for %s" % name
-            # default to false
-            return false
-        end
-
-        def deny(pattern)
-            store(pattern, @deny)
-        end
-
-        def initialize
-            @globalallow = nil
-            @allow = Hash.new { |hash, key|
-                hash[key] = []
-            }
-            @deny = Hash.new { |hash, key|
-                hash[key] = []
-            }
-        end
-
-        private
-
-        def match?(nametype, value, pattern)
-            if value == pattern # simplest shortcut
-                return true
-            end
-
-            case nametype
-            when :ip: matchip?(value, pattern)
-            when :name: matchname?(value, pattern)
-            else
-                raise Puppet::DevError, "Invalid match type %s" % nametype
-            end
-        end
-
-        def matchip?(value, pattern)
-            # we're just using builtin stuff for this, thankfully
-            if pattern.include?(value)
-                return true
-            else
-                return false
-            end
-        end
-
-        def matchname?(value, pattern)
-            # yay, horribly inefficient
-            if pattern[-1] != '*' # the pattern has no metachars and is not equal
-                                    # thus, no match
-                #Puppet.info "%s is not equal with no * in %s" % [value, pattern]
-                return false
-            else
-                # we know the last field of the pattern is '*'
-                # if everything up to that doesn't match, we're definitely false
-                if pattern[0..-2] != value[0..pattern.length-2]
-                    #Puppet.notice "subpatterns didn't match; %s vs %s" %
-                    #    [pattern[0..-2], value[0..pattern.length-2]]
-                    return false
-                end
-
-                case value.length <=> pattern.length
-                when -1: # value is shorter than pattern
-                    if pattern.length - value.length == 1
-                        # only ever allowed when the value is the domain of a
-                        # splatted pattern
-                        #Puppet.info "allowing splatted domain %s" % [value]
-                        return true
-                    else
-                        return false
-                    end
-                when 0: # value is the same length as pattern
-                    if pattern[-1] == "*"
-                        #Puppet.notice "same length with *"
-                        return true
-                    else
-                        return false
-                    end
-                when 1: # value is longer than pattern
-                    # at this point we've already verified that everything up to
-                    # the '*' in the pattern matches, so we are true
-                    return true
-                end
-            end
-        end
-
-        def store(pattern, hash)
-            type, value = type(pattern)
-
-            if type and value
-                # this won't work once we get beyond simple stuff...
-                hash[type] << value
-            else
-                raise AuthStoreError, "Invalid pattern %s" % pattern
-            end
-        end
-
-        def type(pattern)
-            type = value = nil
-            case pattern
-            when /^(\d+\.){3}\d+$/:
-                type = :ip
-                begin
-                    value = IPAddr.new(pattern)
-                rescue ArgumentError => detail
-                    raise AuthStoreError, "Invalid IP address pattern %s" % pattern
-                end
-            when /^(\d+\.){3}\d+\/(\d+)$/:
-                mask = Integer($2)
-                if mask < 1 or mask > 32
-                    raise AuthStoreError, "Invalid IP mask %s" % mask
-                end
-                type = :ip
-                begin
-                    value = IPAddr.new(pattern)
-                rescue ArgumentError => detail
-                    raise AuthStoreError, "Invalid IP address pattern %s" % pattern
-                end
-            when /^(\d+\.){1,3}\*$/: # an ip address with a '*' at the end
-                type = :ip
-                match = $1
-                match.sub!(".", '')
-                ary = pattern.split(".")
-
-                mask = case ary.index(match)
-                when 0: 8
-                when 1: 16
-                when 2: 24
-                else
-                    raise AuthStoreError, "Invalid IP pattern %s" % pattern
-                end
-
-                ary.pop
-                while ary.length < 4
-                    ary.push("0")
-                end
-
-                begin
-                    value = IPAddr.new(ary.join(".") + "/" + mask.to_s)
-                rescue ArgumentError => detail
-                    raise AuthStoreError, "Invalid IP address pattern %s" % pattern
-                end
-            when /^[\d.]+$/: # necessary so incomplete IP addresses can't look
-                             # like hostnames
-                raise AuthStoreError, "Invalid IP address pattern %s" % pattern
-            when /^([a-zA-Z][-\w]*\.)+[-\w]+$/: # a full hostname
-                type = :hostname
-                value = pattern.split(".").reverse
-            when /^\*(\.([a-zA-Z][-\w]*)){1,}$/:
-                type = :domain
-                value = pattern.split(".").reverse
-            else
-                raise AuthStoreError, "Invalid pattern %s" % pattern
-            end
-
-            return [type, value]
-        end
-    end
-end
-end
-#
-# $Id: authstore.rb 1248 2006-06-08 21:46:07Z luke $