PostgresNode::_try_shutdown is rewrited (normalization)

testgres/node.py

@@ -338,41 +338,84 @@ def version(self):
         return self._pg_version
 
     def _try_shutdown(self, max_attempts, with_force=False):
+        assert type(max_attempts) == int  # noqa: E721
+        assert type(with_force) == bool  # noqa: E721
+        assert max_attempts > 0
+
         attempts = 0
+
+        # try stopping server N times
+        while attempts < max_attempts:
+            attempts += 1
+            try:
+                self.stop()
+            except ExecUtilException:
+                continue  # one more time
+            except Exception:
+                eprint('cannot stop node {}'.format(self.name))
+                break
+
+            return  # OK
+
+        # If force stopping is enabled and PID is valid
+        if not with_force:
+            return
+
         node_pid = self.pid
+        assert node_pid is not None
+        assert type(node_pid) == int  # noqa: E721
 
-        if node_pid > 0:
-            # try stopping server N times
-            while attempts < max_attempts:
-                try:
-                    self.stop()
-                    break    # OK
-                except ExecUtilException:
-                    pass    # one more time
-                except Exception:
-                    eprint('cannot stop node {}'.format(self.name))
-                    break
-
-                attempts += 1
-
-            # If force stopping is enabled and PID is valid
-            if with_force and node_pid != 0:
-                # If we couldn't stop the node
-                p_status_output = self.os_ops.exec_command(cmd=f'ps -o pid= -p {node_pid}', shell=True, ignore_errors=True).decode('utf-8')
-                if self.status() != NodeStatus.Stopped and p_status_output and str(node_pid) in p_status_output:
-                    try:
-                        eprint(f'Force stopping node {self.name} with PID {node_pid}')
-                        self.os_ops.kill(node_pid, signal.SIGKILL, expect_error=False)
-                    except Exception:
-                        # The node has already stopped
-                        pass
-
-                # Check that node stopped - print only column pid without headers
-                p_status_output = self.os_ops.exec_command(f'ps -o pid= -p {node_pid}', shell=True, ignore_errors=True).decode('utf-8')
-                if p_status_output and str(node_pid) in p_status_output:
-                    eprint(f'Failed to stop node {self.name}.')
-                else:
-                    eprint(f'Node {self.name} has been stopped successfully.')
+        if node_pid == 0:
+            return
+
+        # TODO: [2025-02-28] It is really the old ugly code. We have to rewrite it!
+
+        ps_command = ['ps', '-o', 'pid=', '-p', str(node_pid)]
+
+        ps_output = self.os_ops.exec_command(cmd=ps_command, shell=True, ignore_errors=True).decode('utf-8')
+        assert type(ps_output) == str  # noqa: E721
+
+        if ps_output == "":
+            return
+
+        if ps_output != str(node_pid):
+            __class__._throw_bugcheck__unexpected_result_of_ps(
+                ps_output,
+                ps_command)
+
+        try:
+            eprint('Force stopping node {0} with PID {1}'.format(self.name, node_pid))
+            self.os_ops.kill(node_pid, signal.SIGKILL, expect_error=False)
+        except Exception:
+            # The node has already stopped
+            pass
+
+        # Check that node stopped - print only column pid without headers
+        ps_output = self.os_ops.exec_command(cmd=ps_command, shell=True, ignore_errors=True).decode('utf-8')
+        assert type(ps_output) == str  # noqa: E721
+
+        if ps_output == "":
+            eprint('Node {0} has been stopped successfully.'.format(self.name))
+            return
+
+        if ps_output == str(node_pid):
+            eprint('Failed to stop node {0}.'.format(self.name))
+            return
+
+        __class__._throw_bugcheck__unexpected_result_of_ps(
+            ps_output,
+            ps_command)
+
+    @staticmethod
+    def _throw_bugcheck__unexpected_result_of_ps(result, cmd):
+        assert type(result) == str  # noqa: E721
+        assert type(cmd) == list  # noqa: E721
+        errLines = []
+        errLines.append("[BUG CHECK] Unexpected result of command ps:")
+        errLines.append(result)
+        errLines.append("-----")
+        errLines.append("Command line is {0}".format(cmd))
+        raise RuntimeError("\n".join(errLines))
 
     def _assign_master(self, master):
         """NOTE: this is a private method!"""