puppet 0.22.4 → 0.23.0

data/TODO

@@ -1,4 +0,0 @@
-$Id: TODO 576 2005-08-23 16:09:14Z luke $
-
-* Syntax for configuration of types (e.g., search path for Services)
-* Get file parsing working in the language

data/lib/puppet/network/client/logger.rb

@@ -1,6 +0,0 @@
-class Puppet::Network::Client::Logger < Puppet::Network::Client::ProxyClient
-    @handler = Puppet::Network::Handler.handler(:logger)
-    self.mkmethods
-end
-
-# $Id: logger.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -1,52 +0,0 @@
-require 'yaml'
-
-class Puppet::Network::Handler
-    class LoggerError < RuntimeError; end
-
-    # Receive logs from remote hosts.
-    class Logger < Handler
-        @interface = XMLRPC::Service::Interface.new("puppetlogger") { |iface|
-            iface.add_method("void addlog(string)")
-        }
-
-        # accept a log message from a client, and route it accordingly
-        def addlog(message, client = nil, clientip = nil)
-            unless message
-                raise Puppet::DevError, "Did not receive message"
-            end
-
-            Puppet.info message.inspect
-            # if the client is set, then we're not local
-            if client
-                begin
-                    message = YAML.load(CGI.unescape(message))
-                    #message = message
-                rescue => detail
-                    raise XMLRPC::FaultException.new(
-                        1, "Could not unYAML log message from %s" % client
-                    )
-                end
-            end
-
-            unless message
-                raise Puppet::DevError, "Could not resurrect message"
-            end
-
-            # Mark it as remote, so it's not sent to syslog
-            message.remote = true
-
-            if client
-                if ! message.source or message.source == "Puppet"
-                    message.source = client
-                end
-            end
-
-            Puppet::Util::Log.newmessage(message)
-
-            # This is necessary or XMLRPC gets all pukey
-            return ""
-        end
-    end
-end
-
-# $Id: logger.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/rails/database/001_add_indexes.rb

@@ -1,38 +0,0 @@
-class AddIndexes < ActiveRecord::Migration
-    INDEXES = {
-        :resources => [[:title, :restype], :host_id, :exported],
-        :source_files => [:filename, :path],
-        :puppet_classes => [:name, :host_id],
-        :hosts => [:name, :ip, :updated_at],
-        :fact_names => [:name, :host_id],
-        :fact_values => [:fact_name_id],
-        :param_values => [:param_name_id],
-        :param_names => [:name, :resource_id],
-        :tags => [:name, :updated_at],
-        :taggings => [:tag_id, :taggable_id, :taggable_type]
-    }
-
-    def self.up
-        puts "trying"
-        # Add all of our initial indexes
-        INDEXES.each do |table, indexes|
-            indexes.each do |index|
-                if index.to_s =~ /_id/
-                    add_index table, index, :integer => true
-                else
-                    add_index table, index
-                end
-            end
-        end
-    end
-
-    def self.down
-        INDEXES.each do |table, indexes|
-            indexes.each do |index|
-                remove_index table, index
-            end
-        end
-    end
-end
-
-# $Id: 001_add_indexes.rb 2344 2007-03-22 04:56:05Z luke $

data/lib/puppet/type/parsedtype.rb

@@ -1,219 +0,0 @@
-require 'etc'
-require 'facter'
-require 'puppet/util/filetype'
-require 'puppet/type/property'
-
-module Puppet
-    # The base parameter for all of these types.  Its only job is to copy
-    # the 'should' value to the 'is' value and to do support the right logging
-    # and such.
-    class Property::ParsedParam < Puppet::Property
-        # This is the info retrieved from disk.
-        attr_accessor :found
-
-        def self.isoptional
-            @isoptional = true
-        end
-
-        def self.isoptional?
-            if defined? @isoptional
-                return @isoptional
-            else
-                return false
-            end
-        end
-
-        # By default, support ':absent' as a value for optional
-        # parameters.  Any parameters that define their own validation
-        # need to do this manuallly.
-        validate do |value|
-            if self.class.isoptional? and (
-                value == "absent" or value == :absent
-            )
-                return :absent
-            else
-                return value
-            end
-        end
-
-        def clear
-            super
-            @found = nil
-        end
-
-        # Fix things so that the fields have to match exactly, instead
-        # of only kinda
-        def insync?
-            self.is == self.should
-        end
-
-        # Normally this would retrieve the current value, but our property is not
-        # actually capable of doing so.  So, we retrieve the whole object and
-        # just collect our current state.  Note that this method is not called
-        # during a transaction, since transactions call the parent object method.
-        def retrieve
-            @parent.retrieve
-        end
-
-        # All this does is return an event; all of the work gets done
-        # in the flush method on the model.
-        def sync
-            if e = self.class.event(self.should)
-                return e
-            else
-                if self.class.name == :ensure
-                    if self.should == :absent
-                        return (@parent.class.name.to_s + "_removed").intern
-                    else
-                        return (@parent.class.name.to_s + "_created").intern
-                    end
-                else
-                    return (@parent.class.name.to_s + "_changed").intern
-                end
-            end
-        end
-    end
-
-    # The collection of classes that are just simple records aggregated
-    # into a file. See 'host.rb' for an example.
-    class Type::ParsedType < Puppet::Type
-        @name = :parsedtype
-
-        # Convert the hash to an object.
-        def self.hash2obj(hash)
-            obj = nil
-
-            namevar = self.namevar
-            unless hash.include?(namevar) and hash[namevar]
-                raise Puppet::DevError, "Hash was not passed with namevar"
-            end
-
-            # if the obj already exists with that name...
-            if obj = self[hash[namevar]]
-                # We're assuming here that objects with the same name
-                # are the same object, which *should* be the case, assuming
-                # we've set up our naming stuff correctly everywhere.
-
-                # Mark found objects as present
-                obj.is = [:ensure, :present]
-                obj.property(:ensure).found = :present
-                hash.each { |param, value|
-                    if property = obj.property(param)
-                        property.is = value
-                    elsif val = obj[param]
-                        obj[param] = val
-                    else
-                        # There is a value on disk, but it should go away
-                        obj.is = [param, value]
-                        obj[param] = :absent
-                    end
-                }
-            else
-                # create a new obj, since no existing one seems to
-                # match
-                obj = self.create(namevar => hash[namevar])
-
-                # We can't just pass the hash in at object creation time,
-                # because it sets the should value, not the is value.
-                hash.delete(namevar)
-                hash.each { |param, value|
-                    obj.is = [param, value]
-                }
-            end
-
-            return obj
-        end
-
-        # Override 'newproperty' so that all properties default to having the
-        # correct parent type
-        def self.newproperty(name, options = {}, &block)
-            options[:parent] ||= Puppet::Property::ParsedParam
-            super(name, options, &block)
-        end
-
-        def self.list
-            ret = suitableprovider.collect do |provider|
-                provider.retrieve.find_all { |i| i.is_a? Hash }.collect { |i| hash2obj(i) }
-            end.flatten
-        end
-
-        def self.listbyname
-            suitableprovider.collect do |provider|
-                provider.retrieve.find_all { |i| i.is_a? Hash }.collect { |i| i[:name] }
-            end.flatten
-        end
-
-        # Make sure they've got an explicit :ensure class.
-        def self.postinit
-            unless validproperty? :ensure
-                newproperty(:ensure) do
-                    newvalue(:present) do
-                        # The value will get flushed appropriately
-                        return nil
-                    end
-
-                    newvalue(:absent) do
-                        # The value will get flushed appropriately
-                        return nil
-                    end
-
-                    defaultto do
-                        if @parent.managed?
-                            :present
-                        else
-                            nil
-                        end
-                    end
-                end
-            end
-        end
-
-        def exists?
-            h = self.retrieve
-
-            if h.nil? or h[:ensure] == :absent
-                return false
-            else
-                return true
-            end
-        end
-
-        # Flush our content to disk.
-        def flush
-            provider.store(self.to_hash)
-        end
-
-        # Retrieve our current state from our provider
-        def retrieve
-            if h = provider.hash and ! h.empty?
-                h[:ensure] ||= :present
-
-                # If they passed back info we don't have, then mark it to
-                # be deleted.
-                h.each do |name, value|
-                    next unless self.class.validproperty?(name)
-                    unless @parameters[name]
-                        self.newproperty(name, :should => :absent)
-                    end
-                end
-
-                properties().each do |property|
-                    if h.has_key? property.name
-                        property.is = h[property.name]
-                    else
-                        property.is = :absent
-                    end
-                end
-
-                return h
-            else
-                properties().each do |property|
-                    property.is = :absent
-                end
-                return nil
-            end
-        end
-    end
-end
-
-# $Id: parsedtype.rb 2178 2007-02-07 23:56:59Z luke $

data/test/network/handler/logger.rb

@@ -1,183 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'puppet/network/handler/logger'
-require 'base64'
-require 'cgi'
-
-class TestLogger < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-
-    def setup
-        super
-        
-        # Send the logs to an array, yo.
-        Puppet::Util::Log.close
-        @logs = []
-        Puppet::Util::Log.newdestination @logs
-    end
-
-    # Test the log driver manually
-    def test_localaddlog
-        logger = nil
-        assert_nothing_raised {
-            logger = Puppet::Network::Handler.logger.new
-        }
-
-        msg = nil
-        assert_nothing_raised {
-            msg = Puppet::Util::Log.create(
-                :level => :warning,
-                :message => "This is a message"
-            )
-        }
-
-        assert_nothing_raised {
-            logger.addlog(msg)
-        }
-    end
-
-    # Test it while replicating a remote client
-    def test_remoteaddlog
-        logger = nil
-        assert_nothing_raised {
-            logger = Puppet::Network::Handler.logger.new
-        }
-
-        msg = nil
-        assert_nothing_raised {
-            msg = Puppet::Util::Log.create(
-                :level => :warning,
-                :message => "This is a remote message"
-            )
-        }
-
-        assert_nothing_raised {
-            msg = CGI.escape(YAML.dump(msg))
-        }
-        assert_nothing_raised {
-            logger.addlog(msg, "localhost", "127.0.0.1")
-        }
-    end
-
-    # Now test it with a real client and server, but not remote
-    def test_localclient
-        client = nil
-        assert_nothing_raised {
-            client = Puppet::Network::Client.logger.new(:Logger => true)
-        }
-
-        msg = nil
-        assert_nothing_raised {
-            msg = Puppet::Util::Log.create(
-                :level => :warning,
-                :message => "This is a logclient message"
-            )
-        }
-
-        msg = CGI.escape(YAML.dump(msg))
-
-        assert_nothing_raised {
-            client.addlog(msg, "localhost", "127.0.0.1")
-        }
-    end
-
-    # And now test over the network
-    # This test is disabled, since it doesn't work well and it's not the right
-    # solution anyway.
-    def disabled_test_logclient
-        pid = nil
-        clientlog = tempfile()
-        serverlog = tempfile()
-        Puppet.warning "serverlog is %s" % serverlog
-        Puppet::Util::Log.newdestination clientlog
-        Puppet::Util::Log.close(:syslog)
-
-        # For testing
-        Puppet[:autosign] = true
-
-        logger = nil
-        # Create our server
-        assert_nothing_raised {
-            logger = Puppet::Network::Server.new(
-                :Port => @@port,
-                :Handlers => {
-                    :CA => {}, # so that certs autogenerate
-                    :Logger => {}
-                }
-            )
-        }
-
-        # Start our server
-        serverpid = fork {
-            Puppet::Util::Log.close(clientlog)
-            Puppet::Util::Log.newdestination serverlog
-            assert_nothing_raised() {
-                trap(:INT) { logger.shutdown }
-                logger.start
-            }
-        }
-        @@tmppids << serverpid
-        sleep(0.5)
-
-        # Start a raw xmlrpc client
-        client = nil
-        assert_nothing_raised() {
-            client = Puppet::Network::Client.logger.new(
-                :Server => "localhost",
-                :Port => @@port
-            )
-            unless client.readcert
-                raise "Could not get certs"
-            end
-        }
-        retval = nil
-
-        {
-            :notice => "XMLRPC1",
-            :warning => "XMLRPC2",
-            :err => "XMLRPC3"
-        }.each { |level, str|
-            msg = CGI.escape(YAML.dump(Puppet::Util::Log.create(
-                :level => level,
-                :message => str
-            )))
-            assert_nothing_raised {
-                retval = client.addlog(msg)
-            }
-        }
-
-        # and now use the normal client action
-
-        # Set the log destination to be the server
-        Puppet::Util::Log.newdestination "localhost:%s" % @@port
-
-        # And now do some logging
-        assert_nothing_raised {
-            Puppet.notice "TEST1"
-            Puppet.warning "TEST2"
-            Puppet.err "TEST3"
-        }
-
-        assert_nothing_raised {
-            Process.kill("INT", serverpid)
-        }
-
-        assert(FileTest.exists?(serverlog), "Server log does not exist")
-
-        # Give it a bit to flush to disk
-        sleep(0.5)
-        content = nil
-        assert_nothing_raised {
-            content = File.read(serverlog)
-        }
-
-        %w{TEST1 TEST2 TEST3}.each { |str|
-            assert(content =~ %r{#{str}}, "Content does not match %s" % str)
-        }
-    end
-end
-
-# $Id: logger.rb 2259 2007-03-06 19:03:05Z luke $