[213] Processes->components

src/bin/bind10/bind10_src.py.in

@@ -254,12 +254,11 @@ class BoB:
         self.msgq_socket_file = msgq_socket_file
         self.nocache = nocache
         self.component_config = {}
-        # This is not named "components" on purpose, as there doesn't have
-        # to be one-to-one correspondence between processes and components
-        # (A component can have multiple processes, therefore taking multiple
-        # places in the dict, or no processes at all). This tracks the real,
-        # running processes.
-        self.processes = {}
+        # Some time in future, it may happen that a single component has
+        # multple processes. If so happens, name "components" may be
+        # inapropriate. But as the code isn't probably completely ready
+        # for it, we leave it at components for now.
+        self.components = {}
         self.runnable = False
         self.uid = setuid
         self.username = username
@@ -373,11 +372,11 @@ class BoB:
         return answer
 
     def get_processes(self):
-        pids = list(self.processes.keys())
+        pids = list(self.components.keys())
         pids.sort()
         process_list = [ ]
         for pid in pids:
-            process_list.append([pid, self.processes[pid].name()])
+            process_list.append([pid, self.components[pid].name()])
         return process_list
 
     def _get_stats_data(self):
@@ -426,7 +425,7 @@ class BoB:
                                                             "Unknown command")
         return answer
 
-    def kill_started_processes(self):
+    def kill_started_components(self):
         """
             Called as part of the exception handling when a process fails to
             start, this runs through the list of started processes, killing
@@ -434,10 +433,10 @@ class BoB:
         """
         logger.info(BIND10_KILLING_ALL_PROCESSES)
 
-        for pid in self.processes:
-            logger.info(BIND10_KILL_PROCESS, self.processes[pid].name())
-            self.processes[pid].kill(True)
-        self.processes = {}
+        for pid in self.components:
+            logger.info(BIND10_KILL_PROCESS, self.components[pid].name())
+            self.components[pid].kill(True)
+        self.components = {}
 
     def read_bind10_config(self):
         """
@@ -618,7 +617,7 @@ class BoB:
         Put another process into boss to watch over it.  When the process
         dies, the component.failed() is called with the exit code.
         """
-        self.processes[pid] = component
+        self.components[pid] = component
 
     def start_simple(self, name):
         """
@@ -718,10 +717,10 @@ class BoB:
 
         return self.start_process("b10-xfrin", args, c_channel_env)
 
-    def start_all_processes(self):
+    def start_all_components(self):
         """
-            Starts up all the processes.  Any exception generated during the
-            starting of the processes is handled by the caller.
+            Starts up all the components.  Any exception generated during the
+            starting of the components is handled by the caller.
         """
         # Start the real core (sockcreator, msgq, cfgmgr)
         self._component_configurator.startup(self.__core_components)
@@ -736,7 +735,7 @@ class BoB:
         # configuration may override the "-v" switch set on the command line.
         self.read_bind10_config()
 
-        # Continue starting the processes.  The authoritative server (if
+        # Continue starting the components.  The authoritative server (if
         # selected):
         component_config = {}
         if self.cfg_start_auth:
@@ -769,7 +768,7 @@ class BoB:
             self.__propagate_component_config(component_config)
             self.started_auth_family = True
 
-        # ... and finally start the remaining processes
+        # ... and finally start the remaining components
         component_config['b10-stats'] = { 'kind': 'dispensable',
                                           'address': 'Stats' }
         component_config['b10-stats-httpd'] = { 'kind': 'dispensable',
@@ -807,13 +806,13 @@ class BoB:
             # this is the case we want, where the msgq is not running
             pass
 
-        # Start all processes.  If any one fails to start, kill all started
-        # processes and exit with an error indication.
+        # Start all components.  If any one fails to start, kill all started
+        # components and exit with an error indication.
         try:
             self.c_channel_env = c_channel_env
-            self.start_all_processes()
+            self.start_all_components()
         except Exception as e:
-            self.kill_started_processes()
+            self.kill_started_components()
             return "Unable to start " + self.curproc + ": " + str(e)
 
         # Started successfully
@@ -878,7 +877,7 @@ class BoB:
         time.sleep(1)
         self.reap_children()
         # next try sending a SIGTERM
-        components_to_stop = list(self.processes.values())
+        components_to_stop = list(self.components.values())
         for component in components_to_stop:
             logger.info(BIND10_SEND_SIGTERM, component.name(), component.pid())
             try:
@@ -888,11 +887,11 @@ class BoB:
                 # finally exited)
                 pass
         # finally, send SIGKILL (unmaskable termination) until everybody dies
-        while self.processes:
+        while self.components:
             # XXX: some delay probably useful... how much is uncertain
             time.sleep(0.1)  
             self.reap_children()
-            components_to_stop = list(self.processes.values())
+            components_to_stop = list(self.components.values())
             for component in components_to_stop:
                 logger.info(BIND10_SEND_SIGKILL, component.name(),
                             component.pid())
@@ -919,9 +918,9 @@ class BoB:
                 # XXX: should be impossible to get any other error here
                 raise
             if pid == 0: break
-            if pid in self.processes:
-                # One of the processes we know about.  Get information on it.
-                component = self.processes.pop(pid)
+            if pid in self.components:
+                # One of the components we know about.  Get information on it.
+                component = self.components.pop(pid)
                 logger.info(BIND10_PROCESS_ENDED, component.name(), pid,
                             exit_status)
                 if component.running() and self.runnable:
@@ -969,7 +968,7 @@ class BoB:
                 logger.info(BIND10_RESURRECTING_PROCESS, proc_info.name)
                 try:
                     proc_info.respawn()
-                    self.processes[proc_info.pid] = proc_info
+                    self.components[proc_info.pid] = proc_info
                     logger.info(BIND10_RESURRECTED_PROCESS, proc_info.name, proc_info.pid)
                 except:
                     still_dead[proc_info.pid] = proc_info

src/bin/bind10/tests/bind10_test.py.in

@@ -104,7 +104,7 @@ class TestBoB(unittest.TestCase):
         self.assertEqual(bob.msgq_socket_file, None)
         self.assertEqual(bob.cc_session, None)
         self.assertEqual(bob.ccs, None)
-        self.assertEqual(bob.processes, {})
+        self.assertEqual(bob.components, {})
         self.assertEqual(bob.dead_processes, {})
         self.assertEqual(bob.runnable, False)
         self.assertEqual(bob.uid, None)
@@ -122,7 +122,7 @@ class TestBoB(unittest.TestCase):
         self.assertEqual(bob.msgq_socket_file, "alt_socket_file")
         self.assertEqual(bob.cc_session, None)
         self.assertEqual(bob.ccs, None)
-        self.assertEqual(bob.processes, {})
+        self.assertEqual(bob.components, {})
         self.assertEqual(bob.dead_processes, {})
         self.assertEqual(bob.runnable, False)
         self.assertEqual(bob.uid, None)
@@ -221,7 +221,7 @@ class MockBob(BoB):
         self.dhcp6 = False
         self.dhcp4 = False
         self.c_channel_env = {}
-        self.processes = { }
+        self.components = { }
         self.creator = False
 
         class MockSockCreator(isc.bind10.component.Component):
@@ -351,58 +351,58 @@ class MockBob(BoB):
     # in case he forgets to update the tests.
     def stop_msgq(self):
         if self.msgq:
-            del self.processes[2]
+            del self.components[2]
         self.msgq = False
 
     def stop_cfgmgr(self):
         if self.cfgmgr:
-            del self.processes[3]
+            del self.components[3]
         self.cfgmgr = False
 
     def stop_auth(self):
         if self.auth:
-            del self.processes[5]
+            del self.components[5]
         self.auth = False
 
     def stop_resolver(self):
         if self.resolver:
-            del self.processes[6]
+            del self.components[6]
         self.resolver = False
 
     def stop_xfrout(self):
         if self.xfrout:
-            del self.processes[7]
+            del self.components[7]
         self.xfrout = False
 
     def stop_xfrin(self):
         if self.xfrin:
-            del self.processes[8]
+            del self.components[8]
         self.xfrin = False
 
     def stop_zonemgr(self):
         if self.zonemgr:
-            del self.processes[9]
+            del self.components[9]
         self.zonemgr = False
 
     def stop_stats(self):
         if self.stats:
-            del self.processes[10]
+            del self.components[10]
         self.stats = False
 
     def stop_stats_httpd(self):
         if self.stats_httpd:
-            del self.processes[11]
+            del self.components[11]
         self.stats_httpd = False
 
     def stop_cmdctl(self):
         if self.cmdctl:
-            del self.processes[12]
+            del self.components[12]
         self.cmdctl = False
 
 class TestStartStopProcessesBob(unittest.TestCase):
     """
-    Check that the start_all_processes method starts the right combination
-    of processes and that the right processes are started and stopped
+    Check that the start_all_components method starts the right combination
+    of components and that the right components are started and stopped
     according to changes in configuration.
     """
     def check_environment_unchanged(self):
@@ -436,7 +436,7 @@ class TestStartStopProcessesBob(unittest.TestCase):
     def check_started_none(self, bob):
         """
         Check that the situation is according to configuration where no servers
-        should be started. Some processes still need to be running.
+        should be started. Some components still need to be running.
         """
         self.check_started(bob, True, False, False)
         self.check_environment_unchanged()
@@ -451,14 +451,14 @@ class TestStartStopProcessesBob(unittest.TestCase):
 
     def check_started_auth(self, bob):
         """
-        Check the set of processes needed to run auth only is started.
+        Check the set of components needed to run auth only is started.
         """
         self.check_started(bob, True, True, False)
         self.check_environment_unchanged()
 
     def check_started_resolver(self, bob):
         """
-        Check the set of processes needed to run resolver only is started.
+        Check the set of components needed to run resolver only is started.
         """
         self.check_started(bob, True, False, True)
         self.check_environment_unchanged()
@@ -476,65 +476,65 @@ class TestStartStopProcessesBob(unittest.TestCase):
         self.assertEqual(v6==True, v6found==1)
         self.check_environment_unchanged()
 
-    # Checks the processes started when starting neither auth nor resolver
+    # Checks the components started when starting neither auth nor resolver
     # is specified.
     def test_start_none(self):
         # Create BoB and ensure correct initialization
         bob = MockBob()
         self.check_preconditions(bob)
 
-        # Start processes and check what was started
+        # Start components and check what was started
         bob.cfg_start_auth = False
         bob.cfg_start_resolver = False
 
-        bob.start_all_processes()
+        bob.start_all_components()
         self.check_started_none(bob)
 
-    # Checks the processes started when starting only the auth process
+    # Checks the components started when starting only the auth process
     def test_start_auth(self):
         # Create BoB and ensure correct initialization
         bob = MockBob()
         self.check_preconditions(bob)
 
-        # Start processes and check what was started
+        # Start components and check what was started
         bob.cfg_start_auth = True
         bob.cfg_start_resolver = False
 
-        bob.start_all_processes()
+        bob.start_all_components()
 
         self.check_started_auth(bob)
 
-    # Checks the processes started when starting only the resolver process
+    # Checks the components started when starting only the resolver process
     def test_start_resolver(self):
         # Create BoB and ensure correct initialization
         bob = MockBob()
         self.check_preconditions(bob)
 
-        # Start processes and check what was started
+        # Start components and check what was started
         bob.cfg_start_auth = False
         bob.cfg_start_resolver = True
 
-        bob.start_all_processes()
+        bob.start_all_components()
 
         self.check_started_resolver(bob)
 
-    # Checks the processes started when starting both auth and resolver process
+    # Checks the components started when starting both auth and resolver process
     def test_start_both(self):
         # Create BoB and ensure correct initialization
         bob = MockBob()
         self.check_preconditions(bob)
 
-        # Start processes and check what was started
+        # Start components and check what was started
         bob.cfg_start_auth = True
         bob.cfg_start_resolver = True
 
-        bob.start_all_processes()
+        bob.start_all_components()
 
         self.check_started_both(bob)
 
     def test_config_start(self):
         """
-        Test that the configuration starts and stops processes according
+        Test that the configuration starts and stops components according
         to configuration changes.
         """
 
@@ -542,12 +542,12 @@ class TestStartStopProcessesBob(unittest.TestCase):
         bob = MockBob()
         self.check_preconditions(bob)
 
-        # Start processes (nothing much should be started, as in
+        # Start components (nothing much should be started, as in
         # test_start_none)
         bob.cfg_start_auth = False
         bob.cfg_start_resolver = False
 
-        bob.start_all_processes()
+        bob.start_all_components()
         bob.runnable = True
         self.check_started_none(bob)
 
@@ -607,11 +607,11 @@ class TestStartStopProcessesBob(unittest.TestCase):
         bob = MockBob()
         self.check_preconditions(bob)
 
-        # Start processes (both)
+        # Start components (both)
         bob.cfg_start_auth = True
         bob.cfg_start_resolver = True
 
-        bob.start_all_processes()
+        bob.start_all_components()
         bob.runnable = True
         self.check_started_both(bob)
 
@@ -627,7 +627,7 @@ class TestStartStopProcessesBob(unittest.TestCase):
 
     def test_config_not_started_early(self):
         """
-        Test that processes are not started by the config handler before
+        Test that components are not started by the config handler before
         startup.
         """
         bob = MockBob()
@@ -641,7 +641,7 @@ class TestStartStopProcessesBob(unittest.TestCase):
 
         bob.config_handler({'start_auth': True, 'start_resolver': True})
 
-    # Checks that DHCP (v4 and v6) processes are started when expected
+    # Checks that DHCP (v4 and v6) components are started when expected
     def test_start_dhcp(self):
 
         # Create BoB and ensure correct initialization
@@ -655,7 +655,7 @@ class TestStartStopProcessesBob(unittest.TestCase):
         # v4 and v6 disabled
         bob.cfg_start_dhcp6 = False
         bob.cfg_start_dhcp4 = False
-        bob.start_all_processes()
+        bob.start_all_components()
         self.check_started_dhcp(bob, False, False)
 
     def test_start_dhcp_v6only(self):
@@ -670,7 +670,7 @@ class TestStartStopProcessesBob(unittest.TestCase):
         # v6 only enabled
         bob.cfg_start_dhcp6 = True
         bob.cfg_start_dhcp4 = False
-        bob.start_all_processes()
+        bob.start_all_components()
         self.check_started_dhcp(bob, False, True)
 
         # uncomment when dhcpv4 becomes implemented
@@ -831,7 +831,7 @@ class TestPIDFile(unittest.TestCase):
 class TestBrittle(unittest.TestCase):
     def test_brittle_disabled(self):
         bob = MockBob()
-        bob.start_all_processes()
+        bob.start_all_components()
         bob.runnable = True
 
         bob.reap_children()
@@ -844,7 +844,7 @@ class TestBrittle(unittest.TestCase):
 
     def test_brittle_enabled(self):
         bob = MockBob()
-        bob.start_all_processes()
+        bob.start_all_components()
         bob.runnable = True
 
         bob.brittle = True