puppet 0.18.4 → 0.22.4

data/lib/puppet/util/plist/parser.rb

@@ -0,0 +1,227 @@
+#--###########################################################
+# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
+# Patrick May <patrick@hexane.org>                           #
+#                                                            #
+# Distributed under the MIT license.                         #
+##############################################################
+#++
+# Plist parses Mac OS X xml property list files into ruby data structures.
+#
+# === Load a plist file
+# This is the main point of the library:
+#
+#   r = Plist::parse_xml( filename_or_xml )
+module Plist
+# Note that I don't use these two elements much:
+#
+#  + Date elements are returned as DateTime objects.
+#  + Data elements are implemented as Tempfiles
+#
+# Plist::parse_xml will blow up if it encounters a data element.
+# If you encounter such an error, or if you have a Date element which
+# can't be parsed into a Time object, please send your plist file to
+# plist@hexane.org so that I can implement the proper support.
+  def Plist::parse_xml( filename_or_xml )
+    listener = Listener.new
+    #parser = REXML::Parsers::StreamParser.new(File.new(filename), listener)
+    parser = StreamParser.new(filename_or_xml, listener)
+    parser.parse
+    listener.result
+  end
+
+  class Listener
+    #include REXML::StreamListener
+
+    attr_accessor :result, :open
+
+    def initialize
+      @result = nil
+      @open   = Array.new
+    end
+
+
+    def tag_start(name, attributes)
+      @open.push PTag::mappings[name].new
+    end
+
+    def text( contents )
+      @open.last.text = contents if @open.last
+    end
+
+    def tag_end(name)
+      last = @open.pop
+      if @open.empty?
+        @result = last.to_ruby
+      else
+        @open.last.children.push last
+      end
+    end
+  end
+
+  class StreamParser
+    def initialize( filename_or_xml, listener )
+      @filename_or_xml = filename_or_xml
+      @listener = listener
+    end
+
+    TEXT       = /([^<]+)/
+    XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>*/um
+    DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/um
+    COMMENT_START = /\A<!--/u
+    COMMENT_END = /.*?-->/um
+
+
+    def parse
+      plist_tags = PTag::mappings.keys.join('|')
+      start_tag  = /<(#{plist_tags})([^>]*)>/i
+      end_tag    = /<\/(#{plist_tags})[^>]*>/i
+
+      require 'strscan'
+
+      contents = (
+        if (File.exists? @filename_or_xml)
+          File.open(@filename_or_xml) {|f| f.read}
+        else
+          @filename_or_xml
+        end
+      )
+
+      @scanner = StringScanner.new( contents )
+      until @scanner.eos?
+        if @scanner.scan(COMMENT_START)
+          @scanner.scan(COMMENT_END)
+        elsif @scanner.scan(XMLDECL_PATTERN)
+        elsif @scanner.scan(DOCTYPE_PATTERN)
+        elsif @scanner.scan(start_tag)
+          @listener.tag_start(@scanner[1], nil)
+          if (@scanner[2] =~ /\/$/)
+            @listener.tag_end(@scanner[1])
+          end
+        elsif @scanner.scan(TEXT)
+          @listener.text(@scanner[1])
+        elsif @scanner.scan(end_tag)
+          @listener.tag_end(@scanner[1])
+        else
+          raise "Unimplemented element"
+        end
+      end
+    end
+  end
+
+  class PTag
+    @@mappings = { }
+    def PTag::mappings
+      @@mappings
+    end
+
+    def PTag::inherited( sub_class )
+      key = sub_class.to_s.downcase
+      key.gsub!(/^plist::/, '' )
+      key.gsub!(/^p/, '')  unless key == "plist"
+
+      @@mappings[key] = sub_class
+    end
+
+    attr_accessor :text, :children
+    def initialize
+      @children = Array.new
+    end
+
+    def to_ruby
+      raise "Unimplemented: " + self.class.to_s + "#to_ruby on #{self.inspect}"
+    end
+  end
+
+  class PList < PTag
+    def to_ruby
+      children.first.to_ruby if children.first
+    end
+  end
+
+  class PDict < PTag
+    def to_ruby
+      dict = Hash.new
+      key = nil
+
+      children.each do |c|
+        if key.nil?
+          key = c.to_ruby
+        else
+          dict[key] = c.to_ruby
+          key = nil
+        end
+      end
+
+      dict
+    end
+  end
+
+  class PKey < PTag
+    def to_ruby
+      CGI::unescapeHTML(text || '')
+    end
+  end
+
+  class PString < PTag
+    def to_ruby
+      CGI::unescapeHTML(text || '')
+    end
+  end
+
+  class PArray < PTag
+    def to_ruby
+      children.collect do |c|
+        c.to_ruby
+      end
+    end
+  end
+
+  class PInteger < PTag
+    def to_ruby
+      text.to_i
+    end
+  end
+
+  class PTrue < PTag
+    def to_ruby
+      true
+    end
+  end
+
+  class PFalse < PTag
+    def to_ruby
+      false
+    end
+  end
+
+  class PReal < PTag
+    def to_ruby
+      text.to_f
+    end
+  end
+
+  require 'date'
+  class PDate < PTag
+    def to_ruby
+      DateTime.parse(text)
+    end
+  end
+
+  require 'base64'
+  class PData < PTag
+    def to_ruby
+      data = Base64.decode64(text.gsub(/\s+/, ''))
+
+      begin
+        return Marshal.load(data)
+      rescue Exception => e
+        io = StringIO.new
+        io.write data
+        io.rewind
+        return io
+      end
+    end
+  end
+end
+
+# $Id: parser.rb 1781 2006-10-16 01:01:35Z luke $

data/lib/puppet/util/posix.rb

@@ -0,0 +1,87 @@
+# Utility methods for interacting with POSIX objects; mostly user and group
+module Puppet::Util::POSIX
+    # Retrieve a field from a POSIX Etc object.  The id can be either an integer
+    # or a name.  This only works for users and groups.
+    def get_posix_field(space, field, id)
+        if id =~ /^\d+$/
+            id = Integer(id)
+        end
+        prefix = "get" + space.to_s
+        if id.is_a?(Integer)
+            if id > 1000000
+                Puppet.err "Tried to get %s field for silly id %s" % [field, id]
+                return nil
+            end
+            method = (prefix + idfield(space).to_s).intern
+        else
+            method = (prefix + "nam").intern
+        end
+
+        begin
+            return Etc.send(method, id).send(field)
+        rescue ArgumentError => detail
+            # ignore it; we couldn't find the object
+            return nil
+        end
+    end
+    
+    # Look in memory for an already-managed type and use its info if available.
+    def get_provider_value(type, field, id)
+        unless typeklass = Puppet::Type.type(type)
+            raise ArgumentError, "Invalid type %s" % type
+        end
+        
+        id = id.to_s
+        
+        chkfield = idfield(type)
+        obj = typeklass.find { |obj|
+            if id =~ /^\d+$/
+                obj.should(chkfield).to_s == id ||
+                    obj.is(chkfield).to_s == id
+            else 
+                obj[:name] == id
+            end                    
+        }
+        
+        return nil unless obj
+        
+        if obj.provider
+            begin
+                val = obj.provider.send(field)
+                if val == :absent
+                    return nil
+                else
+                    return val
+                end
+            rescue => detail
+                if Puppet[:trace]
+                    puts detail.backtrace
+                    Puppet.err detail
+                    return nil
+                end
+            end
+        end
+    end
+    
+    # Determine what the field name is for users and groups.
+    def idfield(space)
+        case Puppet::Util.symbolize(space)
+        when :gr, :group: return :gid
+        when :pw, :user: return :uid
+        else
+            raise ArgumentError.new("Can only handle users and groups")
+        end
+    end
+    
+    # Get the GID of a given group, provided either a GID or a name
+    def gid(group)
+        get_provider_value(:group, :gid, group) or get_posix_field(:gr, :gid, group)
+    end
+
+    # Get the UID of a given user, whether a UID or name is provided
+    def uid(user)
+        get_provider_value(:user, :uid, user) or get_posix_field(:pw, :uid, user)
+    end
+end
+
+# $Id: posix.rb 2052 2007-01-05 17:09:04Z luke $

data/lib/puppet/util/provider_features.rb

@@ -0,0 +1,170 @@
+# Provides feature definitions.
+require 'puppet/util/methodhelper'
+require 'puppet/util/docs'
+require 'puppet/util'
+module Puppet::Util::ProviderFeatures
+    include Puppet::Util::Docs
+    # The class that models the features and handles checking whether the features
+    # are present.
+    class ProviderFeature
+        include Puppet::Util
+        include Puppet::Util::MethodHelper
+        include Puppet::Util::Docs
+        attr_accessor :name, :docs, :methods
+
+        # Are all of the requirements met?
+        def available?(obj)
+            if self.methods 
+                if methods_available?(obj)
+                    return true
+                else
+                    return false
+                end
+            else
+                # In this case, the provider has to declare support for this
+                # feature, and that's been checked before we ever get to the
+                # method checks.
+                return false
+            end
+        end
+
+        def initialize(name, docs, hash)
+            self.name = symbolize(name)
+            self.docs = docs
+            hash = symbolize_options(hash)
+            set_options(hash)
+        end
+
+        private
+
+        # Are all of the required methods available?
+        def methods_available?(obj)
+            methods.each do |m|
+                if obj.is_a?(Class)
+                    return false unless obj.public_method_defined?(m)
+                else
+                    return false unless obj.respond_to?(m)
+                end
+            end
+            return true
+        end
+    end
+
+    # Define one or more features.  At a minimum, features require a name
+    # and docs, and at this point they should also specify a list of methods
+    # required to determine if the feature is present.
+    def feature(name, docs, hash = {})
+        @features ||= {}
+        if @features.include?(name)
+            raise Puppet::DevError, "Feature %s is already defined" % name
+        end
+        begin
+            obj = ProviderFeature.new(name, docs, hash)
+            @features[obj.name] = obj
+        rescue ArgumentError => detail
+            error = ArgumentError.new(
+                "Could not create feature %s: %s" % [name, detail]
+            )
+            error.set_backtrace(detail.backtrace)
+            raise error
+        end
+    end
+
+    # Return a hash of all feature documentation.
+    def featuredocs
+        str = ""
+        @features ||= {}
+        return nil if @features.empty?
+        names = @features.keys.sort { |a,b| a.to_s <=> b.to_s }
+        names.each do |name|
+            doc = @features[name].docs.gsub(/\n\s+/, " ")
+            str += "- **%s**: %s\n" % [name, doc]
+        end
+
+        if providers.length > 0
+            headers = ["Provider", names].flatten
+            data = {}
+            providers.each do |provname|
+                data[provname] = []
+                prov = provider(provname)
+                names.each do |name|
+                    if prov.feature?(name)
+                        data[provname] << "**X**"
+                    else
+                        data[provname] << ""
+                    end
+                end
+            end
+            str += doctable(headers, data)
+        end
+        str
+    end
+
+    # Generate a module that sets up the boolean methods to test for given
+    # features.
+    def feature_module
+        unless defined? @feature_module
+            @features ||= {}
+            @feature_module = ::Module.new
+            const_set("FeatureModule", @feature_module)
+            features = @features
+            # Create a feature? method that can be passed a feature name and
+            # determine if the feature is present.
+            @feature_module.send(:define_method, :feature?) do |name|
+                method = name.to_s + "?"
+                if respond_to?(method) and send(method)
+                    return true
+                else
+                    return false
+                end
+            end
+
+            # Create a method that will list all functional features.
+            @feature_module.send(:define_method, :features) do
+                return false unless defined?(features)
+                features.keys.find_all { |n| feature?(n) }.sort { |a,b| 
+                    a.to_s <=> b.to_s 
+                }
+            end
+
+            # Create a method that will list all functional features.
+            @feature_module.send(:define_method, :satisfies?) do |*needed|
+                ret = true
+                needed.flatten.each do |feature|
+                    unless feature?(feature)
+                        ret = false
+                        break
+                    end
+                end
+                ret
+            end
+
+            # Create a boolean method for each feature so you can test them
+            # individually as you might need.
+            @features.each do |name, feature|
+                method = name.to_s + "?"
+                @feature_module.send(:define_method, method) do
+                    if defined? @declared_features and @declared_features.include?(name)
+                        true
+                    elsif feature.available?(self)
+                        true
+                    else
+                        false
+                    end
+                end
+            end
+
+            # Allow the provider to declare that it has a given feature.
+            @feature_module.send(:define_method, :has_features) do |*names|
+                @declared_features ||= []
+                names.each do |name|
+                    name = symbolize(name)
+                    @declared_features << name
+                end
+            end
+        end
+        @feature_module
+    end
+end
+
+# $Id: provider_features.rb 2413 2007-04-25 20:04:59Z luke $