puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/parser/type_loader.rb

@@ -0,0 +1,172 @@
+require 'find'
+require 'puppet/node/environment'
+
+class Puppet::Parser::TypeLoader
+  include Puppet::Node::Environment::Helper
+
+  # Helper class that makes sure we don't try to import the same file
+  # more than once from either the same thread or different threads.
+  class Helper
+    include MonitorMixin
+    def initialize
+      super
+      # These hashes are indexed by filename
+      @state = {} # :doing or :done
+      @thread = {} # if :doing, thread that's doing the parsing
+      @cond_var = {} # if :doing, condition var that will be signaled when done.
+    end
+
+    # Execute the supplied block exactly once per file, no matter how
+    # many threads have asked for it to run.  If another thread is
+    # already executing it, wait for it to finish.  If this thread is
+    # already executing it, return immediately without executing the
+    # block.
+    #
+    # Note: the reason for returning immediately if this thread is
+    # already executing the block is to handle the case of a circular
+    # import--when this happens, we attempt to recursively re-parse a
+    # file that we are already in the process of parsing.  To prevent
+    # an infinite regress we need to simply do nothing when the
+    # recursive import is attempted.
+    def do_once(file)
+      need_to_execute = synchronize do
+        case @state[file]
+        when :doing
+          if @thread[file] != Thread.current
+            @cond_var[file].wait
+          end
+          false
+        when :done
+          false
+        else
+          @state[file] = :doing
+          @thread[file] = Thread.current
+          @cond_var[file] = new_cond
+          true
+        end
+      end
+      if need_to_execute
+        begin
+          yield
+        ensure
+          synchronize do
+            @state[file] = :done
+            @thread.delete(file)
+            @cond_var.delete(file).broadcast
+          end
+        end
+      end
+    end
+  end
+
+  # Import our files.
+  def import(file, current_file = nil)
+    return if Puppet[:ignoreimport]
+
+    # use a path relative to the file doing the importing
+    if current_file
+      dir = current_file.sub(%r{[^/]+$},'').sub(/\/$/, '')
+    else
+      dir = "."
+    end
+    if dir == ""
+      dir = "."
+    end
+
+    pat = file
+    modname, files = Puppet::Parser::Files.find_manifests(pat, :cwd => dir, :environment => environment)
+    if files.size == 0
+      raise Puppet::ImportError.new("No file(s) found for import of '#{pat}'")
+    end
+
+    loaded_asts = []
+    files.each do |file|
+      unless Puppet::Util.absolute_path?(file)
+        file = File.join(dir, file)
+      end
+      @loading_helper.do_once(file) do
+        loaded_asts << parse_file(file)
+      end
+    end
+    loaded_asts.inject([]) do |loaded_types, ast|
+      loaded_types + known_resource_types.import_ast(ast, modname)
+    end
+  end
+
+  def import_all
+    module_names = []
+    # Collect the list of all known modules
+    environment.modulepath.each do |path|
+      Dir.chdir(path) do
+        Dir.glob("*").each do |dir|
+          next unless FileTest.directory?(dir)
+          module_names << dir
+        end
+      end
+    end
+
+    module_names.uniq!
+    # And then load all files from each module, but (relying on system
+    # behavior) only load files from the first module of a given name.  E.g.,
+    # given first/foo and second/foo, only files from first/foo will be loaded.
+    module_names.each do |name|
+      mod = Puppet::Module.new(name, :environment => environment)
+      Find.find(File.join(mod.path, "manifests")) do |path|
+        if path =~ /\.pp$/ or path =~ /\.rb$/
+          import(path)
+        end
+      end
+    end
+  end
+
+  def known_resource_types
+    environment.known_resource_types
+  end
+
+  def initialize(env)
+    self.environment = env
+    @loading_helper = Helper.new
+  end
+
+  # Try to load the object with the given fully qualified name.
+  def try_load_fqname(type, fqname)
+    return nil if fqname == "" # special-case main.
+    name2files(fqname).each do |filename|
+      begin
+        imported_types = import(filename)
+        if result = imported_types.find { |t| t.type == type and t.name == fqname }
+          Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
+          return result
+        end
+      rescue Puppet::ImportError => detail
+        # We couldn't load the item
+        # I'm not convienced we should just drop these errors, but this
+        # preserves existing behaviours.
+      end
+    end
+    # Nothing found.
+    return nil
+  end
+
+  def parse_file(file)
+    Puppet.debug("importing '#{file}' in environment #{environment}")
+    parser = Puppet::Parser::Parser.new(environment)
+    parser.file = file
+    return parser.parse
+  end
+
+  private
+
+  # Return a list of all file basenames that should be tried in order
+  # to load the object with the given fully qualified name.
+  def name2files(fqname)
+    result = []
+    ary = fqname.split("::")
+    while ary.length > 0
+      result << ary.join(File::SEPARATOR)
+      ary.pop
+    end
+    return result
+  end
+
+end

data/lib/vendor/puppet/parser/yaml_trimmer.rb

@@ -0,0 +1,9 @@
+module Puppet::Parser::YamlTrimmer
+  REMOVE = %w{@scope @source}
+
+  def to_yaml_properties
+    r = instance_variables - REMOVE
+    r -= skip_for_yaml if respond_to?(:skip_for_yaml)
+    r
+  end
+end

data/lib/vendor/puppet/parser.rb

@@ -0,0 +1,4 @@
+require 'puppet/parser/parser'
+require 'puppet/parser/compiler'
+require 'puppet/resource/type_collection'
+

data/lib/vendor/puppet/property/ensure.rb

@@ -0,0 +1,92 @@
+require 'puppet/property'
+
+# This property will get automatically added to any type that responds
+# to the methods 'exists?', 'create', and 'destroy'.
+class Puppet::Property::Ensure < Puppet::Property
+  @name = :ensure
+
+  def self.defaultvalues
+    newvalue(:present) do
+      if @resource.provider and @resource.provider.respond_to?(:create)
+        @resource.provider.create
+      else
+        @resource.create
+      end
+      nil # return nil so the event is autogenerated
+    end
+
+    newvalue(:absent) do
+      if @resource.provider and @resource.provider.respond_to?(:destroy)
+        @resource.provider.destroy
+      else
+        @resource.destroy
+      end
+      nil # return nil so the event is autogenerated
+    end
+
+    defaultto do
+      if @resource.managed?
+        :present
+      else
+        nil
+      end
+    end
+
+    # This doc will probably get overridden
+    @doc ||= "The basic property that the resource should be in."
+  end
+
+  def self.inherited(sub)
+    # Add in the two properties that everyone will have.
+    sub.class_eval do
+    end
+  end
+
+  def change_to_s(currentvalue, newvalue)
+    begin
+      if currentvalue == :absent or currentvalue.nil?
+        return "created"
+      elsif newvalue == :absent
+        return "removed"
+      else
+        return "#{self.name} changed '#{self.is_to_s(currentvalue)}' to '#{self.should_to_s(newvalue)}'"
+      end
+    rescue Puppet::Error, Puppet::DevError
+      raise
+    rescue => detail
+      raise Puppet::DevError, "Could not convert change #{self.name} to string: #{detail}"
+    end
+  end
+
+  def retrieve
+    # XXX This is a problem -- whether the object exists or not often
+    # depends on the results of other properties, yet we're the first property
+    # to get checked, which means that those other properties do not have
+    # @is values set.  This seems to be the source of quite a few bugs,
+    # although they're mostly logging bugs, not functional ones.
+    if prov = @resource.provider and prov.respond_to?(:exists?)
+      result = prov.exists?
+    elsif @resource.respond_to?(:exists?)
+      result = @resource.exists?
+    else
+      raise Puppet::DevError, "No ability to determine if #{@resource.class.name} exists"
+    end
+    if result
+      return :present
+    else
+      return :absent
+    end
+  end
+
+  # If they're talking about the thing at all, they generally want to
+  # say it should exist.
+  #defaultto :present
+  defaultto do
+    if @resource.managed?
+      :present
+    else
+      nil
+    end
+  end
+end
+

data/lib/vendor/puppet/property/keyvalue.rb

@@ -0,0 +1,86 @@
+#This subclass of property manages string key value pairs.
+
+#In order to use this property:
+# - the @should value must be an array of keyvalue pairs separated by the 'separator'
+# - the retrieve method should return a hash with the keys as symbols
+# IMPORTANT NOTE: In order for this property to work there must also be a 'membership' parameter
+# The class that inherits from property should override that method with the symbol for the membership
+
+require 'puppet/property'
+
+module Puppet
+  class Property
+    class KeyValue < Property
+
+      def hash_to_key_value_s(hash)
+        hash.select { |k,v| true }.map { |pair| pair.join(separator) }.join(delimiter)
+      end
+
+      def should_to_s(should_value)
+        hash_to_key_value_s(should_value)
+      end
+
+      def is_to_s(current_value)
+        hash_to_key_value_s(current_value)
+      end
+
+      def membership
+        :key_value_membership
+      end
+
+      def inclusive?
+        @resource[membership] == :inclusive
+      end
+
+      def hashify(key_value_array)
+        #turns string array into a hash
+        key_value_array.inject({}) do |hash, key_value|
+          tmp = key_value.split(separator)
+          hash[tmp[0].intern] = tmp[1]
+          hash
+        end
+      end
+
+      def process_current_hash(current)
+        return {} if current == :absent
+
+        #inclusive means we are managing everything so if it isn't in should, its gone
+        current.each_key { |key| current[key] = nil } if inclusive?
+        current
+      end
+
+      def should
+        return nil unless @should
+
+        members = hashify(@should)
+        current = process_current_hash(retrieve)
+
+        #shared keys will get overwritten by members
+        current.merge(members)
+      end
+
+      def separator
+        "="
+      end
+
+      def delimiter
+        ";"
+      end
+
+      def retrieve
+        #ok, some 'convention' if the keyvalue property is named properties, provider should implement a properties method
+        if key_hash = provider.send(name) and key_hash != :absent
+          return key_hash
+        else
+          return :absent
+        end
+      end
+
+      def insync?(is)
+        return true unless is
+
+        (is == self.should)
+      end
+    end
+  end
+end

data/lib/vendor/puppet/property/list.rb

@@ -0,0 +1,75 @@
+require 'puppet/property'
+
+module Puppet
+  class Property
+    class List < Property
+
+      def should_to_s(should_value)
+        #just return the should value
+        should_value
+      end
+
+      def is_to_s(currentvalue)
+        if currentvalue == :absent
+          return "absent"
+        else
+          return currentvalue.join(delimiter)
+        end
+      end
+
+      def membership
+        :membership
+      end
+
+      def add_should_with_current(should, current)
+        should += current if current.is_a?(Array)
+        should.uniq
+      end
+
+      def inclusive?
+        @resource[membership] == :inclusive
+      end
+
+      #dearrayify was motivated because to simplify the implementation of the OrderedList property
+      def dearrayify(array)
+        array.sort.join(delimiter)
+      end
+
+      def should
+        return nil unless @should
+
+        members = @should
+        #inclusive means we are managing everything so if it isn't in should, its gone
+        members = add_should_with_current(members, retrieve) if ! inclusive?
+
+        dearrayify(members)
+      end
+
+      def delimiter
+        ","
+      end
+
+      def retrieve
+        #ok, some 'convention' if the list property is named groups, provider should implement a groups method
+        if tmp = provider.send(name) and tmp != :absent
+          return tmp.split(delimiter)
+        else
+          return :absent
+        end
+      end
+
+      def prepare_is_for_comparison(is)
+        if is == :absent
+          is = []
+        end
+        dearrayify(is)
+      end
+
+      def insync?(is)
+        return true unless is
+
+        (prepare_is_for_comparison(is) == self.should)
+      end
+    end
+  end
+end

data/lib/vendor/puppet/property/ordered_list.rb

@@ -0,0 +1,22 @@
+require 'puppet/property/list'
+
+module Puppet
+  class Property
+    class OrderedList < List
+
+      def add_should_with_current(should, current)
+        if current.is_a?(Array)
+          #tricky trick
+          #Preserve all the current items in the list
+          #but move them to the back of the line
+          should = should + (current - should)
+        end
+        should
+      end
+
+      def dearrayify(array)
+        array.join(delimiter)
+      end
+    end
+  end
+end