puppet 0.23.2 → 0.24.0

data/ext/tools/passwd2puppet

@@ -1,45 +0,0 @@
-#!/usr/bin/ruby -w
-
-#--------------------
-# Convert a passwd-format file to Puppet users
-#
-
-require 'getoptlong'
-
-result = GetoptLong.new(
-	[ "--help",		"-h",			GetoptLong::NO_ARGUMENT ]
-)
-
-result.each { |opt,arg|
-	case opt
-		when "--help"
-			puts "There is no help yet"
-			exit
-		else
-			raise "Invalid option '#{opt}'"
-	end
-}
-
-fields = %w{uid gid comment home shell}
-
-puts "user {"
-ARGV.each do |file|
-    File.open(file) do |of|
-        of.sort.each do |line|
-            next if line =~ /^\s*#/
-            next if line =~ /^\s*$/
-
-            ary = line.chomp.split(":")
-            puts "    " + ary.shift + ":"
-            ary.shift # get rid of that password field
-
-            puts fields.zip(ary).collect { |field, val|
-                "        %s => \"%s\"" % [field, val]
-            }.join(",\n") + ";"
-
-        end
-    end
-end
-puts "}"
-
-# $Id: passwd2puppet 943 2006-02-24 22:49:57Z luke $

data/lib/puppet/fact_stores/yaml.rb

@@ -1,42 +0,0 @@
-Puppet::Util::FactStore.newstore(:yaml) do
-    desc "Store client facts as flat files, serialized using YAML."
-
-    # Get a client's facts.
-    def get(node)
-        file = path(node)
-
-        return nil unless FileTest.exists?(file)
-
-        begin
-            facts = YAML::load(File.read(file))
-        rescue => detail
-            Puppet.err "Could not load facts for %s: %s" % [node, detail]
-        end
-        facts
-    end
-
-    def initialize
-        Puppet.config.use(:yamlfacts)
-    end
-
-    # Store the facts to disk.
-    def set(node, facts)
-        File.open(path(node), "w", 0600) do |f|
-            begin
-                f.print YAML::dump(facts)
-            rescue => detail
-                Puppet.err "Could not write facts for %s: %s" % [node, detail]
-            end
-        end
-        nil
-    end
-
-    private
-
-    # Return the path to a given node's file.
-    def path(node)
-        File.join(Puppet[:yamlfactdir], node + ".yaml")
-    end
-end
-
-# $Id: yaml.rb 2457 2007-05-03 05:24:13Z luke $

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

@@ -1,70 +0,0 @@
-require 'yaml'
-require 'puppet/util/fact_store'
-
-class Puppet::Network::Handler
-    # Receive logs from remote hosts.
-    class Facts < Handler
-        desc "An interface for storing and retrieving client facts.  Currently only
-        used internally by Puppet."
-
-        @interface = XMLRPC::Service::Interface.new("facts") { |iface|
-            iface.add_method("void set(string, string)")
-            iface.add_method("string get(string)")
-            iface.add_method("integer store_date(string)")
-        }
-
-        def initialize(hash = {})
-            super
-
-            backend = Puppet[:factstore]
-
-            unless klass = Puppet::Util::FactStore.store(backend)
-                raise Puppet::Error, "Could not find fact store %s" % backend
-            end
-
-            @backend = klass.new
-        end
-
-        # Get the facts from our back end.
-        def get(node)
-            if facts = @backend.get(node)
-                return strip_internal(facts)
-            else
-                return nil
-            end
-        end
-
-        # Set the facts in the backend.
-        def set(node, facts)
-            @backend.set(node, add_internal(facts))
-            nil
-        end
-
-        # Retrieve a client's storage date.
-        def store_date(node)
-            if facts = get(node)
-                facts[:_puppet_timestamp].to_i
-            else
-                nil
-            end
-        end
-
-        private
-
-        # Add internal data to the facts for storage.
-        def add_internal(facts)
-            facts = facts.dup
-            facts[:_puppet_timestamp] = Time.now
-            facts
-        end
-
-        # Strip out that internal data.
-        def strip_internal(facts)
-            facts = facts.dup
-            facts.find_all { |name, value| name.to_s =~ /^_puppet_/ }.each { |name, value| facts.delete(name) }
-            facts
-        end
-    end
-end
-
-# $Id: facts.rb 2479 2007-05-07 22:29:44Z luke $

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

@@ -1,222 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-# Any normal puppet object declaration.  Can result in a class or a 
-# component, in addition to builtin types.
-class Puppet::Parser::AST
-class ResourceDef < AST::Branch
-    attr_accessor :title, :type, :exported, :virtual
-    attr_reader :params
-
-    # probably not used at all
-    def []=(index,obj)
-        @params[index] = obj
-    end
-
-    # probably not used at all
-    def [](index)
-        return @params[index]
-    end
-
-    # Iterate across all of our children.
-    def each
-        [@type,@title,@params].flatten.each { |param|
-            #Puppet.debug("yielding param %s" % param)
-            yield param
-        }
-    end
-
-    # Does not actually return an object; instead sets an object
-    # in the current scope.
-    def evaluate(hash)
-        scope = hash[:scope]
-        @scope = scope
-        hash = {}
-
-        # Get our type and name.
-        objtype = @type
-
-        # Disable definition inheritance, for now.  8/27/06, luke
-        #if objtype == "super"
-        #    objtype = supertype()
-        #    @subtype = true
-        #else
-            @subtype = false
-        #end
-
-        # Evaluate all of the specified params.
-        paramobjects = @params.collect { |param|
-            param.safeevaluate(:scope => scope)
-        }
-
-        # Now collect info from our parent.
-        parentname = nil
-        if @subtype
-            parentname = supersetup(hash)
-        end
-
-        objtitles = nil
-        # Determine our name if we have one.
-        if self.title
-            objtitles = @title.safeevaluate(:scope => scope)
-            # it's easier to always use an array, even for only one name
-            unless objtitles.is_a?(Array)
-                objtitles = [objtitles]
-            end
-        else
-            if parentname
-                objtitles = [parentname]
-            else
-                # See if they specified the name as a parameter instead of
-                # as a normal name (i.e., before the colon).
-                unless object # we're a builtin
-                    if objclass = Puppet::Type.type(objtype)
-                        namevar = objclass.namevar
-
-                        tmp = hash["name"] || hash[namevar.to_s] 
-
-                        if tmp
-                            objtitles = [tmp]
-                        end
-                    else
-                        # This isn't grammatically legal.
-                        raise Puppet::ParseError, "Got a resource with no title"
-                    end
-                end
-            end
-        end
-
-        # This is where our implicit iteration takes place; if someone
-        # passed an array as the name, then we act just like the called us
-        # many times.
-        objtitles.collect { |objtitle|
-            exceptwrap :type => Puppet::ParseError do
-                exp = self.exported || scope.exported
-                # We want virtual to be true if exported is true.  We can't
-                # just set :virtual => self.virtual in the initialization,
-                # because sometimes the :virtual attribute is set *after*
-                # :exported, in which case it clobbers :exported if :exported
-                # is true.  Argh, this was a very tough one to track down.
-                virt = self.virtual || exported
-                obj = Puppet::Parser::Resource.new(
-                    :type => objtype,
-                    :title => objtitle,
-                    :params => paramobjects,
-                    :file => @file,
-                    :line => @line,
-                    :exported => exp,
-                    :virtual => virt,
-                    :source => scope.source,
-                    :scope => scope
-                )
-
-                # And then store the resource in the scope.
-                # XXX At some point, we need to switch all of this to return
-                # objects instead of storing them like this.
-                scope.setresource(obj)
-                obj
-            end
-        }.reject { |obj| obj.nil? }
-    end
-
-    # Create our ResourceDef.  Handles type checking for us.
-    def initialize(hash)
-        @checked = false
-        super
-
-        #self.typecheck(@type.value)
-    end
-
-    # Set the parameters for our object.
-    def params=(params)
-        if params.is_a?(AST::ASTArray)
-            @params = params
-        else
-            @params = AST::ASTArray.new(
-                :line => params.line,
-                :file => params.file,
-                :children => [params]
-            )
-        end
-    end
-
-    def supercomp
-        unless defined? @supercomp
-            if @scope and comp = @scope.inside
-                @supercomp = comp
-            else
-                error = Puppet::ParseError.new(
-                    "'super' is only valid within definitions"
-                )
-                error.line = self.line
-                error.file = self.file
-                raise error
-            end
-        end
-        @supercomp
-    end
-
-    # Take all of the arguments of our parent and add them into our own,
-    # without overriding anything.
-    def supersetup(hash)
-        comp = supercomp()
-
-        # Now check each of the arguments from the parent.
-        comp.arguments.each do |name, value|
-            unless hash.has_key? name
-                hash[name] = value
-            end
-        end
-
-        # Return the parent name, so it can be used if appropriate.
-        return comp.name
-    end
-
-    # Retrieve our supertype.
-    def supertype
-        unless defined? @supertype
-            if parent = supercomp.parentclass
-                @supertype = parent
-            else
-                error = Puppet::ParseError.new(
-                    "%s does not have a parent class" % comp.type
-                )
-                error.line = self.line
-                error.file = self.file
-                raise error
-            end
-        end
-        @supertype
-    end
-
-    # Print this object out.
-    def tree(indent = 0)
-        return [
-            @type.tree(indent + 1),
-            @title.tree(indent + 1),
-            ((@@indline * indent) + self.typewrap(self.pin)),
-            @params.collect { |param|
-                begin
-                    param.tree(indent + 1)
-                rescue NoMethodError => detail
-                    Puppet.err @params.inspect
-                    error = Puppet::DevError.new(
-                        "failed to tree a %s" % self.class
-                    )
-                    error.set_backtrace detail.backtrace
-                    raise error
-                end
-            }.join("\n")
-        ].join("\n")
-    end
-
-    def to_s
-        return "%s => { %s }" % [@title,
-            @params.collect { |param|
-                param.to_s
-            }.join("\n")
-        ]
-    end
-end
-end
-
-# $Id: resourcedef.rb 1922 2006-12-14 22:50:28Z luke $

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

@@ -1,58 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-    # A reference to an object.  Only valid as an rvalue.
-    class ResourceRef < AST::Branch
-        attr_accessor :title, :type
-
-        def each
-            [@type,@title].flatten.each { |param|
-                #Puppet.debug("yielding param %s" % param)
-                yield param
-            }
-        end
-
-        # Evaluate our object, but just return a simple array of the type
-        # and name.
-        def evaluate(hash)
-            scope = hash[:scope]
-
-            # We want a lower-case type.
-            objtype = @type.downcase
-            title = @title.safeevaluate(:scope => scope)
-
-            if scope.builtintype?(objtype)
-                # nothing
-            elsif dtype = scope.finddefine(objtype)
-                objtype = dtype.classname
-            elsif objtype == "class"
-                # Look up the full path to the class
-                if classobj = scope.findclass(title)
-                    title = classobj.classname
-                else
-                    raise Puppet::ParseError, "Could not find class %s" % title
-                end
-            else
-                raise Puppet::ParseError, "Could not find resource type %s" % objtype
-            end
-
-            return Puppet::Parser::Resource::Reference.new(
-                :type => objtype, :title => title
-            )
-        end
-
-        def tree(indent = 0)
-            return [
-                @type.tree(indent + 1),
-                @title.tree(indent + 1),
-                ((@@indline * indent) + self.typewrap(self.pin))
-            ].join("\n")
-        end
-
-        def to_s
-            return "%s[%s]" % [@type,@title]
-        end
-    end
-end
-
-# $Id: resourceref.rb 2715 2007-07-19 19:23:56Z luke $

data/test/language/ast/component.rb

@@ -1,142 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke A. Kanies on 2006-02-20.
-#  Copyright (c) 2006. All rights reserved.
-
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'mocha'
-require 'puppettest/parsertesting'
-require 'puppettest/resourcetesting'
-
-class TestASTComponent < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::ParserTesting
-    include PuppetTest::ResourceTesting
-	AST = Puppet::Parser::AST
-
-    def test_component
-        interp, scope, source = mkclassframing
-
-        # Create a new definition
-        klass = interp.newdefine "yayness",
-            :arguments => [["owner", stringobj("nobody")], %w{mode}],
-            :code => AST::ASTArray.new(
-                :children => [resourcedef("file", "/tmp/$name",
-                        "owner" => varref("owner"), "mode" => varref("mode"))]
-            )
-
-        # Test validattr? a couple different ways
-        [:owner, "owner", :schedule, "schedule"].each do |var|
-            assert(klass.validattr?(var), "%s was not considered valid" % var.inspect)
-        end
-
-        [:random, "random"].each do |var|
-            assert(! klass.validattr?(var), "%s was considered valid" % var.inspect)
-        end
-        # Now call it a couple of times
-        # First try it without a required param
-        assert_raise(Puppet::ParseError) do
-            klass.evaluate(:scope => scope,
-                :name => "bad",
-                :arguments => {"owner" => "nobody"}
-            )
-        end
-
-        # And make sure it didn't create the file
-        assert_nil(scope.findresource("File[/tmp/bad]"),
-            "Made file with invalid params")
-
-        assert_nothing_raised do
-            klass.evaluate(:scope => scope,
-                :title => "first",
-                :arguments => {"mode" => "755"}
-            )
-        end
-
-        firstobj = scope.findresource("File[/tmp/first]")
-        assert(firstobj, "Did not create /tmp/first obj")
-
-        assert_equal("file", firstobj.type)
-        assert_equal("/tmp/first", firstobj.title)
-        assert_equal("nobody", firstobj[:owner])
-        assert_equal("755", firstobj[:mode])
-
-        # Make sure we can't evaluate it with the same args
-        assert_raise(Puppet::ParseError) do
-            klass.evaluate(:scope => scope,
-                :title => "first",
-                :arguments => {"mode" => "755"}
-            )
-        end
-
-        # Now create another with different args
-        assert_nothing_raised do
-            klass.evaluate(:scope => scope,
-                :title => "second",
-                :arguments => {"mode" => "755", "owner" => "daemon"}
-            )
-        end
-
-        secondobj = scope.findresource("File[/tmp/second]")
-        assert(secondobj, "Did not create /tmp/second obj")
-
-        assert_equal("file", secondobj.type)
-        assert_equal("/tmp/second", secondobj.title)
-        assert_equal("daemon", secondobj[:owner])
-        assert_equal("755", secondobj[:mode])
-    end
-
-    # #539 - definitions should support both names and titles
-    def test_names_and_titles
-        interp, scope, source = mkclassframing
-
-        [
-        {:name => "one", :title => "two"},
-        {:title => "mytitle"},
-        ].each_with_index do |hash, i|
-
-            # Create a definition that uses both name and title
-            klass = interp.newdefine "yayness%s" % i
-
-            subscope = klass.subscope(scope, "yayness%s" % i)
-
-            klass.expects(:subscope).returns(subscope)
-
-            args = {:title => hash[:title]}
-            if hash[:name]
-                args[:arguments] = {:name => hash[:name]}
-            end
-            args[:scope] = scope
-            assert_nothing_raised("Could not evaluate definition with %s" % hash.inspect) do
-                klass.evaluate(args)
-            end
-
-            name = hash[:name] || hash[:title]
-            title = hash[:title]
-            args[:name] ||= name
-
-            assert_equal(name, subscope.lookupvar("name"),
-                "Name did not get set correctly")
-            assert_equal(title, subscope.lookupvar("title"),
-                "title did not get set correctly")
-
-            [:name, :title].each do |param|
-                val = args[param]
-                assert(subscope.tags.include?(val),
-                    "Scope was not tagged with %s" % val)
-            end
-        end
-    end
-
-    # Testing the root cause of #615.  We should be using the fqname for the type, instead
-    # of just the short name.
-    def test_fully_qualified_types
-        interp = mkinterp
-        klass = interp.newclass("one::two")
-
-        assert_equal("one::two", klass.classname, "Class did not get fully qualified class name")
-    end
-end
-# $Id: component.rb 2458 2007-05-03 20:45:25Z luke $