On Friday, November 15, 2013 5:50:16 PM UTC-6, Jon McKenzie wrote:
>
> Thanks John,
>
> Unfortunately, we're using Foreman in our shop for the ENC, so using Hiera
> is currently not possible (AFAIK)
>
>
What does one have to do with the other?
> For some reason, I thought the "require" statement was analogous to the
> "require" metaparameter. But looking at the documentation, clearly that's
> not the case. Still, this seems like a bug to me. If this is a duplicate
> declaration, shouldn't it error regardless of the ordering within the
> manifest?
>
>
For classes, it is not duplicate declaration generally that is the
problem. It is a fundamental design feature of Puppet that the same class
may be 'include'd (or 'require'd, or, now, 'contain'ed) multiple times, and
more generally that it is OK to include (etc.) a class that has already
been declared.
Parameterized-style declarations are a bit of a fly in the ointment,
however, because they do two distinct things that are only loosely related:
(1) declare a class, and (2) bind values to the class's parameters. It is
the second function that causes trouble.
If Puppet could parse the whole manifest set to determine what classes were
declared first, then go back and set class parameters, then the constraint
you ran into could be solved. Unfortunately, that is not possible because
class parameter values can influence which classes are declared. There is
no reliable, general way to defer class parameter assignments, so
parameters are bound to a class by the first declaration evaluated, and
subsequent parameter list declarations (even empty ones) cannot be honored.
tl;dr: it's not a bug, it's a design shortcoming.
> Anyways, would writing something like this work?
>
> class { "foo::bar":
> Class["foo:baz"] -> Class["foo::bar"]
> }
>
>
Puppet should not object to that, provided that Class['foo::baz'] is
declared somewhere else in the manifest set. It should not be sensitive to
evaluation order. With that said, the constraint that foo::baz must be
declared, but foo::bar does not cause it to be, constitutes a weakness that
may bite you later. I would suggest omitting the ordering relationship
from foo::bar, and instead declaring the relationship in some place where
you can know that both classes have been declared. For example,
class foo::bam {
include 'foo::bar'
class {'foo::baz': }
Class['foo::baz'] -> Class['foo::bar']
}
If indeed the relationship declaration is safe in foo::bar in the first place,
then there must be one or more such higher-level places that would be suitable
for declaring the relationship.
John
--
You received this message because you are subscribed to the Google Groups
"Puppet Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to puppet-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit
https://groups.google.com/d/msgid/puppet-users/164bd119-0fe2-4269-9ad2-628180503fd9%40googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
