From 5db696b605ebb331d5af3e640e68978c4f6d604d Mon Sep 17 00:00:00 2001 From: Matt Robinson Date: Mon, 22 Nov 2010 14:56:49 -0800 Subject: maint: Fix tests that don't run on their own From the spec directory I found all the specs that fail when run on their own. for TEST in `find . -name "*.rb" -type f`; do spec $TEST > /dev/null 2>&1 if [[ $? != 0 ]]; then echo $TEST fi done All of them were cases of missing requires. Paired-with: Nick Lewis --- lib/puppet/parser/templatewrapper.rb | 1 + 1 file changed, 1 insertion(+) (limited to 'lib/puppet/parser') diff --git a/lib/puppet/parser/templatewrapper.rb b/lib/puppet/parser/templatewrapper.rb index 73a4ad8aa..6864aa1a9 100644 --- a/lib/puppet/parser/templatewrapper.rb +++ b/lib/puppet/parser/templatewrapper.rb @@ -1,6 +1,7 @@ # A simple wrapper for templates, so they don't have full access to # the scope objects. require 'puppet/parser/files' +require 'erb' class Puppet::Parser::TemplateWrapper attr_writer :scope -- cgit From 7661ba82a3c765d4bf8a400a3c770f351c541f96 Mon Sep 17 00:00:00 2001 From: Jesse Wolfe Date: Mon, 3 Jan 2011 16:28:24 -0800 Subject: maint: Prune #inspect methods on various objects Ruby's default #inspect method can lead to printing factorial-order output for large graphs of objects. Since we have large graphs of objects, this is not optimal. This patch replaces a few well-connected objects' #inspect methods with methods that produce reduced output, and are thus much faster. Paired-With: Nick Lewis --- lib/puppet/parser/ast.rb | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'lib/puppet/parser') diff --git a/lib/puppet/parser/ast.rb b/lib/puppet/parser/ast.rb index 54e034acb..a5aaeddc4 100644 --- a/lib/puppet/parser/ast.rb +++ b/lib/puppet/parser/ast.rb @@ -19,6 +19,10 @@ class Puppet::Parser::AST attr_accessor :parent, :scope + def inspect + "( #{self.class} #{self.to_s} #{@children.inspect} )" + end + # don't fetch lexer comment by default def use_docs self.class.use_docs -- cgit From a2036ea693996cb6ba5eb9f8f52fefa843a320a6 Mon Sep 17 00:00:00 2001 From: Dan Bode Date: Sat, 8 Jan 2011 17:34:19 -0600 Subject: (#5045) External node classifiers should be able to specify params for classes It facilitates the support for param classes from the ENC. It adds support for classes to be passed as a hash to the evaluate_classes method. If a hash of classes is specified, it also evaluates duplicates. I also had to convert the hash to an array for tags to be applied correctly. Reviewed-by: Matt Robinson --- lib/puppet/parser/compiler.rb | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) (limited to 'lib/puppet/parser') diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb index c60e1d4fb..3134e03d9 100644 --- a/lib/puppet/parser/compiler.rb +++ b/lib/puppet/parser/compiler.rb @@ -139,12 +139,23 @@ class Puppet::Parser::Compiler def evaluate_classes(classes, scope, lazy_evaluate = true) raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source found = [] + param_classes = nil + # if we are a param class, save the classes hash + # and transform classes to be the keys + if classes.class == Hash + param_classes = classes + classes = classes.keys + end classes.each do |name| # If we can find the class, then make a resource that will evaluate it. if klass = scope.find_hostclass(name) - found << name and next if scope.class_scope(klass) - resource = klass.ensure_in_catalog(scope) + if param_classes + resource = klass.ensure_in_catalog(scope, param_classes[name] || {}) + else + found << name and next if scope.class_scope(klass) and !param_classes + resource = klass.ensure_in_catalog(scope) + end # If they've disabled lazy evaluation (which the :include function does), # then evaluate our resource immediately. @@ -432,7 +443,11 @@ class Puppet::Parser::Compiler @resources = [] # Make sure any external node classes are in our class list - @catalog.add_class(*@node.classes) + if @node.classes.class == Hash + @catalog.add_class(*@node.classes.keys) + else + @catalog.add_class(*@node.classes) + end end # Set the node's parameters into the top-scope as variables. -- cgit From 3cfbd0722c5f64a3ef39a65f53fa4195135e90b4 Mon Sep 17 00:00:00 2001 From: Matt Robinson Date: Fri, 21 Jan 2011 14:07:32 -0800 Subject: (#5045) Cleaning up some tests and code Renamed some variables to be clearer, made tests use less stubbing, added some additional tests and got rid of some unecessary logic. Paired-with: Dan Bode --- lib/puppet/parser/compiler.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/puppet/parser') diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb index 3134e03d9..fdabd05c9 100644 --- a/lib/puppet/parser/compiler.rb +++ b/lib/puppet/parser/compiler.rb @@ -153,7 +153,7 @@ class Puppet::Parser::Compiler if param_classes resource = klass.ensure_in_catalog(scope, param_classes[name] || {}) else - found << name and next if scope.class_scope(klass) and !param_classes + found << name and next if scope.class_scope(klass) resource = klass.ensure_in_catalog(scope) end -- cgit From 5d108e8007b76ce62f13c99ed1caedcc0f69c37c Mon Sep 17 00:00:00 2001 From: nfagerlund Date: Fri, 21 Jan 2011 17:21:03 -0800 Subject: (#5944) Improve documentation of defined() function The differences in the way defined() handles different types of entities weren't well-explained. Documentation was also added for the behavior of defined(Node["somenode.domain.com"]). --- lib/puppet/parser/functions/defined.rb | 47 +++++++++++++++++++++++++++++----- 1 file changed, 41 insertions(+), 6 deletions(-) (limited to 'lib/puppet/parser') diff --git a/lib/puppet/parser/functions/defined.rb b/lib/puppet/parser/functions/defined.rb index 90632af2f..c3efc5f76 100644 --- a/lib/puppet/parser/functions/defined.rb +++ b/lib/puppet/parser/functions/defined.rb @@ -1,10 +1,45 @@ # Test whether a given class or definition is defined -Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Determine whether a given - type is defined, either as a native type or a defined type, or whether a class is defined. - This is useful for checking whether a class is defined and only including it if it is. - This function can also test whether a resource has been defined, using resource references - (e.g., `if defined(File['/tmp/myfile']) { ... }`). This function is unfortunately - dependent on the parse order of the configuration when testing whether a resource is defined.") do |vals| +Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Determine whether + a given type, class, resource, or node is defined, and return + true or false. Accepts class names, type names, resource references, and node + references. + + The `defined` function checks both native and defined types, including types + provided as plugins via modules. Types are checked using their names: + + defined(\"file\") + defined(\"customtype\") + + Classes are also checked using their names: + + defined(\"foo\") + defined(\"foo::bar\") + + Unlike classes and types, resource definitions are checked using resource + references, e.g. `defined( File['/tmp/myfile'] )`. Checking whether a given + resource defined is, unfortunately, dependent on the parse order of the + configuration, and the following code will not work: + + if defined(File['/tmp/foo']) { + notify(\"This configuration includes the /tmp/foo file.\") + } + file {\"/tmp/foo\": + ensure => present, + } + + However, this order requirement refers to parse order only, and ordering of + resources in the configuration graph (e.g. with `begin` or `require`) does not + affect the behavior of `defined`. + + You can also use `defined` to check whether a node is defined using syntax + resembling a resource reference, like `Node[\"testnode.domain.com\"]`. This usage + is not necessarily recommended, and is included here only in the spirit of + completeness. Checking for node definitions behaves differently from the other + uses of `defined`: it will only return true if a definition for the specified + node (the name of which must match exactly) exists in the manifest **AND** the + specified node matches the node whose configuration is being compiled (either + directly or through node inheritance). The `define` function cannot be used to + introspect information returned by an external node classifier. ") do |vals| result = false vals = [vals] unless vals.is_a?(Array) vals.each do |val| -- cgit From 2b9f6535d46eecd60d8997e93dd2b7533b9e5e71 Mon Sep 17 00:00:00 2001 From: nfagerlund Date: Tue, 25 Jan 2011 17:09:25 -0800 Subject: (#5944) Further edits of inline defined() documentation. Fixing use of define/declare; editing for clarity. --- lib/puppet/parser/functions/defined.rb | 55 ++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 25 deletions(-) (limited to 'lib/puppet/parser') diff --git a/lib/puppet/parser/functions/defined.rb b/lib/puppet/parser/functions/defined.rb index c3efc5f76..deb57a616 100644 --- a/lib/puppet/parser/functions/defined.rb +++ b/lib/puppet/parser/functions/defined.rb @@ -1,45 +1,50 @@ # Test whether a given class or definition is defined Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Determine whether - a given type, class, resource, or node is defined, and return - true or false. Accepts class names, type names, resource references, and node - references. - + a given type or class is defined. This function can also determine whether a + specific resource has been declared. Returns true or false. Accepts class names, + type names, resource references, and node references. + The `defined` function checks both native and defined types, including types - provided as plugins via modules. Types are checked using their names: - + provided as plugins via modules. Types and classes are both checked using their names: + defined(\"file\") defined(\"customtype\") - - Classes are also checked using their names: - defined(\"foo\") defined(\"foo::bar\") - - Unlike classes and types, resource definitions are checked using resource - references, e.g. `defined( File['/tmp/myfile'] )`. Checking whether a given - resource defined is, unfortunately, dependent on the parse order of the - configuration, and the following code will not work: - + + Resource declarations are checked using resource references, e.g. + `defined( File['/tmp/myfile'] )`. Checking whether a given resource + has been declared is, unfortunately, dependent on the parse order of + the configuration, and the following code will not work: + if defined(File['/tmp/foo']) { notify(\"This configuration includes the /tmp/foo file.\") } file {\"/tmp/foo\": ensure => present, } - + However, this order requirement refers to parse order only, and ordering of - resources in the configuration graph (e.g. with `begin` or `require`) does not + resources in the configuration graph (e.g. with `before` or `require`) does not affect the behavior of `defined`. - - You can also use `defined` to check whether a node is defined using syntax + + You can also use `defined` to check whether a node is declared using syntax resembling a resource reference, like `Node[\"testnode.domain.com\"]`. This usage is not necessarily recommended, and is included here only in the spirit of - completeness. Checking for node definitions behaves differently from the other - uses of `defined`: it will only return true if a definition for the specified - node (the name of which must match exactly) exists in the manifest **AND** the - specified node matches the node whose configuration is being compiled (either - directly or through node inheritance). The `define` function cannot be used to - introspect information returned by an external node classifier. ") do |vals| + completeness. Note that: + + * Only the node whose configuration is being compiled is considered declared; + the `define` function will not return information about definitions not currently + being used. + * Node definitions inherited by the current node are considered declared; + however, the default node is never considered declared. + * A node is not considered declared simply by virtue of receiving a + configuration; it must have matched a node definition in the manifest. + * The name used in the node reference must match the name used in the node + definition, even if this is not the node's actual certname. + * Regular expression node definitions cannot be checked for declaration using + `define`, nor can `define` be used to introspect information returned by an + external node classifier.") do |vals| result = false vals = [vals] unless vals.is_a?(Array) vals.each do |val| -- cgit From 86a2a0031fdad032003d053244a3baa04c8f2b81 Mon Sep 17 00:00:00 2001 From: nfagerlund Date: Tue, 25 Jan 2011 17:50:17 -0800 Subject: (#5944) Remove documentation of define() when used on nodes, as it is not a supported use of this function. Final patch in this series reviewed by Dan Bode. --- lib/puppet/parser/functions/defined.rb | 24 +++--------------------- 1 file changed, 3 insertions(+), 21 deletions(-) (limited to 'lib/puppet/parser') diff --git a/lib/puppet/parser/functions/defined.rb b/lib/puppet/parser/functions/defined.rb index deb57a616..2aeaa9ba0 100644 --- a/lib/puppet/parser/functions/defined.rb +++ b/lib/puppet/parser/functions/defined.rb @@ -1,8 +1,8 @@ # Test whether a given class or definition is defined Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Determine whether - a given type or class is defined. This function can also determine whether a + a given class or resource type is defined. This function can also determine whether a specific resource has been declared. Returns true or false. Accepts class names, - type names, resource references, and node references. + type names, and resource references. The `defined` function checks both native and defined types, including types provided as plugins via modules. Types and classes are both checked using their names: @@ -26,25 +26,7 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Dete However, this order requirement refers to parse order only, and ordering of resources in the configuration graph (e.g. with `before` or `require`) does not - affect the behavior of `defined`. - - You can also use `defined` to check whether a node is declared using syntax - resembling a resource reference, like `Node[\"testnode.domain.com\"]`. This usage - is not necessarily recommended, and is included here only in the spirit of - completeness. Note that: - - * Only the node whose configuration is being compiled is considered declared; - the `define` function will not return information about definitions not currently - being used. - * Node definitions inherited by the current node are considered declared; - however, the default node is never considered declared. - * A node is not considered declared simply by virtue of receiving a - configuration; it must have matched a node definition in the manifest. - * The name used in the node reference must match the name used in the node - definition, even if this is not the node's actual certname. - * Regular expression node definitions cannot be checked for declaration using - `define`, nor can `define` be used to introspect information returned by an - external node classifier.") do |vals| + affect the behavior of `defined`.") do |vals| result = false vals = [vals] unless vals.is_a?(Array) vals.each do |val| -- cgit From a732a15a0fd43ce983474cae4c298a9bbd86329f Mon Sep 17 00:00:00 2001 From: James Turnbull Date: Wed, 15 Dec 2010 23:39:12 +1100 Subject: Fixed #5564 - Added some more fqdn_rand documentation Reviewed-by: Paul Berry --- lib/puppet/parser/functions/fqdn_rand.rb | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'lib/puppet/parser') diff --git a/lib/puppet/parser/functions/fqdn_rand.rb b/lib/puppet/parser/functions/fqdn_rand.rb index 3e7018ac4..52946f2c1 100644 --- a/lib/puppet/parser/functions/fqdn_rand.rb +++ b/lib/puppet/parser/functions/fqdn_rand.rb @@ -1,7 +1,10 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc => - "Generates random numbers based on the node's fqdn. The first argument - sets the range. Additional (optional) arguments may be used to further - distinguish the seed.") do |args| + "Generates random numbers based on the node's fqdn. Generated random values + will be a range from 0 up to and excluding n, where n is the first parameter. + The second argument specifies a number to add to the seed and is optional, for example: + + $random_number = fqdn_rand(30) + $random_number_seed = fqdn_rand(30,30)") do |args| require 'md5' max = args.shift srand MD5.new([lookupvar('fqdn'),args].join(':')).to_s.hex -- cgit