puppet 0.18.4 → 0.22.4

data/lib/puppet/type/symlink.rb

@@ -1,186 +0,0 @@
-require 'etc'
-require 'puppet/type/state'
-require 'puppet/type/pfile'
-
-module Puppet
-    newtype(:symlink) do
-        @doc = "Create symbolic links to existing files.  **This type is deprecated;
-            use file instead.**"
-        #newstate(:ensure) do
-        ensurable do
-            require 'etc'
-            attr_accessor :file
-
-            desc "Create a link to another file.  Currently only symlinks
-                are supported, and attempts to replace normal files with
-                links will currently fail, while existing but incorrect symlinks
-                will be removed."
-
-            validate do |value|
-                unless value == :absent or value =~ /^#{File::SEPARATOR}/
-                    raise Puppet::Error, "Invalid symlink %s" % value
-                end
-            end
-
-            nodefault
-
-            def create
-                begin
-                    unless File.symlink(self.should,self.parent[:path])
-                        self.fail "Could not create symlink '%s'" %
-                            self.parent[:path]
-                    end
-                rescue => detail
-                    self.fail "Cannot create symlink '%s': %s" %
-                        [self.parent[:path],detail]
-                end
-            end
-
-            def remove
-                if FileTest.symlink?(self.parent[:path])
-                    begin
-                        File.unlink(self.parent[:path])
-                    rescue
-                        self.fail "Failed to remove symlink '%s'" %
-                            self.parent[:path]
-                    end
-                elsif FileTest.exists?(self.parent[:path])
-                    self.fail "Cannot remove normal file '%s'" %
-                        self.parent[:path]
-                else
-                    @parent.debug("Symlink '%s' does not exist" %
-                        self.parent[:path])
-                end
-            end
-
-            def retrieve
-                stat = nil
-
-                if FileTest.symlink?(self.parent[:path])
-                    self.is = File.readlink(self.parent[:path])
-                    return
-                else
-                    self.is = :absent
-                    return
-                end
-            end
-
-            # this is somewhat complicated, because it could exist and be
-            # a link
-            def sync
-                case self.should
-                when :absent
-                    self.remove()
-                    return :symlink_removed
-                when /^#{File::SEPARATOR}/
-                    if FileTest.symlink?(self.parent[:path])
-                        path = File.readlink(self.parent[:path])
-                        if path != self.should
-                            self.remove()
-                            self.create()
-                            return :symlink_changed
-                        else
-                            self.info "Already in sync"
-                            return nil
-                        end
-                    elsif FileTest.exists?(self.parent[:path])
-                        self.fail "Cannot replace normal file '%s'" %
-                            self.parent[:path]
-                    else
-                        self.create()
-                        return :symlink_created
-                    end
-                else
-                    raise Puppet::DevError, "Got invalid symlink value %s" %
-                        self.should
-                end
-            end
-        end
-
-        attr_reader :stat, :params
-
-        copyparam(Puppet.type(:file), :path)
-
-        newparam(:recurse) do
-            desc "If target is a directory, recursively create
-                directories (using `file`'s `source` parameter) and link all
-                contained files.  For instance:
-
-                    # The Solaris Blastwave repository installs everything
-                    # in /opt/csw; link it into /usr/local
-                    symlink { \"/usr/local\":
-                        ensure => \"/opt/csw\",
-                        recurse => true
-                    }
-
-
-                Note that this does not link directories -- any directories
-                are created in the destination, and any files are linked over."
-
-            munge do |value|
-                @stat = nil
-                @target = @parent.state(:ensure).should
-
-                self.setparent(@target)
-            end
-
-            def setparent(value)
-                # we want to remove our state, because we're creating children
-                # to do the links
-                if FileTest.exist?(@target)
-                    @stat = File.lstat(@target)
-                else
-                    @setparent = false
-                    return
-                end
-
-                # if we're a directory, then we descend into it; we only actually
-                # link to real files
-                unless @stat.directory?
-                    return
-                end
-
-                @parent.delete(:ensure)
-
-                recurse = value
-                # we might have a string, rather than a number
-                if recurse.is_a?(String)
-                    if recurse =~ /^[0-9]+$/
-                        recurse = Integer(recurse)
-                    #elsif recurse =~ /^inf/ # infinite recursion
-                    else # anything else is infinite recursion
-                        recurse = true
-                    end
-                end
-
-                # are we at the end of the recursion?
-                if recurse == 0
-                    return
-                end
-
-                # okay, we're not going to recurse ourselves here; instead, we're
-                # going to rely on the fact that we've already got all of that
-                # working in pfile
-
-                args = {
-                    :path => @parent[:path],
-                    :linkmaker => true,
-                    :recurse => recurse,
-                    :source => @target
-                }
-
-                dir = Puppet.type(:file).implicitcreate(args)
-                @parent.push dir
-                @setparent = true
-            end
-        end
-
-        def initialize(hash)
-            @arghash = self.argclean(hash.dup)
-            @arghash.delete(self.class.namevar)
-            super
-        end
-    end # Puppet.type(:symlink)
-end
-
-# $Id: symlink.rb 1300 2006-06-19 19:12:54Z luke $

data/test/client/master.rb

@@ -1,207 +0,0 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
-
-require 'puppet'
-require 'puppet/client'
-require 'puppet/server'
-require 'test/unit'
-require 'puppettest.rb'
-
-# $Id: master.rb 1368 2006-07-05 17:17:39Z luke $
-
-class TestMasterClient < Test::Unit::TestCase
-	include ServerTest
-
-    def mkmaster(file = nil)
-        master = nil
-
-        file ||= mktestmanifest()
-        # create our master
-        assert_nothing_raised() {
-            # this is the default server setup
-            master = Puppet::Server::Master.new(
-                :Manifest => file,
-                :UseNodes => false,
-                :Local => true
-            )
-        }
-        return master
-    end
-
-    def mkclient(master = nil)
-        master ||= mkmaster()
-        client = nil
-        assert_nothing_raised() {
-            client = Puppet::Client::MasterClient.new(
-                :Master => master
-            )
-        }
-
-        return client
-    end
-
-    def test_disable
-        manifest = mktestmanifest
-
-        master = mkmaster(manifest)
-
-        client = mkclient(master)
-
-        assert(! FileTest.exists?(@createdfile))
-
-        assert_nothing_raised {
-            client.disable
-        }
-
-        assert_nothing_raised {
-            client.run
-        }
-
-        assert(! FileTest.exists?(@createdfile), "Disabled client ran")
-
-        assert_nothing_raised {
-            client.enable
-        }
-
-        assert_nothing_raised {
-            client.run
-        }
-
-        assert(FileTest.exists?(@createdfile), "Enabled client did not run")
-    end
-
-    # Make sure we're getting the client version in our list of facts
-    def test_clientversionfact
-        facts = nil
-        assert_nothing_raised {
-            facts = Puppet::Client::MasterClient.facts
-        }
-
-        assert_equal(Puppet.version.to_s, facts["clientversion"])
-        
-    end
-
-    # Make sure the client correctly locks itself
-    def test_locking
-        manifest = mktestmanifest
-
-        master = nil
-
-        # First test with a networked master
-        client = Puppet::Client::MasterClient.new(
-            :Server => "localhost"
-        )
-
-        assert_nothing_raised do
-            client.lock do
-                pid = nil
-                assert(client.locked?, "Client is not locked")
-                assert(client.lockpid.is_a?(Integer), "PID #{client.lockpid} is, um, not a pid")
-            end
-        end
-        assert(! client.locked?)
-
-        # Now test with a local client
-        client = mkclient
-
-        assert_nothing_raised do
-            client.lock do
-                pid = nil
-                assert(! client.locked?, "Local client is locked")
-            end
-        end
-        assert(! client.locked?)
-    end
-
-    # Make sure non-string facts don't make things go kablooie
-    def test_nonstring_facts
-        # Add a nonstring fact
-        Facter.add("nonstring") do
-            setcode { 1 }
-        end
-
-        assert_equal(1, Facter.nonstring, "Fact was a string from facter")
-
-        client = mkclient()
-
-        assert(! FileTest.exists?(@createdfile))
-
-        assert_nothing_raised {
-            client.run
-        }
-    end
-
-    def test_getplugins
-        Puppet[:pluginsource] = tempfile()
-        Dir.mkdir(Puppet[:pluginsource])
-
-        myplugin = File.join(Puppet[:pluginsource], "myplugin.rb")
-        File.open(myplugin, "w") do |f|
-            f.puts %{Puppet::Type.newtype(:myplugin) do
-    newparam(:argument) do
-        isnamevar
-    end
-end
-}
-        end
-
-        client = mkclient()
-
-        assert_nothing_raised {
-            client.send(:getplugins)
-        }
-
-        destfile = File.join(Puppet[:plugindest], "myplugin.rb")
-
-        assert(File.exists?(destfile), "Did not get plugin")
-
-        obj = Puppet::Type.type(:myplugin)
-
-        assert(obj, "Did not define type")
-
-        assert(obj.validattr?(:argument),
-            "Did not get namevar")
-
-        # Now modify the file and make sure the type is replaced
-        File.open(myplugin, "w") do |f|
-            f.puts %{Puppet::Type.newtype(:myplugin) do
-    newparam(:yayness) do
-        isnamevar
-    end
-
-    newparam(:rahness) do
-    end
-end
-}
-        end
-
-        assert_nothing_raised {
-            client.send(:getplugins)
-        }
-
-        destfile = File.join(Puppet[:pluginpath], "myplugin.rb")
-
-        obj = Puppet::Type.type(:myplugin)
-
-        assert(obj, "Did not define type")
-
-        assert(obj.validattr?(:yayness),
-            "Did not get namevar")
-
-        assert(obj.validattr?(:rahness),
-            "Did not get other var")
-
-        assert(! obj.validattr?(:argument),
-            "Old namevar is still valid")
-
-        # Now make sure it works with multiple paths specified.
-        newdir = tempfile()
-        Dir.mkdir(newdir)
-        Puppet[:pluginpath] = [Puppet[:pluginpath], newdir].join(":")
-
-        client.send(:getplugins)
-    end
-end

data/test/language/rails.rb

@@ -1,105 +0,0 @@
-#!/usr/bin/ruby
-
-if __FILE__ == $0
-    $:.unshift '../../lib'
-    $:.unshift '..'
-    $puppetbase = "../.."
-end
-
-require 'puppet'
-require 'puppet/rails'
-require 'puppet/parser/interpreter'
-require 'puppet/parser/parser'
-require 'puppet/client'
-require 'test/unit'
-require 'puppettest'
-
-class TestRails < Test::Unit::TestCase
-	include ParserTesting
-
-    def test_includerails
-        assert_nothing_raised {
-            require 'puppet/rails'
-        }
-    end
-
-    # Don't do any tests w/out this class
-    if defined? ActiveRecord::Base
-    def test_hostcache
-        # First make some objects
-        bucket = mk_transtree do |object, depth, width|
-            # and mark some of them collectable
-            if width % 2 == 1
-                object.collectable = true
-            end
-        end
-
-        # Now collect our facts
-        facts = {}
-        Facter.each do |fact, value| facts[fact] = value end
-
-        assert_nothing_raised {
-            Puppet::Rails.init
-        }
-
-        # Now try storing our crap
-        host = nil
-        assert_nothing_raised {
-            host = Puppet::Rails::Host.store(
-                :objects => bucket,
-                :facts => facts,
-                :host => facts["hostname"]
-            )
-        }
-
-        assert(host, "Did not create host")
-
-        host = nil
-        assert_nothing_raised {
-            host = Puppet::Rails::Host.find_by_name(facts["hostname"])
-        }
-        assert(host, "Could not find host object")
-
-        assert(host.rails_objects, "No objects on host")
-
-        assert_equal(facts["hostname"], host.facts["hostname"],
-            "Did not retrieve facts")
-
-        inline_test_objectcollection(host)
-    end
-
-    # This is called from another test, it just makes sense to split it out some
-    def inline_test_objectcollection(host)
-        # XXX For some reason, find_all doesn't work here at all.
-        collectable = []
-        host.rails_objects.each do |obj|
-            if obj.collectable?
-                collectable << obj
-            end
-        end
-
-        assert(collectable.length > 0, "Found no collectable objects")
-
-        collectable.each do |obj|
-            trans = nil
-            assert_nothing_raised {
-                trans = obj.to_trans
-            }
-            # Make sure that the objects do not retain their collectable
-            # nature.
-            assert(!trans.collectable, "Object from db was collectable")
-        end
-
-        # Now find all collectable objects directly through database APIs
-
-        list = Puppet::Rails::RailsObject.find_all_by_collectable(true)
-
-        assert_equal(collectable.length, list.length,
-            "Did not get the right number of objects")
-    end
-    else
-        $stderr.puts "Install Rails for Rails and Caching tests"
-    end
-end
-
-# $Id: rails.rb 1192 2006-05-14 02:42:21Z luke $