Added/Updated tests\bugs\gh_8085_test.py: Confirmed fix on intermediate snapshots: 6.0.0.321 #cc6fe45; 5.0.1.1381 #0f3cdde; 4.0.5.3086 #9d13bd3

tests/bugs/gh_8085_test.py

@@ -0,0 +1,129 @@
+#coding:utf-8
+
+"""
+ID:          issue-8085
+ISSUE:       https://github.com/FirebirdSQL/firebird/issues/8085
+TITLE:       Memory leak when executing a lot of different queries and StatementTimeout > 0
+DESCRIPTION:
+    Test launches ISQL in async mode and then checks in loop for <N_CNT> seconds value of psutil.Process( <fb_pid> )
+    where <fb_pid> is value of server PID that can be found in mon$attachments.mon$server_pid of ISQL connection.
+    This value is written in auxiliary table 'tmplog' and can be obtained from it when ISQL establishes attachment.
+    Then we collect values of memory_info().rss returned by instance of psutil.Process( <fb_pid> ) in the list,
+    see 'memo_rss_list' variable.
+    Collection of memory_info().rss value is made with interval 1 second.
+    After that we reuire ISQL process to be terminated and wait for that no more than <MAX_WAIT_FOR_ISQL_TERMINATE> seconds.
+    Finally, we evaluate differences between adjacent values from memo_rss_list.
+    Median of these differences must be <MAX_RSS_DIFFERENCE_MEDIAN> (Kb).
+    Before fix this median was about 650K.
+NOTES:
+    [17.04.2024] pzotov
+    Bug detected on 6.0.0.313 during implementation of test for gh-2388 (there is loop with ~20E6 iterations which run ES).
+    Confirmed fix on intermediate snapshots: 6.0.0.321 #cc6fe45; 5.0.1.1381 #0f3cdde; 4.0.5.3086 #9d13bd3
+"""
+
+import psutil
+import pytest
+import time
+from pathlib import Path
+import subprocess
+
+import firebird.driver
+from firebird.qa import *
+
+db = db_factory()
+act = python_act('db')
+
+N_CNT = 15
+tmp_sql = temp_file('tmp_8085.sql')
+tmp_log = temp_file('tmp_8085.log')
+
+MAX_WAIT_FOR_ISQL_BEGIN_WORK=3
+MAX_WAIT_FOR_ISQL_TERMINATE=11
+MAX_RSS_DIFFERENCE_MEDIAN = 0
+
+#--------------------------------------------------------------------
+def median(lst):
+    n = len(lst)
+    s = sorted(lst)
+    return (sum(s[n//2-1:n//2+1])/2.0, s[n//2])[n % 2] if n else None
+#--------------------------------------------------------------------
+
+@pytest.mark.version('>=4.0.5')
+def test_1(act: Action, tmp_sql: Path, tmp_log: Path, capsys):
+
+    test_sql = f"""
+        recreate table tmplog(srv_pid int);
+        insert into tmplog(srv_pid) 
+        select mon$server_pid as p
+        from mon$attachments
+        where mon$attachment_id = current_connection
+        ;
+        commit;
+        SET STATEMENT TIMEOUT 7200;
+        set term ^;
+        execute block as
+            declare res double precision;
+        begin
+            while (1=1) do
+            begin
+                execute statement 'select ' || rand() || ' from rdb$database' into res;
+            end
+        end
+        ^
+    """
+    with open(tmp_sql, 'w') as f:
+        f.write(test_sql)
+
+    memo_rss_list = []
+    with act.db.connect() as con:
+        with open(tmp_log, 'w') as f:
+            try:
+                p_handed_isql = subprocess.Popen( [act.vars['isql'], '-i', str(tmp_sql),
+                                                  '-user', act.db.user,
+                                                  '-password', act.db.password, act.db.dsn],
+                                                  stdout = f,
+                                                  stderr = subprocess.STDOUT
+                                                )
+
+                # Let ISQL time to establish connection and start infinite loop with ES:
+                time.sleep(MAX_WAIT_FOR_ISQL_BEGIN_WORK)
+
+                cur = con.cursor()
+                cur.execute('select srv_pid from tmplog')
+                fb_srv = psutil.Process( int(cur.fetchone()[0]) )
+
+                for i in range(N_CNT):
+                    memo_rss_list.append(int(fb_srv.memory_info().rss / 1024))
+                    time.sleep(1)
+
+            finally:
+                p_handed_isql.terminate()
+
+            p_handed_isql.wait(MAX_WAIT_FOR_ISQL_TERMINATE)
+            if p_handed_isql.poll() is None:
+                print(f'ISQL process WAS NOT terminated in {MAX_WAIT_FOR_ISQL_TERMINATE} second(s).!')
+            else:
+                print(f'ISQL process terminated.')
+        
+        memo_rss_diff = []
+        for i,x in enumerate(memo_rss_list):
+            if i >= 1:
+                memo_rss_diff.append(x - memo_rss_list[i-1])
+
+    memo_rss_diff_median = median(memo_rss_diff)
+    median_acceptable_msg = 'Memory differences median acceptable.'
+    if memo_rss_diff_median <= MAX_RSS_DIFFERENCE_MEDIAN:
+        print(median_acceptable_msg)
+    else:
+        print(f'Memory LEAK detected. Median of differences: {memo_rss_diff_median} Kb - is UNACCEPTABLE. Check memo_rss_diff:')
+        for p in memo_rss_diff:
+            print('%6d' % p)
+
+    expected_stdout = f"""
+        ISQL process terminated.
+        {median_acceptable_msg}
+    """
+
+    act.expected_stdout = expected_stdout
+    act.stdout = capsys.readouterr().out
+    assert act.clean_stdout == act.clean_expected_stdout