puppet 0.18.4 → 0.22.4

data/lib/puppet/metric.rb

@@ -1,132 +0,0 @@
-# included so we can test object types
-require 'puppet'
-
-module Puppet
-    # A class for handling metrics.  This is currently ridiculously hackish.
-	class Metric
-        Puppet.config.setdefaults("metrics",
-            :rrddir => {:default => "$vardir/rrd",
-                :owner => "$user",
-                :group => "$group",
-                :desc => "The directory where RRD database files are stored."
-            },
-            :rrdgraph => [false, "Whether RRD information should be graphed."]
-        )
-
-        @@haverrd = false
-        begin
-            require 'RRD'
-            @@haverrd = true
-        rescue LoadError
-        end
-
-        def self.haverrd?
-            @@haverrd
-        end
-
-        attr_accessor :type, :name, :value, :label
-
-        def create
-            Puppet.config.use(:metrics)
-
-            path = self.path
-            args = [
-                path,
-                "--start", Time.now.to_i - 5,
-                "--step", "300", # XXX Defaulting to every five minutes, but prob bad
-            ]
-
-            @values.each { |value|
-                args.push "DS:%s:GAUGE:600:U:U" % value[0]
-            }
-            args.push "RRA:AVERAGE:0.5:1:300"
-
-            begin
-                RRD.create(*args)
-            rescue => detail
-                raise "Could not create RRD file %s: %s" % [path,detail]
-            end
-        end
-
-        def initialize(name,label = nil)
-            @name = name.to_s
-
-            if label
-                @label = label
-            else
-                @label = name.to_s.capitalize.gsub("_", " ")
-            end
-
-            @values = []
-        end
-
-        def newvalue(name,value,label = nil)
-            unless label
-                label = name.to_s.capitalize.gsub("_", " ")
-            end
-            @values.push [name,label,value]
-        end
-
-        def path
-            return File.join(Puppet[:rrddir],@name + ".rrd")
-        end
-
-        def graph(range = nil)
-            unless @@haverrd
-                Puppet.warning "RRD library is missing; cannot graph metrics"
-                return
-            end
-            args = [self.path.sub(/rrd$/,"png")]
-
-            args.push("--title",self.label)
-            args.push("--imgformat","PNG")
-            args.push("--interlace")
-            colorstack = %w{#ff0000 #00ff00 #0000ff #099000 #000990 #f00990 #0f0f0f}
-            i = 0
-            defs = []
-            lines = []
-            @values.zip(colorstack).each { |value,color|
-                next if value.nil?
-                # this actually uses the data label
-                defs.push("DEF:%s=%s:%s:AVERAGE" % [value[0],self.path,value[0]])
-                lines.push("LINE3:%s%s:%s" % [value[0],color,value[1]])
-            }
-            args << defs
-            args << lines
-            args.flatten!
-            if range 
-                args.push("--start",range[0],"--end",range[1])
-            end
-
-            begin
-                RRD.graph(*args)
-            rescue => detail
-                Puppet.err "Failed to graph %s: %s" % [self.name,detail]
-            end
-        end
-
-        def store(time)
-            unless @@haverrd
-                Puppet.warning "RRD library is missing; cannot store metrics"
-                return
-            end
-            unless FileTest.exists?(self.path)
-                self.create
-            end
-
-            # XXX this is not terribly error-resistant
-            args = [time]
-            @values.each { |value|
-                args.push value[2]
-            }
-            arg = args.join(":")
-            begin
-                RRD.update(self.path,args.join(":"))
-            rescue => detail
-                raise Puppet::Error, "Failed to update %s: %s" % [self.name,detail]
-            end
-        end
-    end
-end
-
-# $Id: metric.rb 1358 2006-07-04 16:07:47Z luke $

data/lib/puppet/networkclient.rb

@@ -1,175 +0,0 @@
-require 'puppet'
-require 'puppet/sslcertificates'
-require 'puppet/type'
-require 'facter'
-require 'openssl'
-require 'puppet/transaction'
-require 'puppet/transportable'
-require 'puppet/metric'
-require 'puppet/daemon'
-require 'puppet/server'
-require 'puppet/base64'
-
-$noclientnetworking = false
-begin
-    require 'webrick'
-    require 'cgi'
-    require 'xmlrpc/client'
-    require 'xmlrpc/server'
-    require 'yaml'
-rescue LoadError => detail
-    $noclientnetworking = detail
-    raise Puppet::Error, "You must have the Ruby XMLRPC, CGI, and Webrick libraries installed"
-end
-
-module Puppet
-    class NetworkClientError < RuntimeError; end
-    class ClientError < RuntimeError; end
-    #---------------------------------------------------------------
-    if $noclientnetworking
-        Puppet.err "Could not load client network libs: %s" % $noclientnetworking
-    else
-        class NetworkClient < XMLRPC::Client
-            @clients = {}
-
-            # Create a netclient for each handler
-            def self.mkclients
-                # add the methods associated with each namespace
-                Puppet::Server::Handler.each { |handler|
-                    interface = handler.interface
-                    namespace = interface.prefix
-
-                    # Create a subclass for every client type.  This is
-                    # so that all of the methods are on their own class,
-                    # so that they namespaces can define the same methods if
-                    # they want.
-                    newclient = Class.new(self)
-
-                    #name = "Puppet::NetworkClient::" + handler.to_s.sub(/^.+::/, '')
-                    name = handler.to_s.sub(/^.+::/, '')
-                    const_set(name, newclient)
-                    @clients[namespace] = newclient
-
-                    interface.methods.each { |ary|
-                        method = ary[0]
-                        if public_method_defined?(method)
-                            raise Puppet::DevError, "Method %s is already defined" %
-                                method
-                        end
-                        newclient.send(:define_method,method) { |*args|
-                            Puppet.debug "Calling %s.%s" % [namespace, method]
-                            #Puppet.info "peer cert is %s" % @http.peer_cert
-                            #Puppet.info "cert is %s" % @http.cert
-                            begin
-                                call("%s.%s" % [namespace, method.to_s],*args)
-                            rescue OpenSSL::SSL::SSLError => detail
-                                raise NetworkClientError,
-                                    "Certificates were not trusted: %s" % detail
-                            rescue XMLRPC::FaultException => detail
-                                #Puppet.err "Could not call %s.%s: %s" %
-                                #    [namespace, method, detail.faultString]
-                                #raise NetworkClientError,
-                                #    "XMLRPC Error: %s" % detail.faultString
-                                raise NetworkClientError, detail.faultString
-                            rescue Errno::ECONNREFUSED => detail
-                                msg = "Could not connect to %s on port %s" %
-                                    [@host, @port]
-                                raise NetworkClientError, msg
-                            rescue SocketError => detail
-                                Puppet.err "Could not find server %s" % @puppetserver
-                                exit(12)
-                            rescue => detail
-                                Puppet.err "Could not call %s.%s: %s" %
-                                    [namespace, method, detail.inspect]
-                                #raise NetworkClientError.new(detail.to_s)
-                                if Puppet[:debug]
-                                    puts detail.backtrace
-                                end
-                                raise
-                            end
-                        }
-                    }
-                }
-            end
-
-            def self.netclient(namespace)
-                if @clients.empty?
-                    self.mkclients()
-                end
-
-                @clients[namespace]
-            end
-
-            def ca_file=(cafile)
-                @http.ca_file = cafile
-                store = OpenSSL::X509::Store.new
-                cacert = OpenSSL::X509::Certificate.new(
-                    File.read(cafile)
-                )
-                store.add_cert(cacert) 
-                store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
-                @http.cert_store = store
-            end
-
-            def cert=(cert)
-                #Puppet.debug "Adding certificate"
-                @http.cert = cert
-                @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            end
-
-            def key=(key)
-                @http.key = key
-            end
-
-            def initialize(hash)
-                hash[:Path] ||= "/RPC2"
-                hash[:Server] ||= "localhost"
-                hash[:Port] ||= Puppet[:masterport]
-
-                @puppetserver = hash[:Server]
-
-                super(
-                    hash[:Server],
-                    hash[:Path],
-                    hash[:Port],
-                    nil, # proxy_host
-                    nil, # proxy_port
-                    nil, # user
-                    nil, # password
-                    true, # use_ssl
-                    120 # a two minute timeout, instead of 30 seconds
-                )
-
-                if hash[:Certificate]
-                    self.cert = hash[:Certificate]
-                else
-                    unless defined? $nocertwarned
-                        Puppet.err "No certificate; running with reduced functionality."
-                        $nocertwarned = true
-                    end
-                end
-
-                if hash[:Key]
-                    self.key = hash[:Key]
-                end
-
-                if hash[:CAFile]
-                    self.ca_file = hash[:CAFile]
-                end
-
-                # from here, i need to add the key, cert, and ca cert
-                # and reorgize how i start the client
-            end
-
-            def local
-                false
-            end
-
-            def local?
-                false
-            end
-        end
-    end
-end
-
-# $Id: networkclient.rb 1385 2006-07-11 17:36:32Z luke $

data/lib/puppet/parsedfile.rb

@@ -1,58 +0,0 @@
-# A simple class that tells us when a file has changed and thus whether we
-# should reload it
-
-require 'puppet'
-
-module Puppet
-    class NoSuchFile < Puppet::Error; end
-    class ParsedFile
-        attr_reader :file
-
-        # Provide a hook for setting the timestamp during testing, so we don't
-        # have to depend on the granularity of the filesystem.
-        attr_writer :tstamp
-
-        Puppet.config.setdefaults(:puppet,
-            :filetimeout => [ 15,
-                "The minimum time to wait between checking for updates in
-                configuration files."
-            ]
-        )
-
-        # Determine whether the file has changed and thus whether it should
-        # be reparsed
-        def changed?
-            # Don't actually stat the file more often than filetimeout.
-            if Time.now - @statted >= Puppet[:filetimeout]
-                tmp = stamp()
-
-                if tmp == @tstamp
-                    return false
-                else
-                    @tstamp = tmp
-                    return true
-                end
-            else
-                return false
-            end
-        end
-
-        # Create the file.  Must be passed the file path.
-        def initialize(file)
-            @file = file
-            unless FileTest.exists?(@file)
-                raise Puppet::NoSuchFile, "Can not use a non-existent file for parsing"
-            end
-            @tstamp = stamp()
-        end
-
-        private
-
-        def stamp
-            @statted = Time.now
-            return File.stat(@file).ctime
-        end
-    end
-end
-
-# $Id: parsedfile.rb 1422 2006-07-22 03:32:56Z luke $

data/lib/puppet/parser/ast/classdef.rb

@@ -1,79 +0,0 @@
-require 'puppet/parser/ast/compdef'
-
-class Puppet::Parser::AST
-    # Define a new class.  Syntactically similar to component definitions,
-    # but classes are always singletons -- only one can exist on a given
-    # host.
-    class ClassDef < AST::CompDef
-        attr_accessor :parentclass
-
-        def each
-            if @parentclass
-                #[@type,@args,@parentclass,@code].each { |child| yield child }
-                [@type,@parentclass,@code].each { |child| yield child }
-            else
-                #[@type,@args,@code].each { |child| yield child }
-                [@type,@code].each { |child| yield child }
-            end
-        end
-
-        # Store our parse tree according to type.
-        def evaluate(hash)
-            scope = hash[:scope]
-            type = @type.safeevaluate(:scope => scope)
-            #args = @args.safeevaluate(:scope => scope)
-
-                #:args => args,
-            arghash = {
-                :type => type,
-                :code => @code
-            }
-
-            if @parentclass
-                arghash[:parentclass] = @parentclass.safeevaluate(:scope => scope)
-            end
-
-            #Puppet.debug("defining hostclass '%s' with arguments [%s]" %
-            #    [type,args])
-
-            begin
-                hclass = HostClass.new(arghash)
-                hclass.keyword = self.keyword
-                scope.settype(type, hclass)
-            rescue Puppet::ParseError => except
-                except.line = self.line
-                except.file = self.file
-                raise except
-            rescue => detail
-                error = Puppet::ParseError.new(detail)
-                error.line = self.line
-                error.file = self.file
-                error.backtrace = detail.backtrace
-                raise error
-            end
-        end
-
-        def initialize(hash)
-            @parentclass = nil
-            @keyword = "class"
-            super
-        end
-
-        def tree(indent = 0)
-                #@args.tree(indent + 1),
-            return [
-                @type.tree(indent + 1),
-                ((@@indline * 4 * indent) + self.typewrap("class")),
-                @parentclass ? @parentclass.tree(indent + 1) : "",
-                @code.tree(indent + 1),
-            ].join("\n")
-        end
-
-        def to_s
-            return "class %s(%s) inherits %s {\n%s }" %
-                [@type, @parentclass, @code]
-                #[@type, @args, @parentclass, @code]
-        end
-    end
-
-end

data/lib/puppet/parser/ast/compdef.rb

@@ -1,75 +0,0 @@
-class Puppet::Parser::AST
-    # Define a new component.  This basically just stores the
-    # associated parse tree by name in our current scope.  Note that
-    # there is currently a mismatch in how we look up components -- it
-    # usually uses scopes, but sometimes uses '@@settypes'.
-    # FIXME This class should verify that each of its direct children
-    # has an abstractable name -- i.e., if a file does not include a
-    # variable in its name, then the user is essentially guaranteed to
-    # encounter an error if the component is instantiated more than
-    # once.
-    class CompDef < AST::Branch
-        attr_accessor :type, :args, :code, :keyword, :scope
-
-        def each
-            [@type,@args,@code].each { |child| yield child }
-        end
-
-        # Store the parse tree.
-        def evaluate(hash)
-            scope = hash[:scope]
-            type = @type.safeevaluate(:scope => scope)
-            args = @args.safeevaluate(:scope => scope)
-
-            begin
-                comp = AST::Component.new(
-                    :type => type,
-                    :args => args,
-                    :code => @code
-                )
-                comp.keyword = self.keyword
-                scope.settype(type, comp)
-            rescue Puppet::ParseError => except
-                except.line = self.line
-                except.file = self.file
-                raise except
-            rescue => detail
-                error = Puppet::ParseError.new(detail)
-                error.line = self.line
-                error.file = self.file
-                error.backtrace = detail.backtrace
-                raise error
-            end
-        end
-
-        def initialize(hash)
-            @parentclass = nil
-
-            # Set a default keyword
-            @keyword = "define"
-            super
-
-            #if @parentclass
-            #    Puppet.notice "Parent class of %s is %s" %
-            #        [@type.value, @parentclass.value]
-            #end
-
-            #Puppet.debug "Defining type %s" % @type.value
-        end
-
-        def tree(indent = 0)
-            return [
-                @type.tree(indent + 1),
-                ((@@indline * 4 * indent) + self.typewrap("define")),
-                @args.tree(indent + 1),
-                @code.tree(indent + 1),
-            ].join("\n")
-        end
-
-        def to_s
-            return "define %s(%s) {\n%s }" % [@type, @args, @code]
-        end
-    end
-end
-
-# $Id: compdef.rb 1186 2006-05-13 02:14:35Z luke $