Le 17/09/2014 10:14, Francois Lafont a écrit :
> For instance with:
>
> class my_module (
> $var1 = $my_module::params::var1,
> $var2 = $my_module::params::var2,
> $var3 = $my_module::params::var3,
> ) inherits my_module::params {
> # The body of the class
> }
>
> and:
>
> class my_module::params {
>
> ## API of the module ##
> $var1 = default_value1
> $var2 = default_value2
> $var3 = default_value3
>
> ## shared variables between the classes of my_module
> ## but they are not part of the API module
> $foo1 = default_value_foo1
> $foo2 = default_value_foo2
> $foo3 = default_value_foo3
> ...
> }
>
> Imagine I want to define an inner class "internal" which
> needs to use $var2, $var3, $foo1 and $foo2. Which pattern
> should I use to define my "internal" class.
>
> This one?
>
> class my_module::internal (
> $var2,
> $var3,
> ) inherits my_module::params {
>
> notify { "value of foo1 -> $foo1": }
> notify { "value of foo2 -> $foo2": }
>
> }
>
> This one?
>
> class my_module::internal (
> $var2,
> $var3,
> ) {
>
> require my_module::params
> notify { "value of foo1 -> $my_module:params::foo1": }
> notify { "value of foo2 -> $my_module:params::foo2": }
>
> }
>
> Or maybe another one...?
In fact, It's curious. I have made some tests with puppet 3.7.0
on Debian Wheezy and I can simply do this:
class my_module::params {
## API of the module ##
$var1 = default_value1
$var2 = default_value2
## shared variables between the classes of my_module
## but they are not part of the API module
$foo1 = default_value_foo1
$foo2 = default_value_foo2
...
}
class my_module (
$var1 = $my_module::params::var1,
$var2 = $my_module::params::var2,
) inherits my_module::params {
include my_module
}
class my_module::internal {
file { '/tmp/test_internal.txt':
content => template('test/test_internal.txt.erb'),
}
notify { 'm1': message => "var1 = ${my_module::var1}", }
notify { 'm2': message => "var2 = ${my_module::var2}", }
notify { 'm3': message => "foo1 = ${my_module::foo1}", }
notify { 'm4': message => "foo2 = ${my_module::foo2}", }
}
It's curious because I use no inheritance in my_module::internal,
no require etc. and despite that I can access to the variables of
my_module. Is it normal?
One thing very curious too: in the my_module::internal class
I can access to $var1 with this syntax :
${my_module::var1}
and $var1 is empty. Ok, I think I understand that. But in my
template "test_internal.txt.erb" I can use directly:
blabla <%= @var1 %> blabla
without the fully qualified name. Here, I don't understand.
Anyway, although I do not understand well the "scope" mechanism
etc. I feel that I can just use this design for inner classes :
class my_module::internal {
# No inheritance, no require of my_module::params etc.
# It's unnecessary.
# In the class, I must use the fully qualified name
# to access to a variable of my_module inherited by
# my_module::params (and sometimes overwritten).
# For instance:
notify { 'm1': message => "var1 = ${my_module::var1}", }
# But in templates, I can directy use @var1.
}
Am I wrong?
François Lafont
--
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 [email protected].
To view this discussion on the web visit
https://groups.google.com/d/msgid/puppet-users/54196F0D.4080909%40gmail.com.
For more options, visit https://groups.google.com/d/optout.
