Feb 28, 2025 · Feb 28, 2025
diff --git a/testgres/node.py b/testgres/node.py
        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!"""
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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!"""
Expand Down