#include <unistd.h>

Include dependency graph for pg_regress.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	_stringlist

Macros
#define	PID_TYPE pid_t

#define	INVALID_PID (-1)

Typedefs
typedef struct _stringlist	_stringlist

typedef void(*	init_function) (int argc, char **argv)

typedef PID_TYPE(*	test_start_function) (const char testname, _stringlist resultfiles, _stringlist expectfiles, _stringlist *tags)

typedef void(*	postprocess_result_function) (const char *filename)

Functions
int	regression_main (int argc, char *argv[], init_function ifunc, test_start_function startfunc, postprocess_result_function postfunc)

void	add_stringlist_item (_stringlist *listhead, const char str)

PID_TYPE	spawn_process (const char *cmdline)

bool	file_exists (const char *file)

Variables
char *	bindir

char *	libdir

char *	datadir

char *	host_platform

_stringlist *	dblist

bool	debug

char *	inputdir

char *	outputdir

char *	expecteddir

char *	launcher

const char *	basic_diff_opts

const char *	pretty_diff_opts

Macro Definition Documentation

◆ INVALID_PID

#define INVALID_PID (-1)

Definition at line 15 of file pg_regress.h.

◆ PID_TYPE

#define PID_TYPE pid_t

Definition at line 14 of file pg_regress.h.

Typedef Documentation

◆ _stringlist

typedef struct _stringlist _stringlist

◆ init_function

typedef void(* init_function) (int argc, char **argv)

Definition at line 33 of file pg_regress.h.

◆ postprocess_result_function

typedef void(* postprocess_result_function) (const char *filename)

Definition at line 42 of file pg_regress.h.

◆ test_start_function

typedef PID_TYPE(* test_start_function) (const char *testname, _stringlist **resultfiles, _stringlist **expectfiles, _stringlist **tags)

Definition at line 36 of file pg_regress.h.

Function Documentation

◆ add_stringlist_item()

void add_stringlist_item	(	_stringlist **	listhead,
		const char *	str
	)

Definition at line 202 of file pg_regress.c.

{
    _stringlist *newentry = pg_malloc_object(_stringlist);
    _stringlist *oldentry;
 
    newentry->str = pg_strdup(str);
    newentry->next = NULL;
    if (*listhead == NULL)
        *listhead = newentry;
    else
    {
        for (oldentry = *listhead; oldentry->next; oldentry = oldentry->next)
             /* skip */ ;
        oldentry->next = newentry;
    }
}

References fb(), pg_malloc_object, pg_strdup(), _stringlist::str, and str.

Referenced by regression_main(), and split_to_stringlist().

◆ file_exists()

bool file_exists ( const char * file )

Definition at line 1318 of file pg_regress.c.

{
    FILE       *f = fopen(file, "r");
 
    if (!f)
        return false;
    fclose(f);
    return true;
}

References fb().

Referenced by isolation_start_test(), psql_start_test(), and results_differ().

◆ regression_main()

int regression_main	(	int	argc,
		char *	argv[],
		init_function	ifunc,
		test_start_function	startfunc,
		postprocess_result_function	postfunc
	)

Definition at line 2140 of file pg_regress.c.

{
    static struct option long_options[] = {
        {"help", no_argument, NULL, 'h'},
        {"version", no_argument, NULL, 'V'},
        {"dbname", required_argument, NULL, 1},
        {"debug", no_argument, NULL, 2},
        {"inputdir", required_argument, NULL, 3},
        {"max-connections", required_argument, NULL, 5},
        {"encoding", required_argument, NULL, 6},
        {"outputdir", required_argument, NULL, 7},
        {"schedule", required_argument, NULL, 8},
        {"temp-instance", required_argument, NULL, 9},
        {"no-locale", no_argument, NULL, 10},
        {"host", required_argument, NULL, 13},
        {"port", required_argument, NULL, 14},
        {"user", required_argument, NULL, 15},
        {"bindir", required_argument, NULL, 16},
        {"dlpath", required_argument, NULL, 17},
        {"create-role", required_argument, NULL, 18},
        {"temp-config", required_argument, NULL, 19},
        {"use-existing", no_argument, NULL, 20},
        {"launcher", required_argument, NULL, 21},
        {"load-extension", required_argument, NULL, 22},
        {"config-auth", required_argument, NULL, 24},
        {"max-concurrent-tests", required_argument, NULL, 25},
        {"expecteddir", required_argument, NULL, 26},
        {NULL, 0, NULL, 0}
    };
 
    bool        use_unix_sockets;
    _stringlist *sl;
    int         c;
    int         i;
    int         option_index;
    char        buf[MAXPGPATH * 4];
 
    pg_logging_init(argv[0]);
    progname = get_progname(argv[0]);
    set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_regress"));
 
    pg_initialize_timing();
 
    get_restricted_token();
 
    atexit(stop_postmaster);
 
#if defined(WIN32)
 
    /*
     * We don't use Unix-domain sockets on Windows by default (see comment at
     * remove_temp() for a reason).  Override at your own risk.
     */
    use_unix_sockets = getenv("PG_TEST_USE_UNIX_SOCKETS") ? true : false;
#else
    use_unix_sockets = true;
#endif
 
    if (!use_unix_sockets)
        hostname = "localhost";
 
    /*
     * We call the initialization function here because that way we can set
     * default parameters and let them be overwritten by the commandline.
     */
    ifunc(argc, argv);
 
    if (getenv("PG_REGRESS_DIFF_OPTS"))
        pretty_diff_opts = getenv("PG_REGRESS_DIFF_OPTS");
 
    while ((c = getopt_long(argc, argv, "hV", long_options, &option_index)) != -1)
    {
        switch (c)
        {
            case 'h':
                help();
                exit(0);
            case 'V':
                puts("pg_regress (PostgreSQL) " PG_VERSION);
                exit(0);
            case 1:
 
                /*
                 * If a default database was specified, we need to remove it
                 * before we add the specified one.
                 */
                free_stringlist(&dblist);
                split_to_stringlist(optarg, ",", &dblist);
                break;
            case 2:
                debug = true;
                break;
            case 3:
                inputdir = pg_strdup(optarg);
                break;
            case 5:
                max_connections = atoi(optarg);
                break;
            case 6:
                encoding = pg_strdup(optarg);
                break;
            case 7:
                outputdir = pg_strdup(optarg);
                break;
            case 8:
                add_stringlist_item(&schedulelist, optarg);
                break;
            case 9:
                temp_instance = make_absolute_path(optarg);
                break;
            case 10:
                nolocale = true;
                break;
            case 13:
                hostname = pg_strdup(optarg);
                break;
            case 14:
                port = atoi(optarg);
                port_specified_by_user = true;
                break;
            case 15:
                user = pg_strdup(optarg);
                break;
            case 16:
                /* "--bindir=" means to use PATH */
                if (strlen(optarg))
                    bindir = pg_strdup(optarg);
                else
                    bindir = NULL;
                break;
            case 17:
                dlpath = pg_strdup(optarg);
                break;
            case 18:
                split_to_stringlist(optarg, ",", &extraroles);
                break;
            case 19:
                add_stringlist_item(&temp_configs, optarg);
                break;
            case 20:
                use_existing = true;
                break;
            case 21:
                launcher = pg_strdup(optarg);
                break;
            case 22:
                add_stringlist_item(&loadextension, optarg);
                break;
            case 24:
                config_auth_datadir = pg_strdup(optarg);
                break;
            case 25:
                max_concurrent_tests = atoi(optarg);
                break;
            case 26:
                expecteddir = pg_strdup(optarg);
                break;
            default:
                /* getopt_long already emitted a complaint */
                pg_log_error_hint("Try \"%s --help\" for more information.",
                                  progname);
                exit(2);
        }
    }
 
    /*
     * if we still have arguments, they are extra tests to run
     */
    while (argc - optind >= 1)
    {
        add_stringlist_item(&extra_tests, argv[optind]);
        optind++;
    }
 
    /*
     * We must have a database to run the tests in; either a default name, or
     * one supplied by the --dbname switch.
     */
    if (!(dblist && dblist->str && dblist->str[0]))
    {
        bail("no database name was specified");
    }
 
    if (config_auth_datadir)
    {
#ifdef ENABLE_SSPI
        if (!use_unix_sockets)
            config_sspi_auth(config_auth_datadir, user);
#endif
        exit(0);
    }
 
    if (temp_instance && !port_specified_by_user)
 
        /*
         * To reduce chances of interference with parallel installations, use
         * a port number starting in the private range (49152-65535)
         * calculated from the version number.  This aids non-Unix socket mode
         * systems; elsewhere, the use of a private socket directory already
         * prevents interference.
         */
        port = 0xC000 | (PG_VERSION_NUM & 0x3FFF);
 
    inputdir = make_absolute_path(inputdir);
    outputdir = make_absolute_path(outputdir);
    expecteddir = make_absolute_path(expecteddir);
    dlpath = make_absolute_path(dlpath);
 
    /*
     * Initialization
     */
    open_result_files();
 
    initialize_environment();
 
#if defined(HAVE_GETRLIMIT)
    unlimit_core_size();
#endif
 
    if (temp_instance)
    {
        StringInfoData cmd;
        FILE       *pg_conf;
        const char *env_wait;
        int         wait_seconds;
        const char *initdb_template_dir;
        const char *keywords[4];
        const char *values[4];
        PGPing      rv;
        const char *initdb_extra_opts_env;
 
        /*
         * Prepare the temp instance
         */
 
        if (directory_exists(temp_instance))
        {
            if (!rmtree(temp_instance, true))
            {
                bail("could not remove temp instance \"%s\"", temp_instance);
            }
        }
 
        /* make the temp instance top directory */
        make_directory(temp_instance);
 
        /* and a directory for log files */
        snprintf(buf, sizeof(buf), "%s/log", outputdir);
        if (!directory_exists(buf))
            make_directory(buf);
 
        initdb_extra_opts_env = getenv("PG_TEST_INITDB_EXTRA_OPTS");
 
        initStringInfo(&cmd);
 
        /*
         * Create data directory.
         *
         * If available, use a previously initdb'd cluster as a template by
         * copying it. For a lot of tests, that's substantially cheaper.
         *
         * There's very similar code in Cluster.pm, but we can't easily de
         * duplicate it until we require perl at build time.
         */
        initdb_template_dir = getenv("INITDB_TEMPLATE");
        if (initdb_template_dir == NULL || nolocale || debug || initdb_extra_opts_env)
        {
            note("initializing database system by running initdb");
 
            appendStringInfo(&cmd,
                             "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync",
                             bindir ? bindir : "",
                             bindir ? "/" : "",
                             temp_instance);
            if (debug)
                appendStringInfoString(&cmd, " --debug");
            if (nolocale)
                appendStringInfoString(&cmd, " --no-locale");
            if (initdb_extra_opts_env)
                appendStringInfo(&cmd, " %s", initdb_extra_opts_env);
            appendStringInfo(&cmd, " > \"%s/log/initdb.log\" 2>&1", outputdir);
            fflush(NULL);
            if (system(cmd.data))
            {
                bail("initdb failed\n"
                     "# Examine \"%s/log/initdb.log\" for the reason.\n"
                     "# Command was: %s",
                     outputdir, cmd.data);
            }
        }
        else
        {
#ifndef WIN32
            const char *copycmd = "cp -RPp \"%s\" \"%s/data\"";
            int         expected_exitcode = 0;
#else
            const char *copycmd = "robocopy /E /NJS /NJH /NFL /NDL /NP \"%s\" \"%s/data\"";
            int         expected_exitcode = 1;  /* 1 denotes files were copied */
#endif
 
            note("initializing database system by copying initdb template");
 
            appendStringInfo(&cmd,
                             copycmd,
                             initdb_template_dir,
                             temp_instance);
            appendStringInfo(&cmd, " > \"%s/log/initdb.log\" 2>&1", outputdir);
            fflush(NULL);
            if (system(cmd.data) != expected_exitcode)
            {
                bail("copying of initdb template failed\n"
                     "# Examine \"%s/log/initdb.log\" for the reason.\n"
                     "# Command was: %s",
                     outputdir, cmd.data);
            }
        }
 
        pfree(cmd.data);
 
        /*
         * Adjust the default postgresql.conf for regression testing. The user
         * can specify a file to be appended; in any case we expand logging
         * and set max_prepared_transactions to enable testing of prepared
         * xacts.  (Note: to reduce the probability of unexpected shmmax
         * failures, don't set max_prepared_transactions any higher than
         * actually needed by the prepared_xacts regression test.)
         */
        snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_instance);
        pg_conf = fopen(buf, "a");
        if (pg_conf == NULL)
            bail("could not open \"%s\" for adding extra config: %m", buf);
 
        fputs("\n# Configuration added by pg_regress\n\n", pg_conf);
        fputs("log_autovacuum_min_duration = 0\n", pg_conf);
        fputs("log_autoanalyze_min_duration = 0\n", pg_conf);
        fputs("log_checkpoints = on\n", pg_conf);
        fputs("log_line_prefix = '%m %b[%p] %q%a '\n", pg_conf);
        fputs("log_lock_waits = on\n", pg_conf);
        fputs("log_temp_files = 128kB\n", pg_conf);
        fputs("max_prepared_transactions = 2\n", pg_conf);
 
        for (sl = temp_configs; sl != NULL; sl = sl->next)
        {
            char       *temp_config = sl->str;
            FILE       *extra_conf;
            char        line_buf[1024];
 
            extra_conf = fopen(temp_config, "r");
            if (extra_conf == NULL)
            {
                bail("could not open \"%s\" to read extra config: %m",
                     temp_config);
            }
            while (fgets(line_buf, sizeof(line_buf), extra_conf) != NULL)
                fputs(line_buf, pg_conf);
            fclose(extra_conf);
        }
 
        fclose(pg_conf);
 
#ifdef ENABLE_SSPI
        if (!use_unix_sockets)
        {
            /*
             * Since we successfully used the same buffer for the much-longer
             * "initdb" command, this can't truncate.
             */
            snprintf(buf, sizeof(buf), "%s/data", temp_instance);
            config_sspi_auth(buf, NULL);
        }
#endif
 
        /*
         * Prepare the connection params for checking the state of the server
         * before starting the tests.
         */
        sprintf(portstr, "%d", port);
        keywords[0] = "dbname";
        values[0] = "postgres";
        keywords[1] = "port";
        values[1] = portstr;
        keywords[2] = "host";
        values[2] = hostname ? hostname : sockdir;
        keywords[3] = NULL;
        values[3] = NULL;
 
        /*
         * Check if there is a postmaster running already.
         */
        for (i = 0; i < 16; i++)
        {
            rv = PQpingParams(keywords, values, 1);
 
            if (rv == PQPING_OK)
            {
                if (port_specified_by_user || i == 15)
                {
                    note("port %d apparently in use", port);
                    if (!port_specified_by_user)
                        note("could not determine an available port");
                    bail("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers.");
                }
 
                note("port %d apparently in use, trying %d", port, port + 1);
                port++;
                sprintf(portstr, "%d", port);
                setenv("PGPORT", portstr, 1);
            }
            else
                break;
        }
 
        /*
         * Start the temp postmaster
         */
        snprintf(buf, sizeof(buf),
                 "\"%s%spostgres\" -D \"%s/data\" -F%s "
                 "-c \"listen_addresses=%s\" -k \"%s\" "
                 "> \"%s/log/postmaster.log\" 2>&1",
                 bindir ? bindir : "",
                 bindir ? "/" : "",
                 temp_instance, debug ? " -d 5" : "",
                 hostname ? hostname : "", sockdir ? sockdir : "",
                 outputdir);
        postmaster_pid = spawn_process(buf);
        if (postmaster_pid == INVALID_PID)
            bail("could not spawn postmaster: %m");
 
        /*
         * Wait till postmaster is able to accept connections; normally takes
         * only a fraction of a second or so, but Cygwin is reportedly *much*
         * slower, and test builds using Valgrind or similar tools might be
         * too.  Hence, allow the default timeout of 60 seconds to be
         * overridden from the PGCTLTIMEOUT environment variable.
         */
        env_wait = getenv("PGCTLTIMEOUT");
        if (env_wait != NULL)
        {
            wait_seconds = atoi(env_wait);
            if (wait_seconds <= 0)
                wait_seconds = 60;
        }
        else
            wait_seconds = 60;
 
        for (i = 0; i < wait_seconds * WAIT_TICKS_PER_SECOND; i++)
        {
            /*
             * It's fairly unlikely that the server is responding immediately
             * so we start with sleeping before checking instead of the other
             * way around.
             */
            pg_usleep(1000000L / WAIT_TICKS_PER_SECOND);
 
            rv = PQpingParams(keywords, values, 1);
 
            /* Done if the server is running and accepts connections */
            if (rv == PQPING_OK)
                break;
 
            if (rv == PQPING_NO_ATTEMPT)
                bail("attempting to connect to postmaster failed");
 
            /*
             * Fail immediately if postmaster has exited
             */
#ifndef WIN32
            if (waitpid(postmaster_pid, NULL, WNOHANG) == postmaster_pid)
#else
            if (WaitForSingleObject(postmaster_pid, 0) == WAIT_OBJECT_0)
#endif
            {
                bail("postmaster failed, examine \"%s/log/postmaster.log\" for the reason",
                     outputdir);
            }
        }
        if (i >= wait_seconds * WAIT_TICKS_PER_SECOND)
        {
            diag("postmaster did not respond within %d seconds, examine \"%s/log/postmaster.log\" for the reason",
                 wait_seconds, outputdir);
 
            /*
             * If we get here, the postmaster is probably wedged somewhere in
             * startup.  Try to kill it ungracefully rather than leaving a
             * stuck postmaster that might interfere with subsequent test
             * attempts.
             */
#ifndef WIN32
            if (kill(postmaster_pid, SIGKILL) != 0 && errno != ESRCH)
                bail("could not kill failed postmaster: %m");
#else
            if (TerminateProcess(postmaster_pid, 255) == 0)
                bail("could not kill failed postmaster: error code %lu",
                     GetLastError());
#endif
            bail("postmaster failed");
        }
 
        postmaster_running = true;
 
#ifdef _WIN64
/* need a series of two casts to convert HANDLE without compiler warning */
#define ULONGPID(x) (unsigned long) (unsigned long long) (x)
#else
#define ULONGPID(x) (unsigned long) (x)
#endif
        note("using temp instance on port %d with PID %lu",
             port, ULONGPID(postmaster_pid));
    }
    else
    {
        /*
         * Using an existing installation, so may need to get rid of
         * pre-existing database(s) and role(s)
         */
        if (!use_existing)
        {
            for (sl = dblist; sl; sl = sl->next)
                drop_database_if_exists(sl->str);
            for (sl = extraroles; sl; sl = sl->next)
                drop_role_if_exists(sl->str);
        }
    }
 
    /*
     * Create the test database(s) and role(s)
     */
    if (!use_existing)
    {
        for (sl = dblist; sl; sl = sl->next)
            create_database(sl->str);
        for (sl = extraroles; sl; sl = sl->next)
            create_role(sl->str, dblist);
    }
 
    /*
     * Ready to run the tests
     */
    for (sl = schedulelist; sl != NULL; sl = sl->next)
    {
        run_schedule(sl->str, startfunc, postfunc);
    }
 
    for (sl = extra_tests; sl != NULL; sl = sl->next)
    {
        run_single_test(sl->str, startfunc, postfunc);
    }
 
    /*
     * Shut down temp installation's postmaster
     */
    if (temp_instance)
    {
        stop_postmaster();
    }
 
    /*
     * If there were no errors, remove the temp instance immediately to
     * conserve disk space.  (If there were errors, we leave the instance in
     * place for possible manual investigation.)
     */
    if (temp_instance && fail_count == 0)
    {
        if (!rmtree(temp_instance, true))
            diag("could not remove temp instance \"%s\"",
                 temp_instance);
    }
 
    /*
     * Emit a TAP compliant Plan
     */
    plan(fail_count + success_count);
 
    /*
     * Emit nice-looking summary message
     */
    if (fail_count == 0)
        note("All %d tests passed.", success_count);
    else
        diag("%d of %d tests failed.", fail_count, success_count + fail_count);
 
    if (file_size(difffilename) > 0)
    {
        diag("The differences that caused some tests to fail can be viewed in the file \"%s\".",
             difffilename);
        diag("A copy of the test summary that you see above is saved in the file \"%s\".",
             logfilename);
    }
    else
    {
        unlink(difffilename);
        unlink(logfilename);
    }
 
    fclose(logfile);
    logfile = NULL;
 
    if (fail_count != 0)
        exit(1);
 
    return 0;
}

References add_stringlist_item(), appendStringInfo(), appendStringInfoString(), bail, bindir, buf, config_auth_datadir, create_database(), create_role(), StringInfoData::data, dblist, debug, diag, difffilename, directory_exists(), dlpath, drop_database_if_exists(), drop_role_if_exists(), encoding, expecteddir, extra_tests, extraroles, fail_count, fb(), file_size(), free_stringlist(), get_progname(), get_restricted_token(), getopt_long(), help(), hostname, i, initialize_environment(), initStringInfo(), inputdir, INVALID_PID, keywords, kill, launcher, loadextension, logfile, logfilename, make_absolute_path(), make_directory(), max_concurrent_tests, max_connections, MAXPGPATH, _stringlist::next, no_argument, nolocale, note, open_result_files(), optarg, optind, outputdir, pfree(), pg_initialize_timing(), pg_log_error_hint, pg_logging_init(), pg_strdup(), PG_TEXTDOMAIN, pg_usleep(), plan, port, port_specified_by_user, portstr, postmaster_pid, postmaster_running, PQPING_NO_ATTEMPT, PQPING_OK, PQpingParams(), pretty_diff_opts, progname, required_argument, rmtree(), run_schedule(), run_single_test(), schedulelist, set_pglocale_pgservice(), setenv, SIGKILL, snprintf, sockdir, spawn_process(), split_to_stringlist(), sprintf, stop_postmaster(), _stringlist::str, success_count, temp_configs, temp_instance, true, ULONGPID, unlimit_core_size(), use_existing, user, values, wait_seconds, and WAIT_TICKS_PER_SECOND.

Referenced by main().

◆ spawn_process()

PID_TYPE spawn_process ( const char * cmdline )

Definition at line 1215 of file pg_regress.c.

{
#ifndef WIN32
    pid_t       pid;
 
    /*
     * Must flush I/O buffers before fork.
     */
    fflush(NULL);
 
#ifdef EXEC_BACKEND
    pg_disable_aslr();
#endif
 
    pid = fork();
    if (pid == -1)
    {
        bail("could not fork: %m");
    }
    if (pid == 0)
    {
        /*
         * In child
         *
         * Instead of using system(), exec the shell directly, and tell it to
         * "exec" the command too.  This saves two useless processes per
         * parallel test case.
         */
        char       *cmdline2;
 
        cmdline2 = psprintf("exec %s", cmdline);
        execl(shellprog, shellprog, "-c", cmdline2, (char *) NULL);
        /* Not using the normal bail() here as we want _exit */
        bail_noatexit("could not exec \"%s\": %m", shellprog);
    }
    /* in parent */
    return pid;
#else
    PROCESS_INFORMATION pi;
    char       *cmdline2;
    const char *comspec;
 
    /* Find CMD.EXE location using COMSPEC, if it's set */
    comspec = getenv("COMSPEC");
    if (comspec == NULL)
        comspec = "CMD";
 
    memset(&pi, 0, sizeof(pi));
    cmdline2 = psprintf("\"%s\" /c \"%s\"", comspec, cmdline);
 
    if (!CreateRestrictedProcess(cmdline2, &pi))
        exit(2);
 
    CloseHandle(pi.hThread);
    return pi.hProcess;
#endif
}