Agfdhyk

Given the following example:

[root@puppet ~]# cat notify_test.pp

define test (

  Boolean $condition = false,

) {



  if $condition {

    notify { "Debug Output of Test[${title}]": }

  }

}



$test_resource_name_a = 'A'

test { $test_resource_name_a: 

  condition => true,

}



$test_resource_name_b = 'B'

test { $test_resource_name_b: }







exec { 'TestExec':

  refreshonly => true,

  command     => '/usr/bin/echo "Mock Service Refresh"',

  logoutput   => true,

  subscribe   => Test[$test_resource_name_a, $test_resource_name_b],

}

Which should only print something to the agent but appearently refreshes all subscribing resources becaus of resource containment (see https://puppet.com/docs/puppet/4.10/lang_containment.html). Unwanted result:

[root@puppet ~]# puppet apply notify_test.pp

Notice: Compiled catalog for puppet in environment production in 0.10 seconds

Notice: Debug Output of Test[A]

Notice: /Stage[main]/Main/Test[A]/Notify[Debug Output of Test[A]]/message: defined 'message' as 'Debug Output of Test[A]'

Notice: /Stage[main]/Main/Exec[TestExec]/returns: Mock Service Refresh

Notice: /Stage[main]/Main/Exec[TestExec]: Triggered 'refresh' from 1 events

Notice: Applied catalog in 1.53 seconds

So whenever the condition is met (e.g. my custom function which uses an HTTP Client to get data from REST APIs which I use is my manifests but dont have real impact on the catalog compilation) all subscribers (e.g. services) would restart every 30 minutes.

This behaviour is unacceptable, so how can I print something to the puppet agent (puppet agent -t) without notifying/refreshing auto-contained resources?

This is a limitation inherent in modeling Notify as a resource. By definition and design, applying a resource does nothing if that resource is initially in sync with the target system. In order that Notify resources do anything (i.e. emit their message), they are always initially out of sync, and emitting their message brings them into sync. You can conceptualize that as a transition from "not printed" to "printed", if you like.

But that means that from Puppet's perspective, every Notify resource is changed every time it is applied. That generates an event, which is propagated to the Notify's container and onward.

This behaviour is unacceptable, so how can I print something to the
puppet agent (puppet agent -t) without notifying/refreshing
auto-contained resources?

If you must have the messages in the agent's log (as opposed to the master's) then your options are limited. In fact, the best I can come up with is to write a custom resource type and provider that is always in sync, yet emits messages into the log anyway. I tested using an Exec with an unless parameter that emits the message, but Puppet does not seem to print the output of the unless command. Certainly, Notify is right out.

If it would be sufficient to emit the message into the master's log, then there is a set of functions for that purpose. Among them, notice(), info(), and debug() seem the most likely for your purpose.

Side note: the phrase "auto-contained resources" suggests that there is another kind. Before Puppet 6 you could declare resources at top scope, and those are contained only by the catalog itself, which does not propagate events to anything else. But every resource declared inside a container -- class or defined type -- is contained by that container. That's always seemed very natural to me. Usually the thing that trips people up about containment is that classes are only contained when you explicitly make it so. There are good reasons for that, but I won't go into them here.