Allow server-side compression for basebackup option (#3538)

The `compress` option was completely blocked for basebackup, but since
PostgreSQL 15, server-side compression is useful and works transparently
with plain format.

- Removed `compress` from blocked options list
- Added validation to allow only `--compress=server*` values (e.g.,
server-zstd, server-gzip)
- Reject client-side compression with helpful error message

Author: m4rrypro

patroni/postgresql/bootstrap.py

@@ -258,9 +258,25 @@ def basebackup(self, conn_url: str, env: Dict[str, str], options: Dict[str, Any]
         # supports additional user-supplied options, those are not validated
         maxfailures = 2
         ret = 1
-        not_allowed_options = ('pgdata', 'format', 'wal-method', 'xlog-method', 'gzip',
-                               'version', 'compress', 'dbname', 'host', 'port', 'username', 'password')
-        user_options = process_user_options('basebackup', options, not_allowed_options, logger.error)
+        not_allowed_options = ['pgdata', 'format', 'wal-method', 'xlog-method', 'gzip',
+                               'version', 'dbname', 'host', 'port', 'username', 'password']
+        pg_version = self._postgresql.config.pg_version
+        if pg_version < 150000:
+            not_allowed_options.append('compress')
+        user_options = process_user_options('basebackup', options, tuple(not_allowed_options), logger.error)
+        # Validate compress option on PG15+: only server-side compression is allowed
+        if pg_version >= 150000:
+            validated_options: List[str] = []
+            for opt in user_options:
+                if opt.startswith('--compress='):
+                    if opt.startswith('--compress=server'):
+                        validated_options.append(opt)
+                    else:
+                        logger.error('compress option for basebackup must use server-side compression '
+                                     '(e.g., server-gzip, server-zstd). Client-side compression is not allowed.')
+                else:
+                    validated_options.append(opt)
+            user_options = validated_options
         cmd = [
             self._postgresql.pgcommand("pg_basebackup"),
             "--pgdata=" + self._postgresql.data_dir,

tests/test_bootstrap.py

@@ -95,6 +95,7 @@ def test_create_replica_old_format(self, mock_cancellable_subprocess_call):
 
     @patch.object(CancellableSubprocess, 'call', Mock(return_value=0))
     @patch.object(Postgresql, 'data_directory_empty', Mock(return_value=True))
+    @patch.object(ConfigHandler, 'pg_version', PropertyMock(return_value=150000))
     def test_basebackup(self):
         with patch('patroni.postgresql.bootstrap.logger.debug') as mock_debug:
             self.p.cancellable.cancel()
@@ -108,6 +109,32 @@ def test_basebackup(self):
                 ['pg_basebackup', f'--pgdata={self.p.data_dir}', '-X', 'stream', '--dbname=', '--foo=bar'],
             )
 
+        # Test compress option: server-side compression should be allowed on PG15+ (issue #3532)
+        with patch('patroni.postgresql.bootstrap.logger.debug') as mock_debug:
+            self.p.cancellable.reset_is_cancelled()
+            self.b.basebackup("", None, {'compress': 'server-zstd'})
+            mock_debug.assert_called_with(
+                'calling: %r',
+                ['pg_basebackup', f'--pgdata={self.p.data_dir}', '-X', 'stream', '--dbname=', '--compress=server-zstd'],
+            )
+
+        # Test compress option: client-side compression should be rejected on PG15+
+        with patch('patroni.postgresql.bootstrap.logger.error') as mock_error:
+            self.p.cancellable.reset_is_cancelled()
+            self.b.basebackup("", None, {'compress': 'gzip'})
+            mock_error.assert_called_with(
+                'compress option for basebackup must use server-side compression '
+                '(e.g., server-gzip, server-zstd). Client-side compression is not allowed.'
+            )
+
+        # Test compress option: should be rejected on PG < 15
+        with patch('patroni.postgresql.bootstrap.logger.error') as mock_error, \
+                patch.object(ConfigHandler, 'pg_version', PropertyMock(return_value=140000)):
+            self.p.cancellable.reset_is_cancelled()
+            self.b.basebackup("", None, {'compress': 'server-zstd'})
+            # compress is in not_allowed_options for PG < 15, error logged via process_user_options
+            mock_error.assert_any_call('compress option for basebackup is not allowed')
+
     def test__initdb(self):
         self.assertRaises(Exception, self.b.bootstrap, {'initdb': [{'pgdata': 'bar'}]})
         self.assertRaises(Exception, self.b.bootstrap, {'initdb': [{'foo': 'bar', 1: 2}]})

tests/test_ha.py

@@ -189,6 +189,7 @@ def run_async(self, func, args=()):
     'Latest checkpoint location': '0/12345678',
     "Latest checkpoint's TimeLineID": '2'}))
 @patch.object(SlotsHandler, 'load_replication_slots', Mock(side_effect=Exception))
+@patch.object(ConfigHandler, 'pg_version', PropertyMock(return_value=180000))
 @patch.object(ConfigHandler, 'append_pg_hba', Mock())
 @patch.object(ConfigHandler, 'write_pgpass', Mock(return_value={}))
 @patch.object(ConfigHandler, 'write_recovery_conf', Mock())