puppet 0.23.2 → 0.24.0

data/lib/puppet/dsl.rb

@@ -67,11 +67,8 @@ module Puppet
 
         def apply
             bucket = export()
-            objects = bucket.to_type
-            master = Puppet::Network::Client.master.new :Master => "whatever"
-            master.objects = objects
-
-            master.apply
+            catalog = bucket.to_catalog
+            catalog.apply
         end
 
         def export
@@ -84,6 +81,7 @@ module Puppet
             end
             bucket = Puppet::TransBucket.new(objects)
             bucket.name = "top"
+            bucket.type = "class"
 
             return bucket
         end
@@ -113,10 +111,6 @@ module Puppet
 
         @aspects = {}
 
-        # For now, just do some hackery so resources work
-        @@interp = Puppet::Parser::Interpreter.new :Code => ""
-        @@scope = Puppet::Parser::Scope.new(:interp => @@interp)
-
         @@objects = Hash.new do |hash, key|
             hash[key] = {}
         end
@@ -237,7 +231,7 @@ module Puppet
             end
             unless obj = @@objects[type][name]
                 obj = Resource.new :title => name, :type => type.name,
-                    :source => source, :scope => @@scope
+                    :source => source, :scope => scope
                 @@objects[type][name] = obj
 
                 @resources << obj
@@ -250,122 +244,34 @@ module Puppet
                     :source => source
                 )
 
-                obj.set(param)
+                obj.send(:set_parameter, param)
             end
 
             obj
         end
 
-        def type
-            self.name
-        end
-    end
-end
-
-@aspects = {}
-
-class Puppet::DisabledDSL
-    @@subs = {}
-    @name = :DSLClass
-    class << self
-        include Enumerable
-        attr_accessor :included, :name, :objects
-
-        def each
-            @@subs.each do |name, sub|
-                yield name, sub
-            end
-        end
-
-        def export
-            bucket = nil
-            if superclass() != Puppet::DSL
-                bucket = superclass.export
-            else
-                bucket = Puppet::TransBucket.new
-                bucket.keyword = "class"
-                bucket.type = self.name
-            end
-
-            @objects.each do |type, ary|
-                ary.each do |name, obj|
-                    if pobj = bucket.find { |sobj| obj.name == sobj.name &&  obj.type == sobj.type }
-                        obj.each do |param, value|
-                            pobj[param] = value
-                        end
-                    else
-                        bucket.push obj
-                    end
+        def scope
+            unless defined?(@scope)
+                # Set the code to something innocuous; we just need the
+                # scopes, not the interpreter.  Hackish, but true.
+                Puppet[:code] = " "
+                @interp = Puppet::Parser::Interpreter.new
+                require 'puppet/node'
+                @node = Puppet::Node.new(Facter.value(:hostname))
+                if env = Puppet[:environment] and env == ""
+                    env = nil
                 end
+                @node.parameters = Facter.to_hash
+                @compile = Puppet::Parser::Compile.new(@node, @interp.send(:parser, env))
+                @scope = @compile.topscope
             end
-
-            return bucket
+            @scope
         end
 
-        def include(name)
-            if ary = @@subs.find { |n, s| n == name }
-                ary[1].included = true
-            else
-                raise "Could not find class %s" % name
-            end
-        end
-
-        def inherited(sub)
-            name = sub.to_s.downcase.gsub(/.+::/, '').intern
-            @@subs[name] = sub
-            sub.name = name
-            sub.initvars
-
-            sub
-        end
-
-        def initvars
-            #if superclass() == Puppet::DSL
-                @objects = {}
-            #else
-            #    @objects = superclass.objects
-            #end
-        end
-
-
-        def import(file)
-            text = File.read(file)
-            # If they don't specify a parent class, then specify one
-            # for them.
-            text.gsub!(/^class \S+\s*$/) do |match|
-                "#{match} < Puppet::DSL"
-            end
-            eval(text, binding)
-        end
-
-        def method_missing(method, *args)
-            if klass = Puppet::Type.type(method)
-                method = method.intern if method.is_a? String
-                @objects[method] ||= {}
-
-                names = args.shift
-                hash = args.shift
-                names = [names] unless names.is_a? Array
-                names.each do |name|
-                    unless obj = @objects[method][name]
-                        obj = Puppet::TransObject.new(name, method)
-                        @objects[method][name] = obj
-                    end
-
-                    hash.each do |param, value|
-                        if obj[param]
-                            raise "Cannot override %s in %s[%s]" %
-                                [param, method, name]
-                        else
-                            obj[param] = value
-                        end
-                    end
-                end
-            else
-                raise "No type %s" % method
-            end
+        def type
+            self.name
         end
     end
 end
 
-# $Id: dsl.rb 2259 2007-03-06 19:03:05Z luke $
+@aspects = {}

data/lib/puppet/error.rb

@@ -41,14 +41,5 @@ module Puppet # :nodoc:
     # An error class for when I don't know what happened.  Automatically
     # prints a stack trace when in debug mode.
     class DevError < Puppet::Error
-        # XXX This is probably the wrong way to do this, but...
-        def set_backtrace(trace)
-            if Puppet[:trace]
-                puts trace
-            end
-            super
-        end
     end
 end
-
-# $Id: error.rb 2324 2007-03-19 19:16:10Z luke $

data/lib/puppet/event.rb

@@ -26,4 +26,3 @@ module Puppet
 	end
 end
 
-# $Id: event.rb 1964 2006-12-23 04:49:56Z luke $

data/lib/puppet/external/gratr/rdot.rb

@@ -1,6 +1,5 @@
 # rdot.rb
 # 
-# $Id: rdot.rb 1892 2006-11-17 20:15:23Z luke $
 #
 # This is a modified version of dot.rb from Dave Thomas's rdoc project.  I [Horst Duchene]
 # renamed it to rdot.rb to avoid collision with an installed rdoc/dot.

data/lib/puppet/external/lock.rb

@@ -61,4 +61,3 @@ class File
     end
 end
 
-# $Id: lock.rb 2119 2007-01-30 05:27:56Z luke $

data/lib/puppet/feature/base.rb

@@ -18,6 +18,7 @@ Puppet.features.add(:libshadow, :libs => ["shadow"])
 Puppet.features.add(:root) { require 'puppet/util/suidmanager'; Puppet::Util::SUIDManager.uid == 0 }
 
 # We've got mongrel available
-Puppet.features.add(:mongrel, :libs => %w{rubygems mongrel puppet/network/server/mongrel})
+Puppet.features.add(:mongrel, :libs => %w{rubygems mongrel puppet/network/http_server/mongrel})
 
-# $Id: base.rb 2577 2007-06-14 03:39:23Z luke $
+# We have lcs diff
+Puppet.features.add :diff, :libs => %w{diff/lcs diff/lcs/hunk}

data/lib/puppet/feature/rails.rb

@@ -49,4 +49,3 @@ Puppet.features.add(:rails) do
     end
 end
 
-# $Id: rails.rb 2195 2007-02-15 22:36:38Z shadoi $

data/lib/puppet/file_serving.rb

@@ -0,0 +1,7 @@
+#
+#  Created by Luke Kanies on 2007-10-16.
+#  Copyright (c) 2007. All rights reserved.
+
+# Just a stub class.
+class Puppet::FileServing # :nodoc:
+end

data/lib/puppet/file_serving/configuration.rb

@@ -0,0 +1,129 @@
+#
+#  Created by Luke Kanies on 2007-10-16.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet'
+require 'puppet/file_serving'
+require 'puppet/file_serving/mount'
+
+class Puppet::FileServing::Configuration
+    require 'puppet/file_serving/configuration/parser'
+
+    @config_fileuration = nil
+
+    Mount = Puppet::FileServing::Mount
+
+    # Remove our singleton instance.
+    def self.clear_cache
+        @config_fileuration = nil
+    end
+
+    # Create our singleton configuration.
+    def self.create
+        unless @config_fileuration
+            @config_fileuration = new()
+        end
+        @config_fileuration
+    end
+
+    private_class_method  :new
+
+    # Verify that the client is allowed access to this file.
+    def authorized?(file, options = {})
+        mount, file_path = split_path(file, options[:node])
+        # If we're not serving this mount, then access is denied.
+        return false unless mount
+        return mount.allowed?(options[:node], options[:ipaddress])
+    end
+
+    # Search for a file.
+    def file_path(key, options = {})
+        mount, file_path = split_path(key, options[:node])
+
+        return nil unless mount
+
+        # The mount checks to see if the file exists, and returns nil
+        # if not.
+        return mount.file(file_path, options)
+    end
+
+    def initialize
+        @mounts = {}
+        @config_file = nil
+
+        # We don't check to see if the file is modified the first time,
+        # because we always want to parse at first.
+        readconfig(false)
+    end
+
+    # Is a given mount available?
+    def mounted?(name)
+        @mounts.include?(name)
+    end
+
+    def umount(name)
+        @mounts.delete(name) if @mounts.include? name
+    end
+
+    private
+
+    # Deal with ignore parameters.
+    def handleignore(children, path, ignore)            
+        ignore.each { |ignore|                
+            Dir.glob(File.join(path,ignore), File::FNM_DOTMATCH) { |match|
+                children.delete(File.basename(match))
+            }                
+        }
+        return children
+    end  
+
+    # Read the configuration file.
+    def readconfig(check = true)
+        config = Puppet[:fileserverconfig]
+
+        return unless FileTest.exists?(config)
+
+        @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
+
+        if check and ! @parser.changed?
+            return
+        end
+
+        # Don't assign the mounts hash until we're sure the parsing succeeded.
+        begin
+            newmounts = @parser.parse
+            @mounts = newmounts
+        rescue => detail
+            Puppet.err "Error parsing fileserver configuration: %s; using old configuration" % detail
+        end
+    end
+
+    # Split the path into the separate mount point and path.
+    def split_path(uri, node)
+        # Reparse the configuration if necessary.
+        readconfig
+
+        raise(ArgumentError, "Cannot find file: Invalid path '%s'" % uri) unless uri =~ %r{/([-\w]+)/?}
+
+        # the dir is based on one of the mounts
+        # so first retrieve the mount path
+        mount = path = nil
+        # Strip off the mount name.
+        mount_name, path = uri.sub(%r{^/}, '').split(File::Separator, 2)
+
+        return nil unless mount = @mounts[mount_name]
+
+        if path == ""
+            path = nil
+        elsif path
+            # Remove any double slashes that might have occurred
+            path = URI.unescape(path.gsub(/\/\//, "/"))
+        end
+
+        return mount, path
+    end
+
+    def to_s
+        "fileserver"
+    end
+end

data/lib/puppet/file_serving/configuration/parser.rb

@@ -0,0 +1,124 @@
+require 'puppet/file_serving/configuration'
+require 'puppet/util/loadedfile'
+
+class Puppet::FileServing::Configuration::Parser < Puppet::Util::LoadedFile
+    Mount = Puppet::FileServing::Mount
+    MODULES = 'modules'
+
+    # Parse our configuration file.
+    def parse
+        raise("File server configuration %s does not exist" % self.file) unless FileTest.exists?(self.file)
+        raise("Cannot read file server configuration %s" % self.file) unless FileTest.readable?(self.file)
+
+        @mounts = {}
+        @count = 0
+
+        File.open(self.file) { |f|
+            mount = nil
+            f.each { |line|
+                # Have the count increment at the top, in case we throw exceptions.
+                @count += 1
+
+                case line
+                when /^\s*#/: next # skip comments
+                when /^\s*$/: next # skip blank lines
+                when /\[([-\w]+)\]/:
+                    mount = newmount($1)
+                when /^\s*(\w+)\s+(.+)$/:
+                    var = $1
+                    value = $2
+                    raise(ArgumentError, "Fileserver configuration file does not use '=' as a separator") if value =~ /^=/
+                    case var
+                    when "path":
+                        path(mount, value)
+                    when "allow":
+                        allow(mount, value)
+                    when "deny":
+                        deny(mount, value)
+                    else
+                        raise ArgumentError.new("Invalid argument '%s'" % var,
+                            @count, file)
+                    end
+                else
+                    raise ArgumentError.new("Invalid line '%s'" % line.chomp,
+                        @count, file)
+                end
+            }
+        }
+
+        return @mounts
+    end
+
+    private
+
+    # Add the mount for getting files from modules.
+    def add_module_mount
+        unless @mounts[MODULES]
+            mount = Mount.new(MODULES)
+            mount.allow("*")
+            @mounts[MODULES] = mount
+        end
+    end
+
+    # Allow a given pattern access to a mount.
+    def allow(mount, value)
+        value.split(/\s*,\s*/).each { |val|
+            begin
+                mount.info "allowing %s access" % val
+                mount.allow(val)
+            rescue AuthStoreError => detail
+                raise ArgumentError.new(detail.to_s,
+                    @count, file)
+            end
+        }
+    end
+
+    # Deny a given pattern access to a mount.
+    def deny(mount, value)
+        value.split(/\s*,\s*/).each { |val|
+            begin
+                mount.info "denying %s access" % val
+                mount.deny(val)
+            rescue AuthStoreError => detail
+                raise ArgumentError.new(detail.to_s,
+                    @count, file)
+            end
+        }
+    end
+
+    # Create a new mount.
+    def newmount(name)
+        if @mounts.include?(name)
+            raise ArgumentError, "%s is already mounted at %s" %
+                [@mounts[name], name], @count, file
+        end
+        mount = Mount.new(name)
+        @mounts[name] = mount
+        return mount
+    end
+
+    # Set the path for a mount.
+    def path(mount, value)
+        if mount.name == MODULES
+            Puppet.warning "The '#{MODULES}' module can not have a path. Ignoring attempt to set it"
+        else
+            begin
+                mount.path = value
+            rescue ArgumentError => detail
+                Puppet.err "Removing mount %s: %s" %
+                    [mount.name, detail]
+                @mounts.delete(mount.name)
+            end
+        end
+    end
+
+    # Make sure all of our mounts are valid.  We have to do this after the fact
+    # because details are added over time as the file is parsed.
+    def validate
+        @mounts.each { |name, mount|
+            unless mount.valid?
+                raise ArgumentError, "No path specified for mount %s" % name
+            end
+        }
+    end
+end