puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/vendor/rgen/lib/rgen/util/auto_class_creator.rb

@@ -0,0 +1,61 @@
+# RGen Framework
+# (c) Martin Thiede, 2006
+
+require 'rgen/metamodel_builder'
+
+module RGen
+
+module Util
+
+class Base
+	extend MetamodelBuilder
+	def initialize(env=nil)
+		env << self if env
+	end
+end
+
+class AutoCreatedClass < Base
+	def method_missing(m,*args)
+		return super unless self.class.parent.accEnabled
+		if m.to_s =~ /(.*)=$/ 
+			self.class.has_one($1)
+			send(m,args[0])
+		elsif args.size == 0
+			self.class.has_many(m)
+			send(m)
+		end
+	end
+end
+
+# will be "extended" to the auto created class
+module ParentAccess
+	def parent=(p)
+		@parent = p
+	end
+	def parent
+		@parent
+	end
+end
+
+module AutoClassCreator
+	attr_reader :accEnabled
+	def const_missing(className)
+		return super unless @accEnabled
+		module_eval("class "+className.to_s+" < RGen::AutoCreatedClass; end")
+		c = const_get(className)
+		c.extend(ParentAccess)
+		c.parent = self
+		c
+	end
+	def enableACC
+		@accEnabled = true
+	end
+	def disableACC
+		@accEnabled = false
+	end
+end
+
+end
+
+end
+

data/lib/puppet/vendor/rgen/lib/rgen/util/cached_glob.rb

@@ -0,0 +1,67 @@
+module RGen
+
+module Util
+
+# WARNING: the mechanism of taking timestamps of directories in order to find out if the
+# content has changed doesn't work reliably across all kinds of filesystems
+#
+class CachedGlob
+
+  def initialize(dir_glob, file_glob)
+    @dir_glob = dir_glob
+    @file_glob = file_glob
+    @root_dirs = []
+    @dirs = {}
+    @files = {}
+    @timestamps = {}
+  end
+
+  # returns all files contained in directories matched by +dir_glob+ which match +file_glob+.
+  # +file_glob+ must be relative to +dir_glob+.
+  # dir_glob "*/a" with file_glob "**/*.txt" is basically equivalent with Dir.glob("*/a/**/*.txt")
+  # the idea is that the file glob will only be re-eavluated when the content of one of the 
+  # directories matched by dir_glob has changed.
+  # this will only be faster than a normal Dir.glob if the number of dirs matched by dir_glob is
+  # relatively large and changes in files affect only a few of them at a time.
+  def glob
+    root_dirs = Dir.glob(@dir_glob)
+    (@root_dirs - root_dirs).each do |d|
+      remove_root_dir(d)
+    end
+    (@root_dirs & root_dirs).each do |d|
+      update_root_dir(d) if dir_changed?(d)
+    end
+    (root_dirs - @root_dirs).each do |d|
+      update_root_dir(d)
+    end
+    @root_dirs = root_dirs
+    @root_dirs.sort.collect{|d| @files[d]}.flatten
+  end
+
+  private
+
+  def dir_changed?(dir)
+    @dirs[dir].any?{|d| File.mtime(d) != @timestamps[dir][d]}
+  end
+
+  def update_root_dir(dir)
+    @dirs[dir] = Dir.glob(dir+"/**/")
+    @files[dir] = Dir.glob(dir+"/"+@file_glob)
+    @timestamps[dir] = {}
+    @dirs[dir].each do |d|
+      @timestamps[dir][d] = File.mtime(d)
+    end
+  end
+
+  def remove_root_dir(dir)
+    @dirs.delete(dir)
+    @files.delete(dir)
+    @timestamps.delete(dir)
+  end
+
+end
+
+end
+
+end
+

data/lib/puppet/vendor/rgen/lib/rgen/util/file_cache_map.rb

@@ -0,0 +1,124 @@
+require 'digest'
+require 'fileutils'
+
+module RGen
+
+module Util
+
+# Implements a cache for storing and loading data associated with arbitrary files.
+# The data is stored in cache files within a subfolder of the folder where
+# the associated files exists.
+# The cache files are protected with a checksum and loaded data will be
+# invalid in case either the associated file are the cache file has changed.
+#
+class FileCacheMap
+  # optional program version info to be associated with the cache files
+  # if the program version changes, cached data will also be invalid
+  attr_accessor :version_info
+
+  # +cache_dir+ is the name of the subfolder where cache files are created
+  # +postfix+ is an extension appended to the original file name for 
+  # creating the name of the cache file
+  def initialize(cache_dir, postfix)
+    @postfix = postfix
+    @cache_dir = cache_dir
+  end
+
+  # load data associated with file +key_path+
+  # returns :invalid in case either the associated file or the cache file has changed
+  #
+  # options:
+  #  :invalidation_reasons:
+  #    an array which will receive symbols indicating why the cache is invalid:
+  #    :no_cachefile, :cachefile_corrupted, :keyfile_changed
+  #
+  def load_data(key_path, options={})
+    reasons = options[:invalidation_reasons] || []
+    cf = cache_file(key_path)
+    result = nil
+    begin
+      File.open(cf, "rb") do |f|
+        header = f.read(41)
+        if !header
+          reasons << :cachefile_corrupted
+          return :invalid
+        end
+        checksum = header[0..39]
+        data = f.read
+        if calc_sha1(data) == checksum
+          if calc_sha1_keydata(key_path) == data[0..39]
+            result = data[41..-1]
+          else
+            reasons << :keyfile_changed
+            result = :invalid
+          end
+        else
+          reasons << :cachefile_corrupted
+          result = :invalid
+        end
+      end 
+    rescue Errno::ENOENT
+      reasons << :no_cachefile
+      result = :invalid 
+    end
+    result
+  end
+
+  # store data +value_data+ associated with file +key_path+
+  def store_data(key_path, value_data)
+    data = calc_sha1_keydata(key_path) + "\n" + value_data
+    data = calc_sha1(data) + "\n" + data
+    cf = cache_file(key_path)
+    FileUtils.mkdir(File.dirname(cf)) rescue Errno::EEXIST
+    File.open(cf, "wb") do |f|
+      f.write(data)
+    end 
+  end
+
+  # remove cache files which are not associated with any file in +key_paths+
+  # will only remove files within +root_path+
+  def clean_unused(root_path, key_paths)
+    raise "key paths must be within root path" unless key_paths.all?{|p| p.index(root_path) == 0}
+    used_files = key_paths.collect{|p| cache_file(p)}
+    files = Dir[root_path+"/**/"+@cache_dir+"/*"+@postfix] 
+    files.each do |f|
+      FileUtils.rm(f) unless used_files.include?(f)
+    end
+  end
+
+private
+  
+  def cache_file(path)
+    File.dirname(path) + "/"+@cache_dir+"/" + File.basename(path) + @postfix 
+  end
+
+  def calc_sha1(data)
+    sha1 = Digest::SHA1.new
+    sha1.update(data)
+    sha1.hexdigest
+  end
+
+  def keyData(path)
+    File.read(path)+@version_info.to_s
+  end
+
+  # this method is much faster than calling +keyData+ and putting the result in +calc_sha1+
+  # reason is probably that there are not so many big strings being created
+  def calc_sha1_keydata(path)
+    begin
+      sha1 = Digest::SHA1.new
+      sha1.file(path)
+      sha1.update(@version_info.to_s)
+      sha1.hexdigest
+    rescue Errno::ENOENT
+      "<missing_key_file>"
+    end
+  end
+   
+end
+
+end
+
+end
+
+

data/lib/puppet/vendor/rgen/lib/rgen/util/file_change_detector.rb

@@ -0,0 +1,84 @@
+require 'digest'
+
+module RGen
+
+module Util
+
+# The FileChangeDetector detects changes in a set of files.
+# Changes are detected between successive calls to check_files with a give set of files.
+# Changes include files being added, removed or having changed their content.
+#
+class FileChangeDetector
+
+  FileInfo = Struct.new(:timestamp, :digest)
+
+  # Create a FileChangeDetector, options include:
+  #
+  #  :file_added
+  #    a proc which is called when a file is added, receives the filename
+  #
+  #  :file_removed
+  #    a proc which is called when a file is removed, receives the filename
+  #
+  #  :file_changed
+  #    a proc which is called when a file is changed, receives the filename
+  #
+  def initialize(options={})
+    @file_added = options[:file_added]
+    @file_removed = options[:file_removed]
+    @file_changed = options[:file_changed]
+    @file_info = {}
+  end
+
+  # Checks if any of the files has changed compared to the last call of check_files.
+  # When called for the first time on a new object, all files will be reported as being added.
+  # 
+  def check_files(files)
+    files_before = @file_info.keys
+    used_files = {} 
+    files.each do |file|
+      begin
+        if @file_info[file]
+          if @file_info[file].timestamp != File.mtime(file)
+            @file_info[file].timestamp = File.mtime(file)
+            digest = calc_digest(file)
+            if @file_info[file].digest != digest
+              @file_info[file].digest = digest 
+              @file_changed && @file_changed.call(file)
+            end
+          end
+        else
+          @file_info[file] = FileInfo.new
+          @file_info[file].timestamp = File.mtime(file)
+          @file_info[file].digest = calc_digest(file)
+          @file_added && @file_added.call(file)
+        end
+        used_files[file] = true
+      # protect against missing files
+      rescue Errno::ENOENT
+        # used_files is not set and @file_info will be removed below
+        # notification hook hasn't been called yet since it comes after file accesses
+      end
+    end
+    files_before.each do |file|
+      if !used_files[file]
+        @file_info.delete(file)
+        @file_removed && @file_removed.call(file)
+      end
+    end
+  end
+
+  private
+
+  def calc_digest(file)
+    sha1 = Digest::SHA1.new
+    sha1.file(file)
+    sha1.hexdigest
+  end
+
+end
+
+end
+
+end
+

data/lib/puppet/vendor/rgen/lib/rgen/util/method_delegation.rb

@@ -0,0 +1,114 @@
+module RGen
+
+module Util
+  
+module MethodDelegation
+
+class << self
+  
+  def registerDelegate(delegate, object, method)
+    method = method.to_sym
+    createDelegateStore(object)
+    if object._methodDelegates[method]
+      object._methodDelegates[method] << delegate
+    else
+      object._methodDelegates[method] = [delegate]
+      createDelegatingMethod(object, method)
+    end
+  end
+  
+  def unregisterDelegate(delegate, object, method)
+    method = method.to_sym
+    return unless object.respond_to?(:_methodDelegates)
+    return unless object._methodDelegates[method]
+    object._methodDelegates[method].delete(delegate)
+    if object._methodDelegates[method].empty?
+      object._methodDelegates[method] = nil
+      removeDelegatingMethod(object, method)
+      removeDelegateStore(object)
+    end
+  end
+
+  private
+  
+  def createDelegateStore(object)
+    return if object.respond_to?(:_methodDelegates)
+    class << object
+      def _methodDelegates
+        @_methodDelegates ||= {}
+      end
+    end
+  end
+  
+  def removeDelegateStore(object)
+    return unless object.respond_to?(:_methodDelegates)
+    class << object
+      remove_method(:_methodDelegates)
+    end
+  end
+  
+  def createDelegatingMethod(object, method)
+    if hasMethod(object, method)
+      object.instance_eval <<-END
+        class << self
+          alias #{aliasMethodName(method)} #{method}
+        end
+      END
+    end
+    
+    # define the delegating method
+    object.instance_eval <<-END
+      class << self
+        def #{method}(*args, &block)
+          @_methodDelegates[:#{method}].each do |d|
+            catch(:continue) do
+              return d.#{method}_delegated(self, *args, &block)
+            end
+          end
+          # if aliased method does not exist, we want an exception
+          #{aliasMethodName(method)}(*args, &block)
+        end
+      end
+    END
+  end
+
+  def removeDelegatingMethod(object, method)
+    if hasMethod(object, aliasMethodName(method))
+      # there is an aliased original, restore it
+      object.instance_eval <<-END
+        class << self
+          alias #{method} #{aliasMethodName(method)}
+          remove_method(:#{aliasMethodName(method)})
+        end
+      END
+    else
+      # just delete the delegating method
+      object.instance_eval <<-END
+        class << self
+          remove_method(:#{method})
+        end
+      END
+    end
+  end
+  
+  def hasMethod(object, method)
+    # in Ruby 1.9, #methods returns symbols
+    if object.methods.first.is_a?(Symbol)
+      method = method.to_sym
+    else
+      method = method.to_s
+    end
+    object.methods.include?(method)
+  end
+
+  def aliasMethodName(method)
+    "#{method}_delegate_original"
+  end    
+end
+
+end
+
+end
+
+end
+