Better correlation between two features.

Removed 'notify' argument.
Removed superfluous event send.
Minor updates

salt/defaults/events.py

@@ -9,5 +9,5 @@ as this may result in circular imports.
 """
 
 # Constants for events on the minion bus
-MINION_PILLAR_COMPLETE = "/salt/minion/minion_pillar_complete"
-MINION_MOD_COMPLETE = "/salt/minion/minion_mod_complete"
+MINION_PILLAR_REFRESH_COMPLETE = "/salt/minion/minion_pillar_refresh_complete"
+MINION_MOD_REFRESH_COMPLETE = "/salt/minion/minion_mod_refresh_complete"

salt/loader.py

@@ -285,7 +285,7 @@ def minion_mods(
     if notify:
         with salt.utils.event.get_event("minion", opts=opts, listen=False) as evt:
             evt.fire_event(
-                {"complete": True}, tag=salt.defaults.events.MINION_MOD_COMPLETE
+                {"complete": True}, tag=salt.defaults.events.MINION_MOD_REFRESH_COMPLETE
             )
 
     return ret

salt/minion.py

@@ -2411,14 +2411,14 @@ class Minion(MinionBase):
 
     # TODO: only allow one future in flight at a time?
     @salt.ext.tornado.gen.coroutine
-    def pillar_refresh(self, force_refresh=False, notify=False):
+    def pillar_refresh(self, force_refresh=False):
         """
         Refresh the pillar
         """
         self.module_refresh(force_refresh)
 
         if self.connected:
-            log.debug("Refreshing pillar. Notify: %s", notify)
+            log.debug("Refreshing pillar.")
             async_pillar = salt.pillar.get_async_pillar(
                 self.opts,
                 self.opts["grains"],
@@ -2428,14 +2428,6 @@ class Minion(MinionBase):
             )
             try:
                 self.opts["pillar"] = yield async_pillar.compile_pillar()
-                if notify:
-                    with salt.utils.event.get_event(
-                        "minion", opts=self.opts, listen=False
-                    ) as evt:
-                        evt.fire_event(
-                            {"complete": True},
-                            tag=salt.defaults.events.MINION_PILLAR_COMPLETE,
-                        )
             except SaltClientError:
                 # Do not exit if a pillar refresh fails.
                 log.error(
@@ -2446,10 +2438,11 @@ class Minion(MinionBase):
                 async_pillar.destroy()
         self.matchers_refresh()
         self.beacons_refresh()
-        evt = salt.utils.event.get_event("minion", opts=self.opts)
-        evt.fire_event(
-            {"complete": True}, tag="/salt/minion/minion_pillar_refresh_complete"
-        )
+        with salt.utils.event.get_event("minion", opts=self.opts, listen=False) as evt:
+            evt.fire_event(
+                {"complete": True},
+                tag=salt.defaults.events.MINION_PILLAR_REFRESH_COMPLETE,
+            )
 
     def manage_schedule(self, tag, data):
         """
@@ -2599,10 +2592,7 @@ class Minion(MinionBase):
                 notify=data.get("notify", False),
             )
         elif tag.startswith("pillar_refresh"):
-            yield self.pillar_refresh(
-                force_refresh=data.get("force_refresh", False),
-                notify=data.get("notify", False),
-            )
+            yield self.pillar_refresh(force_refresh=data.get("force_refresh", False))
         elif tag.startswith("beacons_refresh"):
             self.beacons_refresh()
         elif tag.startswith("matchers_refresh"):

salt/modules/saltutil.py

@@ -1150,15 +1150,18 @@ def refresh_pillar(wait=False, timeout=30):
             with salt.utils.event.get_event(
                 "minion", opts=__opts__, listen=True
             ) as eventer:
-                ret = __salt__["event.fire"]({"notify": True}, "pillar_refresh")
+                ret = __salt__["event.fire"]({}, "pillar_refresh")
                 # Wait for the finish event to fire
                 log.trace("refresh_pillar waiting for pillar refresh to complete")
                 # Blocks until we hear this event or until the timeout expires
                 event_ret = eventer.get_event(
-                    tag=salt.defaults.events.MINION_PILLAR_COMPLETE, wait=timeout
+                    tag=salt.defaults.events.MINION_PILLAR_REFRESH_COMPLETE,
+                    wait=timeout,
                 )
                 if not event_ret or event_ret["complete"] is False:
-                    log.warn("Pillar refresh did not complete within timeout %s", timeout)
+                    log.warn(
+                        "Pillar refresh did not complete within timeout %s", timeout
+                    )
         else:
             ret = __salt__["event.fire"]({}, "pillar_refresh")
     except KeyError:
@@ -1197,7 +1200,9 @@ def refresh_modules(**kwargs):
                 # Wait for the finish event to fire
                 log.trace("refresh_modules waiting for module refresh to complete")
                 # Blocks until we hear this event or until the timeout expires
-                eventer.get_event(tag=salt.defaults.events.MINION_MOD_COMPLETE, wait=30)
+                eventer.get_event(
+                    tag=salt.defaults.events.MINION_MOD_REFRESH_COMPLETE, wait=30
+                )
     except KeyError:
         log.error("Event module not available. Module refresh failed.")
         ret = False  # Effectively a no-op, since we can't really return without an event system

tests/integration/modules/test_saltutil.py

@@ -354,7 +354,9 @@ class SaltUtilSyncPillarTest(ModuleCase):
             )
 
         opts = self.run_function("test.get_opts")
-        wait = self.WaitForEvent(opts, salt.defaults.events.MINION_PILLAR_COMPLETE)
+        wait = self.WaitForEvent(
+            opts, salt.defaults.events.MINION_PILLAR_REFRESH_COMPLETE
+        )
         wait.start()
         self.run_function("saltutil.refresh_pillar", wait=True)
         while wait.is_alive():