feature: add optional parameter depends_on attribute to start dependent processes consecutively

Author: Michael Hammann

supervisor/graphutils.py

@@ -0,0 +1,36 @@
+from collections import defaultdict
+ 
+class Graph():
+    def __init__(self,vertices):
+        self.graph = defaultdict(list)
+        self.V = vertices
+ 
+    def addEdge(self,u,v):
+        self.graph[u].append(v)
+
+    def cyclic(self):
+        """Return True if the directed graph has a cycle.
+        The graph must be represented as a dictionary mapping vertices to
+        iterables of neighbouring vertices. For example:
+
+        >>> cyclic({1: (2,), 2: (3,), 3: (1,)})
+        True
+        >>> cyclic({1: (2,), 2: (3,), 3: (4,)})
+        False
+
+        """
+        path = set()
+        visited = set()
+
+        def visit(vertex):
+            if vertex in visited:
+                return False
+            visited.add(vertex)
+            path.add(vertex)
+            for neighbour in self.graph.get(vertex, ()):
+                if neighbour in path or visit(neighbour):
+                    return True
+            path.remove(vertex)
+            return False
+
+        return any(visit(v) for v in self.graph)

supervisor/options.py

@@ -932,6 +932,7 @@ def get(section, opt, *args, **kwargs):
         serverurl = get(section, 'serverurl', None)
         if serverurl and serverurl.strip().upper() == 'AUTO':
             serverurl = None
+        depends_on = get(section, 'depends_on', None)
 
         # find uid from "user" option
         user = get(section, 'user', None)
@@ -1057,7 +1058,9 @@ def get(section, opt, *args, **kwargs):
                 exitcodes=exitcodes,
                 redirect_stderr=redirect_stderr,
                 environment=environment,
-                serverurl=serverurl)
+                serverurl=serverurl,
+                depends_on=depends_on,
+            )
 
             programs.append(pconfig)
 
@@ -1875,7 +1878,7 @@ class ProcessConfig(Config):
         'stderr_events_enabled', 'stderr_syslog',
         'stopsignal', 'stopwaitsecs', 'stopasgroup', 'killasgroup',
         'exitcodes', 'redirect_stderr' ]
-    optional_param_names = [ 'environment', 'serverurl' ]
+    optional_param_names = [ 'environment', 'serverurl', 'depends_on' ]
 
     def __init__(self, options, **params):
         self.options = options

supervisor/process.py

@@ -17,6 +17,7 @@
 from supervisor.states import SupervisorStates
 from supervisor.states import getProcessStateDescription
 from supervisor.states import STOPPED_STATES
+from supervisor.states import RUNNING_STATES
 
 from supervisor.options import decode_wait_status
 from supervisor.options import signame
@@ -194,6 +195,10 @@ def spawn(self):
 
         Return the process id.  If the fork() call fails, return None.
         """
+        # check if the process is dependent upon any other process and if so make sure that one is in the RUNNING state
+        if self.config.depends_on is not None and self.config.depends_on.state not in RUNNING_STATES:
+            self.config.depends_on.spawn()
+
         options = self.config.options
         processname = as_string(self.config.name)
 

supervisor/rpcinterface.py

@@ -592,6 +592,7 @@ def getAllConfigInfo(self):
                      'stderr_logfile_backups': pconfig.stderr_logfile_backups,
                      'stderr_logfile_maxbytes': pconfig.stderr_logfile_maxbytes,
                      'stderr_syslog': pconfig.stderr_syslog,
+                     'depends_on': pconfig.depends_on,
                     }
                 # no support for these types in xml-rpc
                 d.update((k, 'auto') for k, v in d.items() if v is Automatic)

supervisor/supervisord.py

@@ -44,6 +44,7 @@
 from supervisor import events
 from supervisor.states import SupervisorStates
 from supervisor.states import getProcessStateDescription
+from supervisor.graphutils import Graph
 
 class Supervisor:
     stopping = False # set after we detect that we are handling a stop request
@@ -84,6 +85,18 @@ def run(self):
         try:
             for config in self.options.process_group_configs:
                 self.add_process_group(config)
+            # add processes to directed graph, to check for dependency cycles
+            g = Graph(len(self.options.process_group_configs))
+            # replace depends_on string with actual process object
+            for config in (self.options.process_group_configs):
+                depends_on = config.process_configs[0].depends_on
+                if config.process_configs[0].depends_on is not None:
+                    g.addEdge(config.process_configs[0].name, config.process_configs[0].depends_on)
+                    config.process_configs[0].depends_on = self.process_groups[depends_on].processes[depends_on]
+            # check for cyclical process dependencies
+            if g.cyclic() == 1:
+                raise AttributeError('Process config contains dependeny cycle(s)! Check config files again!')
+            
             self.options.openhttpservers(self)
             self.options.setsignals()
             if (not self.options.nodaemon) and self.options.first: