Merge pull request #55565 from s0undt3ch/features/pytest-staged-29

[PyTest #29] Allow passing the context dictionary to Sminion and Runner

salt/loader.py

@@ -537,7 +537,7 @@ def thorium(opts, functions, runners):
     return ret
 
 
-def states(opts, functions, utils, serializers, whitelist=None, proxy=None):
+def states(opts, functions, utils, serializers, whitelist=None, proxy=None, context=None):
     '''
     Returns the state modules
 
@@ -553,6 +553,9 @@ def states(opts, functions, utils, serializers, whitelist=None, proxy=None):
         __opts__ = salt.config.minion_config('/etc/salt/minion')
         statemods = salt.loader.states(__opts__, None, None)
     '''
+    if context is None:
+        context = {}
+
     ret = LazyLoader(
         _module_dirs(opts, 'states'),
         opts,
@@ -563,6 +566,7 @@ def states(opts, functions, utils, serializers, whitelist=None, proxy=None):
     ret.pack['__states__'] = ret
     ret.pack['__utils__'] = utils
     ret.pack['__serializers__'] = serializers
+    ret.pack['__context__'] = context
     return ret
 
 
@@ -623,12 +627,17 @@ def ssh_wrapper(opts, functions=None, context=None):
     )
 
 
-def render(opts, functions, states=None, proxy=None):
+def render(opts, functions, states=None, proxy=None, context=None):
     '''
     Returns the render modules
     '''
+    if context is None:
+        context = {}
+
     pack = {'__salt__': functions,
-            '__grains__': opts.get('grains', {})}
+            '__grains__': opts.get('grains', {}),
+            '__context__': context}
+
     if states:
         pack['__states__'] = states
     pack['__proxy__'] = proxy or {}

salt/minion.py

@@ -423,7 +423,7 @@ def __init__(self, opts):
         self.opts = opts
         self.beacons_leader = opts.get('beacons_leader', True)
 
-    def gen_modules(self, initial_load=False):
+    def gen_modules(self, initial_load=False, context=None):
         '''
         Tell the minion to reload the execution modules
 
@@ -442,22 +442,26 @@ def gen_modules(self, initial_load=False):
                 pillarenv=self.opts.get('pillarenv'),
             ).compile_pillar()
 
-        self.utils = salt.loader.utils(self.opts)
-        self.functions = salt.loader.minion_mods(self.opts, utils=self.utils)
+        self.utils = salt.loader.utils(self.opts, context=context)
+        self.functions = salt.loader.minion_mods(self.opts, utils=self.utils, context=context)
         self.serializers = salt.loader.serializers(self.opts)
-        self.returners = salt.loader.returners(self.opts, self.functions)
-        self.proxy = salt.loader.proxy(self.opts, self.functions, self.returners, None)
+        self.returners = salt.loader.returners(self.opts, functions=self.functions, context=context)
+        self.proxy = salt.loader.proxy(self.opts, functions=self.functions, returners=self.returners)
         # TODO: remove
         self.function_errors = {}  # Keep the funcs clean
         self.states = salt.loader.states(self.opts,
-                self.functions,
-                self.utils,
-                self.serializers)
-        self.rend = salt.loader.render(self.opts, self.functions)
+                                         functions=self.functions,
+                                         utils=self.utils,
+                                         serializers=self.serializers,
+                                         context=context)
+        self.rend = salt.loader.render(self.opts, functions=self.functions, context=context)
 #        self.matcher = Matcher(self.opts, self.functions)
         self.matchers = salt.loader.matchers(self.opts)
         self.functions['sys.reload_modules'] = self.gen_modules
-        self.executors = salt.loader.executors(self.opts, self.functions, proxy=self.proxy)
+        self.executors = salt.loader.executors(self.opts,
+                                               functions=self.functions,
+                                               proxy=self.proxy,
+                                               context=context)
 
     @staticmethod
     def process_schedule(minion, loop_interval):
@@ -829,7 +833,7 @@ class SMinion(MinionBase):
     generate all of the salt minion functions and present them with these
     functions for general use.
     '''
-    def __init__(self, opts):
+    def __init__(self, opts, context=None):
         # Late setup of the opts grains, so we can log from the grains module
         import salt.loader
         opts['grains'] = salt.loader.grains(opts)
@@ -843,7 +847,7 @@ def __init__(self, opts):
             io_loop.run_sync(
                 lambda: self.eval_master(self.opts, failed=True)
             )
-        self.gen_modules(initial_load=True)
+        self.gen_modules(initial_load=True, context=context or {})
 
         # If configured, cache pillar data on the minion
         if self.opts['file_client'] == 'remote' and self.opts.get('minion_pillar_cache', False):
@@ -1638,8 +1642,8 @@ def _thread_return(cls, minion_instance, opts, data):
                         minion_blackout_violation = True
                 if minion_blackout_violation:
                     raise SaltInvocationError('Minion in blackout mode. Set \'minion_blackout\' '
-                                             'to False in pillar or grains to resume operations. Only '
-                                             'saltutil.refresh_pillar allowed in blackout mode.')
+                                              'to False in pillar or grains to resume operations. Only '
+                                              'saltutil.refresh_pillar allowed in blackout mode.')
 
                 if function_name in minion_instance.functions:
                     func = minion_instance.functions[function_name]
@@ -3393,7 +3397,7 @@ class SProxyMinion(SMinion):
     generate all of the salt minion functions and present them with these
     functions for general use.
     '''
-    def gen_modules(self, initial_load=False):
+    def gen_modules(self, initial_load=False, context=None):
         '''
         Tell the minion to reload the execution modules
 
@@ -3428,13 +3432,23 @@ def gen_modules(self, initial_load=False):
         # Then load the proxy module
         self.proxy = salt.loader.proxy(self.opts)
 
-        self.utils = salt.loader.utils(self.opts, proxy=self.proxy)
-
-        self.functions = salt.loader.minion_mods(self.opts, utils=self.utils, notify=False, proxy=self.proxy)
-        self.returners = salt.loader.returners(self.opts, self.functions, proxy=self.proxy)
+        self.utils = salt.loader.utils(self.opts, proxy=self.proxy, context=context)
+
+        self.functions = salt.loader.minion_mods(self.opts,
+                                                 utils=self.utils,
+                                                 notify=False,
+                                                 proxy=self.proxy,
+                                                 context=context)
+        self.returners = salt.loader.returners(self.opts,
+                                               functions=self.functions,
+                                               proxy=self.proxy,
+                                               context=context)
         self.matchers = salt.loader.matchers(self.opts)
         self.functions['sys.reload_modules'] = self.gen_modules
-        self.executors = salt.loader.executors(self.opts, self.functions, proxy=self.proxy)
+        self.executors = salt.loader.executors(self.opts,
+                                               functions=self.functions,
+                                               proxy=self.proxy,
+                                               context=context)
 
         fq_proxyname = self.opts['proxy']['proxytype']
 
@@ -3449,7 +3463,7 @@ def gen_modules(self, initial_load=False):
         self.proxy.pack['__pillar__'] = self.opts['pillar']
 
         # Reload utils as well (chicken and egg, __utils__ needs __proxy__ and __proxy__ needs __utils__
-        self.utils = salt.loader.utils(self.opts, proxy=self.proxy)
+        self.utils = salt.loader.utils(self.opts, proxy=self.proxy, context=context)
         self.proxy.pack['__utils__'] = self.utils
 
         # Reload all modules so all dunder variables are injected

salt/runner.py

@@ -41,9 +41,11 @@ class RunnerClient(mixins.SyncClientMixin, mixins.AsyncClientMixin, object):
     client = 'runner'
     tag_prefix = 'run'
 
-    def __init__(self, opts):
+    def __init__(self, opts, context=None):
         self.opts = opts
-        self.context = {}
+        if context is None:
+            context = {}
+        self.context = context
 
     @property
     def functions(self):
@@ -160,9 +162,9 @@ class Runner(RunnerClient):
     '''
     Execute the salt runner interface
     '''
-    def __init__(self, opts):
-        super(Runner, self).__init__(opts)
-        self.returners = salt.loader.returners(opts, self.functions)
+    def __init__(self, opts, context=None):
+        super(Runner, self).__init__(opts, context=context)
+        self.returners = salt.loader.returners(opts, self.functions, context=context)
         self.outputters = salt.loader.outputters(opts)
 
     def print_docs(self):

salt/state.py

@@ -957,7 +957,7 @@ def _load_states(self):
             self.states = salt.loader.thorium(self.opts, self.functions, {})  # TODO: Add runners, proxy?
         else:
             self.states = salt.loader.states(self.opts, self.functions, self.utils,
-                                             self.serializers, proxy=self.proxy)
+                                             self.serializers, context=self.state_con, proxy=self.proxy)
 
     def load_modules(self, data=None, proxy=None):
         '''
@@ -991,7 +991,7 @@ def load_modules(self, data=None, proxy=None):
         self.serializers = salt.loader.serializers(self.opts)
         self._load_states()
         self.rend = salt.loader.render(self.opts, self.functions,
-                                       states=self.states, proxy=self.proxy)
+                                       states=self.states, proxy=self.proxy, context=self.state_con)
 
     def module_refresh(self):
         '''
@@ -4210,7 +4210,7 @@ def load_modules(self, data=None, proxy=None):
         self.utils = salt.loader.utils(self.opts)
         self.serializers = salt.loader.serializers(self.opts)
         self.states = salt.loader.states(self.opts, self.functions, self.utils, self.serializers)
-        self.rend = salt.loader.render(self.opts, self.functions, states=self.states)
+        self.rend = salt.loader.render(self.opts, self.functions, states=self.states, context=self.state_con)
 
 
 class MasterHighState(HighState):