puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/node/environment.rb

@@ -0,0 +1,216 @@
+require 'puppet/util'
+require 'puppet/util/cacher'
+require 'monitor'
+
+# Just define it, so this class has fewer load dependencies.
+class Puppet::Node
+end
+
+# Model the environment that a node can operate in.  This class just
+# provides a simple wrapper for the functionality around environments.
+class Puppet::Node::Environment
+  module Helper
+    def environment
+      Puppet::Node::Environment.new(@environment)
+    end
+
+    def environment=(env)
+      if env.is_a?(String) or env.is_a?(Symbol)
+        @environment = env
+      else
+        @environment = env.name
+      end
+    end
+  end
+
+  include Puppet::Util::Cacher
+
+  @seen = {}
+
+  # Return an existing environment instance, or create a new one.
+  def self.new(name = nil)
+    return name if name.is_a?(self)
+    name ||= Puppet.settings.value(:environment)
+
+    raise ArgumentError, "Environment name must be specified" unless name
+
+    symbol = name.to_sym
+
+    return @seen[symbol] if @seen[symbol]
+
+    obj = self.allocate
+    obj.send :initialize, symbol
+    @seen[symbol] = obj
+  end
+
+  def self.current
+    Thread.current[:environment] || root
+  end
+
+  def self.current=(env)
+    Thread.current[:environment] = new(env)
+  end
+
+  def self.root
+    @root
+  end
+
+  def self.clear
+    @seen.clear
+    Thread.current[:environment] = nil
+  end
+
+  attr_reader :name
+
+  # Return an environment-specific setting.
+  def [](param)
+    Puppet.settings.value(param, self.name)
+  end
+
+  def initialize(name)
+    @name = name
+    extend MonitorMixin
+  end
+
+  def known_resource_types
+    # This makes use of short circuit evaluation to get the right thread-safe
+    # per environment semantics with an efficient most common cases; we almost
+    # always just return our thread's known-resource types.  Only at the start
+    # of a compilation (after our thread var has been set to nil) or when the
+    # environment has changed do we delve deeper.
+    Thread.current[:known_resource_types] = nil if (krt = Thread.current[:known_resource_types]) && krt.environment != self
+    Thread.current[:known_resource_types] ||= synchronize {
+      if @known_resource_types.nil? or @known_resource_types.require_reparse?
+        @known_resource_types = Puppet::Resource::TypeCollection.new(self)
+        @known_resource_types.import_ast(perform_initial_import, '')
+      end
+      @known_resource_types
+    }
+  end
+
+  def module(name)
+    modules.find {|mod| mod.name == name}
+  end
+
+  def module_by_forge_name(forge_name)
+    author, modname = forge_name.split('/')
+    found_mod = self.module(modname)
+    found_mod and found_mod.forge_name == forge_name ?
+      found_mod :
+      nil
+  end
+
+  # Cache the modulepath, so that we aren't searching through
+  # all known directories all the time.
+  cached_attr(:modulepath, Puppet[:filetimeout]) do
+    dirs = self[:modulepath].split(File::PATH_SEPARATOR)
+    dirs = ENV["PUPPETLIB"].split(File::PATH_SEPARATOR) + dirs if ENV["PUPPETLIB"]
+    validate_dirs(dirs)
+  end
+
+  # Return all modules from this environment.
+  # Cache the list, because it can be expensive to create.
+  cached_attr(:modules, Puppet[:filetimeout]) do
+    module_names = modulepath.collect { |path| Dir.entries(path) }.flatten.uniq
+    module_names.collect do |path|
+      begin
+        Puppet::Module.new(path, :environment => self)
+      rescue Puppet::Module::Error => e
+        nil
+      end
+    end.compact
+  end
+
+  # Modules broken out by directory in the modulepath
+  def modules_by_path
+    modules_by_path = {}
+    modulepath.each do |path|
+      Dir.chdir(path) do
+        module_names = Dir.glob('*').select do |d|
+          FileTest.directory?(d) && (File.basename(d) =~ /^[\w]+([-]{1}[\w]+)*$/)
+        end
+        modules_by_path[path] = module_names.sort.map do |name|
+          Puppet::Module.new(name, :environment => self, :path => File.join(path, name))
+        end
+      end
+    end
+    modules_by_path
+  end
+
+  def module_requirements
+    deps = {}
+    modules.each do |mod|
+      next unless mod.forge_name
+      deps[mod.forge_name] ||= []
+      mod.dependencies and mod.dependencies.each do |mod_dep|
+        deps[mod_dep['name']] ||= []
+        dep_details = {
+          'name'                => mod.forge_name,
+          'version'             => mod.version,
+          'version_requirement' => mod_dep['version_requirement']
+        }
+        deps[mod_dep['name']] << dep_details
+      end
+    end
+    deps.each do |mod, mod_deps|
+      deps[mod] = mod_deps.sort_by {|d| d['name']}
+    end
+    deps
+  end
+
+  def to_s
+    name.to_s
+  end
+
+  def to_sym
+    to_s.to_sym
+  end
+
+  # The only thing we care about when serializing an environment is its
+  # identity; everything else is ephemeral and should not be stored or
+  # transmitted.
+  def to_zaml(z)
+    self.to_s.to_zaml(z)
+  end
+
+  def validate_dirs(dirs)
+    dirs.collect do |dir|
+      unless Puppet::Util.absolute_path?(dir)
+        File.expand_path(File.join(Dir.getwd, dir))
+      else
+        dir
+      end
+    end.find_all do |p|
+      Puppet::Util.absolute_path?(p) && FileTest.directory?(p)
+    end
+  end
+
+  private
+
+  def perform_initial_import
+    return empty_parse_result if Puppet.settings[:ignoreimport]
+    parser = Puppet::Parser::Parser.new(self)
+    if code = Puppet.settings.uninterpolated_value(:code, name.to_s) and code != ""
+      parser.string = code
+    else
+      file = Puppet.settings.value(:manifest, name.to_s)
+      parser.file = file
+    end
+    parser.parse
+  rescue => detail
+    known_resource_types.parse_failed = true
+
+    msg = "Could not parse for environment #{self}: #{detail}"
+    error = Puppet::Error.new(msg)
+    error.set_backtrace(detail.backtrace)
+    raise error
+  end
+
+  def empty_parse_result
+    # Return an empty toplevel hostclass to use as the result of
+    # perform_initial_import when no file was actually loaded.
+    return Puppet::Parser::AST::Hostclass.new('')
+  end
+
+  @root = new(:'*root*')
+end

data/lib/vendor/puppet/node/facts.rb

@@ -0,0 +1,99 @@
+require 'time'
+
+require 'puppet/node'
+require 'puppet/indirector'
+
+require 'puppet/util/pson'
+
+# Manage a given node's facts.  This either accepts facts and stores them, or
+# returns facts for a given node.
+class Puppet::Node::Facts
+  # Set up indirection, so that nodes can be looked for in
+  # the node sources.
+  extend Puppet::Indirector
+  extend Puppet::Util::Pson
+
+  # We want to expire any cached nodes if the facts are saved.
+  module NodeExpirer
+    def save(instance, key = nil)
+      Puppet::Node.indirection.expire(instance.name)
+      super
+    end
+  end
+
+  indirects :facts, :terminus_setting => :facts_terminus, :extend => NodeExpirer
+
+  attr_accessor :name, :values
+
+  def add_local_facts
+    values["clientcert"] = Puppet.settings[:certname]
+    values["clientversion"] = Puppet.version.to_s
+    values["environment"] ||= Puppet.settings[:environment]
+  end
+
+  def initialize(name, values = {})
+    @name = name
+    @values = values
+
+    add_timestamp
+  end
+
+  def downcase_if_necessary
+    return unless Puppet.settings[:downcasefacts]
+
+    Puppet.warning "DEPRECATION NOTICE: Fact downcasing is deprecated; please disable (20080122)"
+    values.each do |fact, value|
+      values[fact] = value.downcase if value.is_a?(String)
+    end
+  end
+
+  # Convert all fact values into strings.
+  def stringify
+    values.each do |fact, value|
+      values[fact] = value.to_s
+    end
+  end
+
+  def ==(other)
+    return false unless self.name == other.name
+    strip_internal == other.send(:strip_internal)
+  end
+
+  def self.from_pson(data)
+    result = new(data['name'], data['values'])
+    result.timestamp = Time.parse(data['timestamp'])
+    result.expiration = Time.parse(data['expiration'])
+    result
+  end
+
+  def to_pson(*args)
+    {
+      'expiration' => expiration,
+      'name' => name,
+      'timestamp' => timestamp,
+      'values' => strip_internal,
+    }.to_pson(*args)
+  end
+
+  # Add internal data to the facts for storage.
+  def add_timestamp
+    self.timestamp = Time.now
+  end
+
+  def timestamp=(time)
+    self.values[:_timestamp] = time
+  end
+
+  def timestamp
+    self.values[:_timestamp]
+  end
+
+  private
+
+  # Strip out that internal data.
+  def strip_internal
+    newvals = values.dup
+    newvals.find_all { |name, value| name.to_s =~ /^_/ }.each { |name, value| newvals.delete(name) }
+    newvals
+  end
+end

data/lib/vendor/puppet/node/inventory.rb

@@ -0,0 +1,7 @@
+require 'puppet/node'
+require 'puppet/indirector'
+
+class Puppet::Node::Inventory
+  extend Puppet::Indirector
+  indirects :inventory, :terminus_setting => :inventory_terminus
+end

data/lib/vendor/puppet/node.rb

@@ -0,0 +1,120 @@
+require 'puppet/indirector'
+
+# A class for managing nodes, including their facts and environment.
+class Puppet::Node
+  require 'puppet/node/facts'
+  require 'puppet/node/inventory'
+  require 'puppet/node/environment'
+
+  # Set up indirection, so that nodes can be looked for in
+  # the node sources.
+  extend Puppet::Indirector
+
+  # Adds the environment getter and setter, with some instance/string conversion
+  include Puppet::Node::Environment::Helper
+
+  # Use the node source as the indirection terminus.
+  indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
+    A node is composed of its name, its facts, and its environment."
+
+  attr_accessor :name, :classes, :source, :ipaddress, :parameters
+  attr_reader :time
+
+  def environment
+    return super if @environment
+
+    if env = parameters["environment"]
+      self.environment = env
+      return super
+    end
+
+    # Else, return the default
+    Puppet::Node::Environment.new
+  end
+
+  def initialize(name, options = {})
+    raise ArgumentError, "Node names cannot be nil" unless name
+    @name = name
+
+    if classes = options[:classes]
+      if classes.is_a?(String)
+        @classes = [classes]
+      else
+        @classes = classes
+      end
+    else
+      @classes = []
+    end
+
+    @parameters = options[:parameters] || {}
+
+    if env = options[:environment]
+      self.environment = env
+    end
+
+    @time = Time.now
+  end
+
+  # Merge the node facts with parameters from the node source.
+  def fact_merge
+      if facts = Puppet::Node::Facts.indirection.find(name)
+        merge(facts.values)
+      end
+  rescue => detail
+      error = Puppet::Error.new("Could not retrieve facts for #{name}: #{detail}")
+      error.set_backtrace(detail.backtrace)
+      raise error
+  end
+
+  # Merge any random parameters into our parameter list.
+  def merge(params)
+    params.each do |name, value|
+      @parameters[name] = value unless @parameters.include?(name)
+    end
+
+    @parameters["environment"] ||= self.environment.name.to_s if self.environment
+  end
+
+  # Calculate the list of names we might use for looking
+  # up our node.  This is only used for AST nodes.
+  def names
+    return [name] if Puppet.settings[:strict_hostname_checking]
+
+    names = []
+
+    names += split_name(name) if name.include?(".")
+
+    # First, get the fqdn
+    unless fqdn = parameters["fqdn"]
+      if parameters["hostname"] and parameters["domain"]
+        fqdn = parameters["hostname"] + "." + parameters["domain"]
+      else
+        Puppet.warning "Host is missing hostname and/or domain: #{name}"
+      end
+    end
+
+    # Now that we (might) have the fqdn, add each piece to the name
+    # list to search, in order of longest to shortest.
+    names += split_name(fqdn) if fqdn
+
+    # And make sure the node name is first, since that's the most
+    # likely usage.
+    #   The name is usually the Certificate CN, but it can be
+    # set to the 'facter' hostname instead.
+    if Puppet[:node_name] == 'cert'
+      names.unshift name
+    else
+      names.unshift parameters["hostname"]
+    end
+    names.uniq
+  end
+
+  def split_name(name)
+    list = name.split(".")
+    tmp = []
+    list.each_with_index do |short, i|
+      tmp << list[0..i].join(".")
+    end
+    tmp.reverse
+  end
+end

data/lib/vendor/puppet/parameter/path.rb

@@ -0,0 +1,34 @@
+require 'puppet/parameter'
+
+class Puppet::Parameter::Path < Puppet::Parameter
+  def self.accept_arrays(bool = true)
+    @accept_arrays = !!bool
+  end
+  def self.arrays?
+    @accept_arrays
+  end
+
+  def validate_path(paths)
+    if paths.is_a?(Array) and ! self.class.arrays? then
+      fail "#{name} only accepts a single path, not an array of paths"
+    end
+
+    fail("#{name} must be a fully qualified path") unless Array(paths).all? {|path| absolute_path?(path)}
+
+    paths
+  end
+
+  # This will be overridden if someone uses the validate option, which is why
+  # it just delegates to the other, useful, method.
+  def unsafe_validate(paths)
+    validate_path(paths)
+  end
+
+  # Likewise, this might be overridden, but by default...
+  def unsafe_munge(paths)
+    if paths.is_a?(Array) and ! self.class.arrays? then
+      fail "#{name} only accepts a single path, not an array of paths"
+    end
+    paths
+  end
+end

data/lib/vendor/puppet/parameter/value.rb

@@ -0,0 +1,69 @@
+require 'puppet/parameter/value_collection'
+
+# An individual Value class.
+class Puppet::Parameter::Value
+  attr_reader :name, :options, :event
+  attr_accessor :block, :call, :method, :required_features
+
+  # Add an alias for this value.
+  def alias(name)
+    @aliases << convert(name)
+  end
+
+  # Return all aliases.
+  def aliases
+    @aliases.dup
+  end
+
+  # Store the event that our value generates, if it does so.
+  def event=(value)
+    @event = convert(value)
+  end
+
+  def initialize(name)
+    if name.is_a?(Regexp)
+      @name = name
+    else
+      # Convert to a string and then a symbol, so things like true/false
+      # still show up as symbols.
+      @name = convert(name)
+    end
+
+    @aliases = []
+
+    @call = :instead
+  end
+
+  # Does a provided value match our value?
+  def match?(value)
+    if regex?
+      return true if name =~ value.to_s
+    else
+      return(name == convert(value) ? true : @aliases.include?(convert(value)))
+    end
+  end
+
+  # Is our value a regex?
+  def regex?
+    @name.is_a?(Regexp)
+  end
+
+  private
+
+  # A standard way of converting all of our values, so we're always
+  # comparing apples to apples.
+  def convert(value)
+    case value
+    when Symbol, ''             # can't intern an empty string
+      value
+    when String
+      value.intern
+    when true
+      :true
+    when false
+      :false
+    else
+      value.to_s.intern
+    end
+  end
+end

data/lib/vendor/puppet/parameter/value_collection.rb

@@ -0,0 +1,143 @@
+require 'puppet/parameter/value'
+
+# A collection of values and regexes, used for specifying
+# what values are allowed in a given parameter.
+class Puppet::Parameter::ValueCollection
+
+  def aliasvalue(name, other)
+    other = other.to_sym
+    unless value = match?(other)
+      raise Puppet::DevError, "Cannot alias nonexistent value #{other}"
+    end
+
+    value.alias(name)
+  end
+
+  # Return a doc string for all of the values in this parameter/property.
+  def doc
+    unless defined?(@doc)
+      @doc = ""
+      unless values.empty?
+        @doc += "  Valid values are "
+        @doc += @strings.collect do |value|
+          if aliases = value.aliases and ! aliases.empty?
+            "`#{value.name}` (also called `#{aliases.join(", ")}`)"
+          else
+            "`#{value.name}`"
+          end
+        end.join(", ") + "."
+      end
+
+      @doc += "  Values can match `" + regexes.join("`, `") + "`." unless regexes.empty?
+    end
+
+    @doc
+  end
+
+  # Does this collection contain any value definitions?
+  def empty?
+    @values.empty?
+  end
+
+  def initialize
+    # We often look values up by name, so a hash makes more sense.
+    @values = {}
+
+    # However, we want to retain the ability to match values in order,
+    # but we always prefer directly equality (i.e., strings) over regex matches.
+    @regexes = []
+    @strings = []
+  end
+
+  # Can we match a given value?
+  def match?(test_value)
+    # First look for normal values
+    if value = @strings.find { |v| v.match?(test_value) }
+      return value
+    end
+
+    # Then look for a regex match
+    @regexes.find { |v| v.match?(test_value) }
+  end
+
+  # If the specified value is allowed, then munge appropriately.
+  def munge(value)
+    return value if empty?
+
+    if instance = match?(value)
+      if instance.regex?
+        return value
+      else
+        return instance.name
+      end
+    else
+      return value
+    end
+  end
+
+  # Define a new valid value for a property.  You must provide the value itself,
+  # usually as a symbol, or a regex to match the value.
+  #
+  # The first argument to the method is either the value itself or a regex.
+  # The second argument is an option hash; valid options are:
+  # * <tt>:event</tt>: The event that should be returned when this value is set.
+  # * <tt>:call</tt>: When to call any associated block.  The default value
+  #   is ``instead``, which means to call the value instead of calling the
+  #   provider.  You can also specify ``before`` or ``after``, which will
+  #   call both the block and the provider, according to the order you specify
+  #   (the ``first`` refers to when the block is called, not the provider).
+  def newvalue(name, options = {}, &block)
+    value = Puppet::Parameter::Value.new(name)
+    @values[value.name] = value
+    if value.regex?
+      @regexes << value
+    else
+      @strings << value
+    end
+
+    options.each { |opt, arg| value.send(opt.to_s + "=", arg) }
+    if block_given?
+      value.block = block
+    else
+      value.call = options[:call] || :none
+    end
+
+    value.method ||= "set_#{value.name}" if block_given? and ! value.regex?
+
+    value
+  end
+
+  # Define one or more new values for our parameter.
+  def newvalues(*names)
+    names.each { |name| newvalue(name) }
+  end
+
+  def regexes
+    @regexes.collect { |r| r.name.inspect }
+  end
+
+  # Verify that the passed value is valid.
+  def validate(value)
+    return if empty?
+
+    unless @values.detect { |name, v| v.match?(value) }
+      str = "Invalid value #{value.inspect}. "
+
+      str += "Valid values are #{values.join(", ")}. " unless values.empty?
+
+      str += "Valid values match #{regexes.join(", ")}." unless regexes.empty?
+
+      raise ArgumentError, str
+    end
+  end
+
+  # Return a single value instance.
+  def value(name)
+    @values[name]
+  end
+
+  # Return the list of valid values.
+  def values
+    @strings.collect { |s| s.name }
+  end
+end