puppet 3.8.7-x86-mingw32 → 4.0.0.rc1-x86-mingw32

data/lib/puppet/parser/ast/resource_defaults.rb

@@ -1,24 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  # A statement syntactically similar to an ResourceDef, but uses a
-  # capitalized object type and cannot have a name.
-  class ResourceDefaults < AST::Branch
-    attr_accessor :type, :parameters
-
-    associates_doc
-
-    # As opposed to ResourceDef, this stores each default for the given
-    # object type.
-    def evaluate(scope)
-      # Use a resource reference to canonize the type
-      ref = Puppet::Resource.new(@type, "whatever")
-      type = ref.type
-      params = @parameters.safeevaluate(scope)
-
-      parsewrap do
-        scope.define_settings(type, params)
-      end
-    end
-  end
-end

data/lib/puppet/parser/ast/resource_override.rb

@@ -1,62 +0,0 @@
-require 'puppet/parser/ast/resource'
-
-class Puppet::Parser::AST
-  # Set a parameter on a resource specification created somewhere else in the
-  # configuration.  The object is responsible for verifying that this is allowed.
-  class ResourceOverride < AST::Branch
-
-    associates_doc
-
-    attr_accessor :object, :parameters
-
-    # Iterate across all of our children.
-    def each
-      [@object,@parameters].flatten.each { |param|
-        #Puppet.debug("yielding param #{param}")
-        yield param
-      }
-    end
-
-    # Does not actually return an object; instead sets an object
-    # in the current scope.
-    def evaluate(scope)
-      # Get our object reference.
-      resource = @object.safeevaluate(scope)
-
-      # Evaluate all of the specified params.
-      params = @parameters.collect { |param|
-        param.safeevaluate(scope)
-      }
-
-      # Now we just create a normal resource, but we call a very different
-      # method on the scope.
-      resource = [resource] unless resource.is_a?(Array)
-
-      resource = resource.collect do |r|
-
-        res = Puppet::Parser::Resource.new(
-        r.type, r.title,
-          :parameters => params,
-          :file => file,
-          :line => line,
-          :source => scope.source,
-          :scope => scope
-        )
-
-        # Now we tell the scope that it's an override, and it behaves as
-        # necessary.
-        scope.compiler.add_override(res)
-
-        res
-      end
-      # decapsulate array in case of only one item
-      return(resource.length == 1 ? resource.pop : resource)
-    end
-
-    # Create our ResourceDef.  Handles type checking for us.
-    def initialize(hash)
-      @checked = false
-      super
-    end
-  end
-end

data/lib/puppet/parser/ast/resource_reference.rb

@@ -1,28 +0,0 @@
-require 'puppet/parser/ast'
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST::ResourceReference < Puppet::Parser::AST::Branch
-  attr_accessor :title, :type
-
-  # Evaluate our object, but just return a simple array of the type
-  # and name.
-  def evaluate(scope)
-    titles = Array(title.safeevaluate(scope)).flatten
-
-    a_type, titles = scope.resolve_type_and_titles(type, titles)
-
-    resources = titles.collect{ |a_title|
-      Puppet::Resource.new(a_type, a_title)
-    }
-
-    return(resources.length == 1 ? resources.pop : resources)
-  end
-
-  def to_s
-    if title.is_a?(Puppet::Parser::AST::ASTArray)
-      "#{type.to_s.capitalize}#{title}"
-    else
-      "#{type.to_s.capitalize}[#{title}]"
-    end
-  end
-end

data/lib/puppet/parser/ast/selector.rb

@@ -1,50 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  # The inline conditional operator.  Unlike CaseStatement, which executes
-  # code, we just return a value.
-  class Selector < AST::Branch
-    attr_accessor :param, :values
-
-    def each
-      [@param,@values].each { |child| yield child }
-    end
-
-    # Find the value that corresponds with the test.
-    def evaluate(scope)
-      level = scope.ephemeral_level
-      # Get our parameter.
-      paramvalue = @param.safeevaluate(scope)
-
-      default = nil
-
-      @values = [@values] unless @values.instance_of? AST::ASTArray or @values.instance_of? Array
-
-      # Then look for a match in the options.
-      @values.each do |obj|
-        # short circuit asap if we have a match
-        return obj.value.safeevaluate(scope) if obj.param.evaluate_match(paramvalue, scope)
-
-        # Store the default, in case it's necessary.
-        default = obj if obj.param.is_a?(Default)
-      end
-
-      # Unless we found something, look for the default.
-      return default.value.safeevaluate(scope) if default
-
-      self.fail Puppet::ParseError, "No matching value for selector param '#{paramvalue}'"
-    ensure
-      scope.unset_ephemeral_var(level)
-    end
-
-    def to_s
-      if @values.instance_of? AST::ASTArray or @values.instance_of? Array
-        v = @values
-      else
-        v = [@values]
-      end
-
-      param.to_s + " ? { " + v.collect { |v| v.to_s }.join(', ') + " }"
-    end
-  end
-end

data/lib/puppet/parser/ast/vardef.rb

@@ -1,38 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  # Define a variable.  Stores the value in the current scope.
-  class VarDef < AST::Branch
-
-    associates_doc
-
-    attr_accessor :name, :value, :append
-
-    # Look up our name and value, and store them appropriately.  The
-    # lexer strips off the syntax stuff like '$'.
-    def evaluate(scope)
-      value = @value.safeevaluate(scope)
-      if name.is_a?(HashOrArrayAccess)
-        name.assign(scope, value)
-      else
-        name = @name.safeevaluate(scope)
-
-        parsewrap do
-          scope.setvar(name,value, :file => file, :line => line, :append => @append)
-        end
-      end
-      if @append
-        # Produce resulting value from append operation
-        scope[name]
-      else
-        # Produce assigned value
-        value
-      end
-    end
-
-    def each
-      [@name,@value].each { |child| yield child }
-    end
-  end
-
-end

data/lib/puppet/parser/code_merger.rb

@@ -1,13 +0,0 @@
-
-class Puppet::Parser::CodeMerger
-
-  # Concatenates the logic in the array of parse results into one parse result
-  # @return Puppet::Parser::AST::BlockExpression
-  #
-  def concatenate(parse_results)
-    children = parse_results.select {|x| !x.nil? && x.code}.reduce([]) do |memo, parsed_class|
-      memo + parsed_class.code.children
-    end
-    Puppet::Parser::AST::BlockExpression.new(:children => children)
-  end
-end

data/lib/puppet/parser/collector.rb

@@ -1,177 +0,0 @@
-# An object that collects stored objects from the central cache and returns
-# them to the current host, yo.
-class Puppet::Parser::Collector
-  attr_accessor :type, :scope, :vquery, :equery, :form
-  attr_accessor :resources, :overrides, :collected
-
-  # Call the collection method, mark all of the returned objects as
-  # non-virtual, optionally applying parameter overrides. The collector can
-  # also delete himself from the compiler if there is no more resources to
-  # collect (valid only for resource fixed-set collector which get their
-  # resources from +collect_resources+ and not from the catalog)
-  def evaluate
-    # Shortcut if we're not using storeconfigs and they're trying to collect
-    # exported resources.
-    if form == :exported and Puppet[:storeconfigs] != true
-      Puppet.warning "Not collecting exported resources without storeconfigs"
-      return false
-    end
-
-    if self.resources
-      unless objects = collect_resources and ! objects.empty?
-        return false
-      end
-    else
-      method = "collect_#{@form.to_s}"
-      objects = send(method).each do |obj|
-        obj.virtual = false
-      end
-      return false if objects.empty?
-    end
-
-    # we have an override for the collected resources
-    if @overrides and !objects.empty?
-      # force the resource to be always child of any other resource
-      overrides[:source].meta_def(:child_of?) do |klass|
-        true
-      end
-
-      # tell the compiler we have some override for him unless we already
-      # overrided those resources
-      objects.each do |res|
-        unless @collected.include?(res.ref)
-          newres = Puppet::Parser::Resource.
-            new(res.type, res.title,
-                :parameters => overrides[:parameters],
-                :file       => overrides[:file],
-                :line       => overrides[:line],
-                :source     => overrides[:source],
-                :scope      => overrides[:scope])
-
-          scope.compiler.add_override(newres)
-        end
-      end
-    end
-
-    # filter out object that this collector has previously found.
-    objects.reject! { |o| @collected.include?(o.ref) }
-
-    return false if objects.empty?
-
-    # keep an eye on the resources we have collected
-    objects.inject(@collected) { |c,o| c[o.ref]=o; c }
-
-    # return our newly collected resources
-    objects
-  end
-
-  def initialize(scope, type, equery, vquery, form)
-    @scope  = scope
-    @vquery = vquery
-    @equery = equery
-
-    # initialisation
-    @collected = {}
-
-    # Canonize the type
-    @type = Puppet::Resource.new(type, "whatever").type
-
-    unless [:exported, :virtual].include?(form)
-      raise ArgumentError, "Invalid query form #{form}"
-    end
-    @form = form
-  end
-
-  # add a resource override to the soon to be exported/realized resources
-  def add_override(hash)
-    raise ArgumentError, "Exported resource try to override without parameters" unless hash[:parameters]
-
-    # schedule an override for an upcoming collection
-    @overrides = hash
-  end
-
-  private
-
-  # Collect exported objects.
-  def collect_exported
-    resources = []
-
-    time = Puppet::Util.thinmark do
-      # First get everything from the export table.  Just reuse our
-      # collect_virtual method but tell it to use 'exported? for the test.
-      resources = collect_virtual(true).reject { |r| ! r.virtual? }
-
-      # key is '#{type}/#{name}', and host and filter.
-      found = Puppet::Resource.indirection.
-        search(@type, :host => @scope.compiler.node.name, :filter => @equery, :scope => @scope)
-
-      found_resources = found.map {|x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope)}
-
-      found_resources.each do |item|
-        if existing = @scope.findresource(item.type, item.title)
-          unless existing.collector_id == item.collector_id
-            # unless this is the one we've already collected
-            raise Puppet::ParseError,
-              "A duplicate resource was found while collecting exported resources, with the type and title #{item.ref}"
-          end
-        else
-          item.exported = false
-          @scope.compiler.add_resource(@scope, item)
-          resources << item
-        end
-      end
-    end
-
-    scope.debug("Collected %s %s resource%s in %.2f seconds" %
-                [resources.length, @type, resources.length == 1 ? "" : "s", time])
-
-    resources
-  end
-
-  def collect_resources
-    @resources = [@resources] unless @resources.is_a?(Array)
-    method = "collect_#{form.to_s}_resources"
-    send(method)
-  end
-
-  def collect_exported_resources
-    raise Puppet::ParseError, "realize() is not yet implemented for exported resources"
-  end
-
-  # Collect resources directly; this is the result of using 'realize',
-  # which specifies resources, rather than using a normal collection.
-  def collect_virtual_resources
-    return [] unless defined?(@resources) and ! @resources.empty?
-    result = @resources.dup.collect do |ref|
-      if res = @scope.findresource(ref.to_s)
-        @resources.delete(ref)
-        res
-      end
-    end.reject { |r| r.nil? }.each do |res|
-      res.virtual = false
-    end
-
-    # If there are no more resources to find, delete this from the list
-    # of collections.
-    @scope.compiler.delete_collection(self) if @resources.empty?
-
-    result
-  end
-
-  # Collect just virtual objects, from our local compiler.
-  def collect_virtual(exported = false)
-    scope.compiler.resources.find_all do |resource|
-      resource.type == @type and (exported ? resource.exported? : true) and match?(resource)
-    end
-  end
-
-  # Does the resource match our tests?  We don't yet support tests,
-  # so it's always true at the moment.
-  def match?(resource)
-    if self.vquery
-      return self.vquery.call(resource)
-    else
-      return true
-    end
-  end
-end

data/lib/puppet/parser/functions/extlookup.rb

@@ -1,153 +0,0 @@
-require 'csv'
-
-module Puppet::Parser::Functions
-  newfunction(:extlookup,
-  :type => :rvalue,
-  :arity => -2,
-  :doc => "This is a parser function to read data from external files, this version
-uses CSV files but the concept can easily be adjust for databases, yaml
-or any other queryable data source.
-
-The object of this is to make it obvious when it's being used, rather than
-magically loading data in when a module is loaded I prefer to look at the code
-and see statements like:
-
-    $snmp_contact = extlookup(\"snmp_contact\")
-
-The above snippet will load the snmp_contact value from CSV files, this in its
-own is useful but a common construct in puppet manifests is something like this:
-
-    case $domain {
-      \"myclient.com\": { $snmp_contact = \"John Doe <john@myclient.com>\" }
-      default:        { $snmp_contact = \"My Support <support@my.com>\" }
-    }
-
-Over time there will be a lot of this kind of thing spread all over your manifests
-and adding an additional client involves grepping through manifests to find all the
-places where you have constructs like this.
-
-This is a data problem and shouldn't be handled in code, and using this function you
-can do just that.
-
-First you configure it in site.pp:
-
-    $extlookup_datadir = \"/etc/puppet/manifests/extdata\"
-    $extlookup_precedence = [\"%{fqdn}\", \"domain_%{domain}\", \"common\"]
-
-The array tells the code how to resolve values, first it will try to find it in
-web1.myclient.com.csv then in domain_myclient.com.csv and finally in common.csv
-
-Now create the following data files in /etc/puppet/manifests/extdata:
-
-    domain_myclient.com.csv:
-      snmp_contact,John Doe <john@myclient.com>
-      root_contact,support@%{domain}
-      client_trusted_ips,192.168.1.130,192.168.10.0/24
-
-    common.csv:
-      snmp_contact,My Support <support@my.com>
-      root_contact,support@my.com
-
-Now you can replace the case statement with the simple single line to achieve
-the exact same outcome:
-
-    $snmp_contact = extlookup(\"snmp_contact\")
-
-The above code shows some other features, you can use any fact or variable that
-is in scope by simply using %{varname} in your data files, you can return arrays
-by just having multiple values in the csv after the initial variable name.
-
-In the event that a variable is nowhere to be found a critical error will be raised
-that will prevent your manifest from compiling, this is to avoid accidentally putting
-in empty values etc.  You can however specify a default value:
-
-    $ntp_servers = extlookup(\"ntp_servers\", \"1.${country}.pool.ntp.org\")
-
-In this case it will default to \"1.${country}.pool.ntp.org\" if nothing is defined in
-any data file.
-
-You can also specify an additional data file to search first before any others at use
-time, for example:
-
-    $version = extlookup(\"rsyslog_version\", \"present\", \"packages\")
-    package{\"rsyslog\": ensure => $version }
-
-This will look for a version configured in packages.csv and then in the rest as configured
-by $extlookup_precedence if it's not found anywhere it will default to `present`, this kind
-of use case makes puppet a lot nicer for managing large amounts of packages since you do not
-need to edit a load of manifests to do simple things like adjust a desired version number.
-
-Precedence values can have variables embedded in them in the form %{fqdn}, you could for example do:
-
-    $extlookup_precedence = [\"hosts/%{fqdn}\", \"common\"]
-
-This will result in /path/to/extdata/hosts/your.box.com.csv being searched.
-
-This is for back compatibility to interpolate variables with %. % interpolation is a workaround for a problem that has been fixed: Puppet variable interpolation at top scope used to only happen on each run.") do |args|
-
-  key = args[0]
-
-  default  = args[1]
-  datafile = args[2]
-
-  raise ArgumentError, ("extlookup(): wrong number of arguments (#{args.length}; must be <= 3)") if args.length > 3
-
-  extlookup_datadir = undef_as('',self['::extlookup_datadir'])
-
-  extlookup_precedence = undef_as([],self['::extlookup_precedence']).collect { |var| var.gsub(/%\{(.+?)\}/) { self["::#{$1}"] } }
-
-  datafiles = Array.new
-
-  # if we got a custom data file, put it first in the array of search files
-  if datafile != ""
-    datafiles << extlookup_datadir + "/#{datafile}.csv" if Puppet::FileSystem.exist?(extlookup_datadir + "/#{datafile}.csv")
-  end
-
-  extlookup_precedence.each do |d|
-    datafiles << extlookup_datadir + "/#{d}.csv"
-  end
-
-  desired = nil
-
-  datafiles.each do |file|
-    if desired.nil?
-      if Puppet::FileSystem.exist?(file)
-        result = CSV.read(file).find_all do |r|
-          r[0] == key
-        end
-
-        # return just the single result if theres just one,
-        # else take all the fields in the csv and build an array
-        if result.length > 0
-          if result[0].length == 2
-            val = result[0][1].to_s
-
-            # parse %{}'s in the CSV into local variables using the current scope
-            while val =~ /%\{(.+?)\}/
-              val.gsub!(/%\{#{$1}\}/, self[$1])
-            end
-
-            desired = val
-          elsif result[0].length > 1
-            length = result[0].length
-            cells = result[0][1,length]
-
-            # Individual cells in a CSV result are a weird data type and throws
-            # puppets yaml parsing, so just map it all to plain old strings
-            desired = cells.map do |c|
-              # parse %{}'s in the CSV into local variables using the current scope
-              while c =~ /%\{(.+?)\}/
-                c.gsub!(/%\{#{$1}\}/, self[$1])
-              end
-
-              c.to_s
-            end
-          end
-        end
-      end
-    end
-  end
-
-  desired || default or raise Puppet::ParseError, "No match found for '#{key}' in any data file during extlookup()"
-  end
-end