# Copyright (c) 2025, PostgreSQL Global Development Group

use strict;
use warnings FATAL => 'all';

use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
use Test::More;
use List::Util qw(shuffle);


my $node = PostgreSQL::Test::Cluster->new('worker');
$node->init();
$node->append_conf(
 'postgresql.conf', qq(
io_method=worker
));

$node->start();

# Test changing the number of I/O worker processes while also evaluating the
# handling of their termination.
test_number_of_io_workers_dynamic($node);

$node->stop();

done_testing();


sub test_number_of_io_workers_dynamic
{
 my $node = shift;

 my $prev_worker_count = $node->safe_psql('postgres', 'SHOW io_workers');

 # Verify that worker count can't be set to 0
 change_number_of_io_workers($node, 0, $prev_worker_count, 1);

 # Verify that worker count can't be set to 33 (above the max)
 change_number_of_io_workers($node, 33, $prev_worker_count, 1);

 # Try changing IO workers to a random value and verify that the worker
 # count ends up as expected. Always test the min/max of workers.
 #
 # Valid range for io_workers is [1, 32]. 8 tests in total seems
 # reasonable.
 my @io_workers_range = shuffle(1 ... 32);
 foreach my $worker_count (1, 32, @io_workers_range[ 0, 6 ])
 {
  $prev_worker_count =
    change_number_of_io_workers($node, $worker_count,
   $prev_worker_count, 0);
 }
}

sub change_number_of_io_workers
{
 my $node = shift;
 my $worker_count = shift;
 my $prev_worker_count = shift;
 my $expect_failure = shift;
 my ($result, $stdout, $stderr);

 ($result, $stdout, $stderr) =
   $node->psql('postgres', "ALTER SYSTEM SET io_workers = $worker_count");
 $node->safe_psql('postgres', 'SELECT pg_reload_conf()');

 if ($expect_failure)
 {
  ok( $stderr =~
     /$worker_count is outside the valid range for parameter "io_workers"/,
   "updating number of io_workers to $worker_count failed, as expected"
  );

  return $prev_worker_count;
 }
 else
 {
  is( $node->safe_psql('postgres', 'SHOW io_workers'),
   $worker_count,
   "updating number of io_workers from $prev_worker_count to $worker_count"
  );

  check_io_worker_count($node, $worker_count);
  terminate_io_worker($node, $worker_count);
  check_io_worker_count($node, $worker_count);

  return $worker_count;
 }
}

sub terminate_io_worker
{
 my $node = shift;
 my $worker_count = shift;
 my ($pid, $ret);

 # Select a random io worker
 $pid = $node->safe_psql(
  'postgres',
  qq(SELECT pid FROM pg_stat_activity WHERE
   backend_type = 'io worker' ORDER BY RANDOM() LIMIT 1));

 # terminate IO worker with SIGINT
 is(PostgreSQL::Test::Utils::system_log('pg_ctl', 'kill', 'INT', $pid),
  0, "random io worker process signalled with INT");

 # Check that worker exits
 ok( $node->poll_query_until(
   'postgres',
   qq(SELECT COUNT(*) FROM pg_stat_activity WHERE pid = $pid), '0'),
  "random io worker process exited after signal");
}

sub check_io_worker_count
{
 my $node = shift;
 my $worker_count = shift;

 ok( $node->poll_query_until(
   'postgres',
   qq(SELECT COUNT(*) FROM pg_stat_activity WHERE backend_type = 'io worker'),
   $worker_count),
  "io worker count is $worker_count");
}