PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
pg_regress.h File Reference
#include <unistd.h>
Include dependency graph for pg_regress.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  _stringlist
 

Macros

#define PID_TYPE   pid_t
 
#define INVALID_PID   (-1)
 

Typedefs

typedef struct _stringlist _stringlist
 
typedef PID_TYPE(* test_function )(const char *, _stringlist **, _stringlist **, _stringlist **)
 
typedef void(* init_function )(int argc, char **argv)
 

Functions

int regression_main (int argc, char *argv[], init_function ifunc, test_function tfunc)
 
void add_stringlist_item (_stringlist **listhead, const char *str)
 
PID_TYPE spawn_process (const char *cmdline)
 
void replace_string (char *string, char *replace, char *replacement)
 
bool file_exists (const char *file)
 

Variables

char * bindir
 
char * libdir
 
char * datadir
 
char * host_platform
 
_stringlistdblist
 
bool debug
 
char * inputdir
 
char * outputdir
 
char * launcher
 
const char * basic_diff_opts
 
const char * pretty_diff_opts
 

Macro Definition Documentation

#define INVALID_PID   (-1)
#define PID_TYPE   pid_t

Typedef Documentation

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

Definition at line 32 of file pg_regress.h.

typedef PID_TYPE(* test_function)(const char *, _stringlist **, _stringlist **, _stringlist **)

Definition at line 28 of file pg_regress.h.

Function Documentation

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

Definition at line 155 of file pg_regress.c.

References _stringlist::next, pg_malloc(), pg_strdup(), and _stringlist::str.

Referenced by ecpg_start_test(), isolation_init(), isolation_start_test(), psql_init(), psql_start_test(), regression_main(), run_schedule(), and split_to_stringlist().

156 {
157  _stringlist *newentry = pg_malloc(sizeof(_stringlist));
158  _stringlist *oldentry;
159 
160  newentry->str = pg_strdup(str);
161  newentry->next = NULL;
162  if (*listhead == NULL)
163  *listhead = newentry;
164  else
165  {
166  for (oldentry = *listhead; oldentry->next; oldentry = oldentry->next)
167  /* skip */ ;
168  oldentry->next = newentry;
169  }
170 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
char * str
Definition: pg_regress.h:24
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
struct _stringlist * next
Definition: pg_regress.h:25
bool file_exists ( const char *  file)

Definition at line 1231 of file pg_regress.c.

Referenced by results_differ().

1232 {
1233  FILE *f = fopen(file, "r");
1234 
1235  if (!f)
1236  return false;
1237  fclose(f);
1238  return true;
1239 }
int regression_main ( int  argc,
char *  argv[],
init_function  ifunc,
test_function  tfunc 
)

Definition at line 2050 of file pg_regress.c.

References _, add_stringlist_item(), bindir, buf, config_auth_datadir, create_database(), create_role(), debug, DEVNULL, difffilename, directory_exists(), dlpath, doputenv(), drop_database_if_exists(), drop_role_if_exists(), encoding, fail_count, fail_ignore_count, file_size(), free_stringlist(), get_progname(), getopt_long(), header(), help(), hostname, i, initialize_environment(), inputdir, INVALID_PID, launcher, logfile, logfilename, make_absolute_path(), make_directory(), max_concurrent_tests, max_connections, MAXPGPATH, _stringlist::next, no_argument, nolocale, open_result_files(), optarg, optind, outputdir, pg_strdup(), PG_TEXTDOMAIN, pg_usleep(), port, port_specified_by_user, postmaster_pid, postmaster_running, pretty_diff_opts, progname, required_argument, rmtree(), run_schedule(), run_single_test(), set_pglocale_pgservice(), SIGKILL, snprintf(), sockdir, spawn_process(), split_to_stringlist(), stop_postmaster(), _stringlist::str, strerror(), success_count, temp_instance, ULONGPID, use_existing, user, and wait_seconds.

Referenced by main().

2051 {
2052  static struct option long_options[] = {
2053  {"help", no_argument, NULL, 'h'},
2054  {"version", no_argument, NULL, 'V'},
2055  {"dbname", required_argument, NULL, 1},
2056  {"debug", no_argument, NULL, 2},
2057  {"inputdir", required_argument, NULL, 3},
2058  {"load-language", required_argument, NULL, 4},
2059  {"max-connections", required_argument, NULL, 5},
2060  {"encoding", required_argument, NULL, 6},
2061  {"outputdir", required_argument, NULL, 7},
2062  {"schedule", required_argument, NULL, 8},
2063  {"temp-instance", required_argument, NULL, 9},
2064  {"no-locale", no_argument, NULL, 10},
2065  {"host", required_argument, NULL, 13},
2066  {"port", required_argument, NULL, 14},
2067  {"user", required_argument, NULL, 15},
2068  {"bindir", required_argument, NULL, 16},
2069  {"dlpath", required_argument, NULL, 17},
2070  {"create-role", required_argument, NULL, 18},
2071  {"temp-config", required_argument, NULL, 19},
2072  {"use-existing", no_argument, NULL, 20},
2073  {"launcher", required_argument, NULL, 21},
2074  {"load-extension", required_argument, NULL, 22},
2075  {"config-auth", required_argument, NULL, 24},
2076  {"max-concurrent-tests", required_argument, NULL, 25},
2077  {NULL, 0, NULL, 0}
2078  };
2079 
2080  _stringlist *sl;
2081  int c;
2082  int i;
2083  int option_index;
2084  char buf[MAXPGPATH * 4];
2085  char buf2[MAXPGPATH * 4];
2086 
2087  progname = get_progname(argv[0]);
2088  set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_regress"));
2089 
2090  atexit(stop_postmaster);
2091 
2092 #ifndef HAVE_UNIX_SOCKETS
2093  /* no unix domain sockets available, so change default */
2094  hostname = "localhost";
2095 #endif
2096 
2097  /*
2098  * We call the initialization function here because that way we can set
2099  * default parameters and let them be overwritten by the commandline.
2100  */
2101  ifunc(argc, argv);
2102 
2103  if (getenv("PG_REGRESS_DIFF_OPTS"))
2104  pretty_diff_opts = getenv("PG_REGRESS_DIFF_OPTS");
2105 
2106  while ((c = getopt_long(argc, argv, "hV", long_options, &option_index)) != -1)
2107  {
2108  switch (c)
2109  {
2110  case 'h':
2111  help();
2112  exit(0);
2113  case 'V':
2114  puts("pg_regress (PostgreSQL) " PG_VERSION);
2115  exit(0);
2116  case 1:
2117 
2118  /*
2119  * If a default database was specified, we need to remove it
2120  * before we add the specified one.
2121  */
2124  break;
2125  case 2:
2126  debug = true;
2127  break;
2128  case 3:
2130  break;
2131  case 4:
2133  break;
2134  case 5:
2135  max_connections = atoi(optarg);
2136  break;
2137  case 6:
2139  break;
2140  case 7:
2142  break;
2143  case 8:
2145  break;
2146  case 9:
2148  break;
2149  case 10:
2150  nolocale = true;
2151  break;
2152  case 13:
2154  break;
2155  case 14:
2156  port = atoi(optarg);
2157  port_specified_by_user = true;
2158  break;
2159  case 15:
2160  user = pg_strdup(optarg);
2161  break;
2162  case 16:
2163  /* "--bindir=" means to use PATH */
2164  if (strlen(optarg))
2165  bindir = pg_strdup(optarg);
2166  else
2167  bindir = NULL;
2168  break;
2169  case 17:
2170  dlpath = pg_strdup(optarg);
2171  break;
2172  case 18:
2174  break;
2175  case 19:
2177  break;
2178  case 20:
2179  use_existing = true;
2180  break;
2181  case 21:
2183  break;
2184  case 22:
2186  break;
2187  case 24:
2189  break;
2190  case 25:
2191  max_concurrent_tests = atoi(optarg);
2192  break;
2193  default:
2194  /* getopt_long already emitted a complaint */
2195  fprintf(stderr, _("\nTry \"%s -h\" for more information.\n"),
2196  progname);
2197  exit(2);
2198  }
2199  }
2200 
2201  /*
2202  * if we still have arguments, they are extra tests to run
2203  */
2204  while (argc - optind >= 1)
2205  {
2207  optind++;
2208  }
2209 
2210  if (config_auth_datadir)
2211  {
2212 #ifdef ENABLE_SSPI
2213  config_sspi_auth(config_auth_datadir);
2214 #endif
2215  exit(0);
2216  }
2217 
2219 
2220  /*
2221  * To reduce chances of interference with parallel installations, use
2222  * a port number starting in the private range (49152-65535)
2223  * calculated from the version number. This aids !HAVE_UNIX_SOCKETS
2224  * systems; elsewhere, the use of a private socket directory already
2225  * prevents interference.
2226  */
2227  port = 0xC000 | (PG_VERSION_NUM & 0x3FFF);
2228 
2232 
2233  /*
2234  * Initialization
2235  */
2237 
2239 
2240 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
2241  unlimit_core_size();
2242 #endif
2243 
2244  if (temp_instance)
2245  {
2246  FILE *pg_conf;
2247  const char *env_wait;
2248  int wait_seconds;
2249 
2250  /*
2251  * Prepare the temp instance
2252  */
2253 
2255  {
2256  header(_("removing existing temp instance"));
2257  if (!rmtree(temp_instance, true))
2258  {
2259  fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
2261  exit(2);
2262  }
2263  }
2264 
2265  header(_("creating temporary instance"));
2266 
2267  /* make the temp instance top directory */
2269 
2270  /* and a directory for log files */
2271  snprintf(buf, sizeof(buf), "%s/log", outputdir);
2272  if (!directory_exists(buf))
2273  make_directory(buf);
2274 
2275  /* initdb */
2276  header(_("initializing database system"));
2277  snprintf(buf, sizeof(buf),
2278  "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync%s%s > \"%s/log/initdb.log\" 2>&1",
2279  bindir ? bindir : "",
2280  bindir ? "/" : "",
2281  temp_instance,
2282  debug ? " --debug" : "",
2283  nolocale ? " --no-locale" : "",
2284  outputdir);
2285  if (system(buf))
2286  {
2287  fprintf(stderr, _("\n%s: initdb failed\nExamine %s/log/initdb.log for the reason.\nCommand was: %s\n"), progname, outputdir, buf);
2288  exit(2);
2289  }
2290 
2291  /*
2292  * Adjust the default postgresql.conf for regression testing. The user
2293  * can specify a file to be appended; in any case we expand logging
2294  * and set max_prepared_transactions to enable testing of prepared
2295  * xacts. (Note: to reduce the probability of unexpected shmmax
2296  * failures, don't set max_prepared_transactions any higher than
2297  * actually needed by the prepared_xacts regression test.)
2298  */
2299  snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_instance);
2300  pg_conf = fopen(buf, "a");
2301  if (pg_conf == NULL)
2302  {
2303  fprintf(stderr, _("\n%s: could not open \"%s\" for adding extra config: %s\n"), progname, buf, strerror(errno));
2304  exit(2);
2305  }
2306  fputs("\n# Configuration added by pg_regress\n\n", pg_conf);
2307  fputs("log_autovacuum_min_duration = 0\n", pg_conf);
2308  fputs("log_checkpoints = on\n", pg_conf);
2309  fputs("log_line_prefix = '%m [%p] %q%a '\n", pg_conf);
2310  fputs("log_lock_waits = on\n", pg_conf);
2311  fputs("log_temp_files = 128kB\n", pg_conf);
2312  fputs("max_prepared_transactions = 2\n", pg_conf);
2313 
2314  for (sl = temp_configs; sl != NULL; sl = sl->next)
2315  {
2316  char *temp_config = sl->str;
2317  FILE *extra_conf;
2318  char line_buf[1024];
2319 
2320  extra_conf = fopen(temp_config, "r");
2321  if (extra_conf == NULL)
2322  {
2323  fprintf(stderr, _("\n%s: could not open \"%s\" to read extra config: %s\n"), progname, temp_config, strerror(errno));
2324  exit(2);
2325  }
2326  while (fgets(line_buf, sizeof(line_buf), extra_conf) != NULL)
2327  fputs(line_buf, pg_conf);
2328  fclose(extra_conf);
2329  }
2330 
2331  fclose(pg_conf);
2332 
2333 #ifdef ENABLE_SSPI
2334 
2335  /*
2336  * Since we successfully used the same buffer for the much-longer
2337  * "initdb" command, this can't truncate.
2338  */
2339  snprintf(buf, sizeof(buf), "%s/data", temp_instance);
2340  config_sspi_auth(buf);
2341 #elif !defined(HAVE_UNIX_SOCKETS)
2342 #error Platform has no means to secure the test installation.
2343 #endif
2344 
2345  /*
2346  * Check if there is a postmaster running already.
2347  */
2348  snprintf(buf2, sizeof(buf2),
2349  "\"%s%spsql\" -X postgres <%s 2>%s",
2350  bindir ? bindir : "",
2351  bindir ? "/" : "",
2352  DEVNULL, DEVNULL);
2353 
2354  for (i = 0; i < 16; i++)
2355  {
2356  if (system(buf2) == 0)
2357  {
2358  char s[16];
2359 
2360  if (port_specified_by_user || i == 15)
2361  {
2362  fprintf(stderr, _("port %d apparently in use\n"), port);
2364  fprintf(stderr, _("%s: could not determine an available port\n"), progname);
2365  fprintf(stderr, _("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers.\n"));
2366  exit(2);
2367  }
2368 
2369  fprintf(stderr, _("port %d apparently in use, trying %d\n"), port, port + 1);
2370  port++;
2371  sprintf(s, "%d", port);
2372  doputenv("PGPORT", s);
2373  }
2374  else
2375  break;
2376  }
2377 
2378  /*
2379  * Start the temp postmaster
2380  */
2381  header(_("starting postmaster"));
2382  snprintf(buf, sizeof(buf),
2383  "\"%s%spostgres\" -D \"%s/data\" -F%s "
2384  "-c \"listen_addresses=%s\" -k \"%s\" "
2385  "> \"%s/log/postmaster.log\" 2>&1",
2386  bindir ? bindir : "",
2387  bindir ? "/" : "",
2388  temp_instance, debug ? " -d 5" : "",
2389  hostname ? hostname : "", sockdir ? sockdir : "",
2390  outputdir);
2392  if (postmaster_pid == INVALID_PID)
2393  {
2394  fprintf(stderr, _("\n%s: could not spawn postmaster: %s\n"),
2395  progname, strerror(errno));
2396  exit(2);
2397  }
2398 
2399  /*
2400  * Wait till postmaster is able to accept connections; normally this
2401  * is only a second or so, but Cygwin is reportedly *much* slower, and
2402  * test builds using Valgrind or similar tools might be too. Hence,
2403  * allow the default timeout of 60 seconds to be overridden from the
2404  * PGCTLTIMEOUT environment variable.
2405  */
2406  env_wait = getenv("PGCTLTIMEOUT");
2407  if (env_wait != NULL)
2408  {
2409  wait_seconds = atoi(env_wait);
2410  if (wait_seconds <= 0)
2411  wait_seconds = 60;
2412  }
2413  else
2414  wait_seconds = 60;
2415 
2416  for (i = 0; i < wait_seconds; i++)
2417  {
2418  /* Done if psql succeeds */
2419  if (system(buf2) == 0)
2420  break;
2421 
2422  /*
2423  * Fail immediately if postmaster has exited
2424  */
2425 #ifndef WIN32
2426  if (kill(postmaster_pid, 0) != 0)
2427 #else
2428  if (WaitForSingleObject(postmaster_pid, 0) == WAIT_OBJECT_0)
2429 #endif
2430  {
2431  fprintf(stderr, _("\n%s: postmaster failed\nExamine %s/log/postmaster.log for the reason\n"), progname, outputdir);
2432  exit(2);
2433  }
2434 
2435  pg_usleep(1000000L);
2436  }
2437  if (i >= wait_seconds)
2438  {
2439  fprintf(stderr, _("\n%s: postmaster did not respond within %d seconds\nExamine %s/log/postmaster.log for the reason\n"),
2440  progname, wait_seconds, outputdir);
2441 
2442  /*
2443  * If we get here, the postmaster is probably wedged somewhere in
2444  * startup. Try to kill it ungracefully rather than leaving a
2445  * stuck postmaster that might interfere with subsequent test
2446  * attempts.
2447  */
2448 #ifndef WIN32
2449  if (kill(postmaster_pid, SIGKILL) != 0 &&
2450  errno != ESRCH)
2451  fprintf(stderr, _("\n%s: could not kill failed postmaster: %s\n"),
2452  progname, strerror(errno));
2453 #else
2454  if (TerminateProcess(postmaster_pid, 255) == 0)
2455  fprintf(stderr, _("\n%s: could not kill failed postmaster: error code %lu\n"),
2456  progname, GetLastError());
2457 #endif
2458 
2459  exit(2);
2460  }
2461 
2462  postmaster_running = true;
2463 
2464 #ifdef _WIN64
2465 /* need a series of two casts to convert HANDLE without compiler warning */
2466 #define ULONGPID(x) (unsigned long) (unsigned long long) (x)
2467 #else
2468 #define ULONGPID(x) (unsigned long) (x)
2469 #endif
2470  printf(_("running on port %d with PID %lu\n"),
2472  }
2473  else
2474  {
2475  /*
2476  * Using an existing installation, so may need to get rid of
2477  * pre-existing database(s) and role(s)
2478  */
2479  if (!use_existing)
2480  {
2481  for (sl = dblist; sl; sl = sl->next)
2483  for (sl = extraroles; sl; sl = sl->next)
2484  drop_role_if_exists(sl->str);
2485  }
2486  }
2487 
2488  /*
2489  * Create the test database(s) and role(s)
2490  */
2491  if (!use_existing)
2492  {
2493  for (sl = dblist; sl; sl = sl->next)
2494  create_database(sl->str);
2495  for (sl = extraroles; sl; sl = sl->next)
2496  create_role(sl->str, dblist);
2497  }
2498 
2499  /*
2500  * Ready to run the tests
2501  */
2502  header(_("running regression test queries"));
2503 
2504  for (sl = schedulelist; sl != NULL; sl = sl->next)
2505  {
2506  run_schedule(sl->str, tfunc);
2507  }
2508 
2509  for (sl = extra_tests; sl != NULL; sl = sl->next)
2510  {
2511  run_single_test(sl->str, tfunc);
2512  }
2513 
2514  /*
2515  * Shut down temp installation's postmaster
2516  */
2517  if (temp_instance)
2518  {
2519  header(_("shutting down postmaster"));
2520  stop_postmaster();
2521  }
2522 
2523  /*
2524  * If there were no errors, remove the temp instance immediately to
2525  * conserve disk space. (If there were errors, we leave the instance in
2526  * place for possible manual investigation.)
2527  */
2528  if (temp_instance && fail_count == 0 && fail_ignore_count == 0)
2529  {
2530  header(_("removing temporary instance"));
2531  if (!rmtree(temp_instance, true))
2532  fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
2534  }
2535 
2536  fclose(logfile);
2537 
2538  /*
2539  * Emit nice-looking summary message
2540  */
2541  if (fail_count == 0 && fail_ignore_count == 0)
2542  snprintf(buf, sizeof(buf),
2543  _(" All %d tests passed. "),
2544  success_count);
2545  else if (fail_count == 0) /* fail_count=0, fail_ignore_count>0 */
2546  snprintf(buf, sizeof(buf),
2547  _(" %d of %d tests passed, %d failed test(s) ignored. "),
2548  success_count,
2551  else if (fail_ignore_count == 0) /* fail_count>0 && fail_ignore_count=0 */
2552  snprintf(buf, sizeof(buf),
2553  _(" %d of %d tests failed. "),
2554  fail_count,
2556  else
2557  /* fail_count>0 && fail_ignore_count>0 */
2558  snprintf(buf, sizeof(buf),
2559  _(" %d of %d tests failed, %d of these failures ignored. "),
2563 
2564  putchar('\n');
2565  for (i = strlen(buf); i > 0; i--)
2566  putchar('=');
2567  printf("\n%s\n", buf);
2568  for (i = strlen(buf); i > 0; i--)
2569  putchar('=');
2570  putchar('\n');
2571  putchar('\n');
2572 
2573  if (file_size(difffilename) > 0)
2574  {
2575  printf(_("The differences that caused some tests to fail can be viewed in the\n"
2576  "file \"%s\". A copy of the test summary that you see\n"
2577  "above is saved in the file \"%s\".\n\n"),
2579  }
2580  else
2581  {
2582  unlink(difffilename);
2583  unlink(logfilename);
2584  }
2585 
2586  if (fail_count != 0)
2587  exit(1);
2588 
2589  return 0;
2590 }
char * make_absolute_path(const char *path)
Definition: path.c:608
static bool directory_exists(const char *dir)
Definition: pg_regress.c:1242
static void drop_role_if_exists(const char *rolename)
Definition: pg_regress.c:1981
static void drop_database_if_exists(const char *dbname)
Definition: pg_regress.c:1928
static int max_concurrent_tests
Definition: pg_regress.c:81
static const char * sockdir
Definition: pg_regress.c:102
static int wait_seconds
Definition: pg_ctl.c:84
static _stringlist * extra_tests
Definition: pg_regress.c:84
static void help(void)
Definition: pg_regress.c:2000
char * str
Definition: pg_regress.h:24
static void initialize_environment(void)
Definition: pg_regress.c:725
static void run_single_test(const char *test, test_function tfunc)
Definition: pg_regress.c:1826
bool debug
Definition: pg_regress.c:73
const char * get_progname(const char *argv0)
Definition: path.c:453
static void static void static void void add_stringlist_item(_stringlist **listhead, const char *str)
Definition: pg_regress.c:155
int getopt_long(int argc, char *const argv[], const char *optstring, const struct option *longopts, int *longindex)
Definition: getopt_long.c:57
static void run_schedule(const char *schedule, test_function tfunc)
Definition: pg_regress.c:1582
static char * encoding
Definition: pg_regress.c:82
static const char * progname
Definition: pg_regress.c:98
static void make_directory(const char *dir)
Definition: pg_regress.c:1255
static bool use_existing
Definition: pg_regress.c:88
static bool postmaster_running
Definition: pg_regress.c:112
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
static FILE * logfile
Definition: pg_regress.c:100
static void stop_postmaster(void)
Definition: pg_regress.c:258
static char * temp_instance
Definition: pg_regress.c:85
char * launcher
Definition: pg_regress.c:77
static void split_to_stringlist(const char *s, const char *delim, _stringlist **listhead)
Definition: pg_regress.c:191
static void free_stringlist(_stringlist **listhead)
Definition: pg_regress.c:176
static _stringlist * loadlanguage
Definition: pg_regress.c:78
PID_TYPE spawn_process(const char *cmdline)
Definition: pg_regress.c:1127
static char * difffilename
Definition: pg_regress.c:101
void pg_usleep(long microsec)
Definition: signal.c:53
#define required_argument
Definition: getopt_long.h:25
int optind
Definition: getopt.c:51
static _stringlist * loadextension
Definition: pg_regress.c:79
#define MAXPGPATH
_stringlist * dblist
Definition: pg_regress.c:72
static _stringlist * extraroles
Definition: pg_regress.c:94
static _stringlist * temp_configs
Definition: pg_regress.c:86
char * c
const char * pretty_diff_opts
Definition: pg_regress.c:65
static char * buf
Definition: pg_test_fsync.c:67
#define INVALID_PID
Definition: pg_regress.h:15
static void create_role(const char *rolename, const _stringlist *granted_dbs)
Definition: pg_regress.c:1988
static char * dlpath
Definition: pg_regress.c:92
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
static int success_count
Definition: pg_regress.c:114
#define DEVNULL
Definition: port.h:119
static int max_connections
Definition: pg_regress.c:80
static int port
Definition: pg_regress.c:90
static PID_TYPE postmaster_pid
Definition: pg_regress.c:111
bool rmtree(const char *path, bool rmtopdir)
Definition: rmtree.c:36
#define no_argument
Definition: getopt_long.h:24
static char * config_auth_datadir
Definition: pg_regress.c:95
#define PG_TEXTDOMAIN(domain)
Definition: c.h:1018
static int fail_ignore_count
Definition: pg_regress.c:116
static int fail_count
Definition: pg_regress.c:115
char * outputdir
Definition: pg_regress.c:75
static char * logfilename
Definition: pg_regress.c:99
char * inputdir
Definition: pg_regress.c:74
static long file_size(const char *file)
Definition: pg_regress.c:1188
static bool port_specified_by_user
Definition: pg_regress.c:91
char * bindir
Definition: pg_regress.c:76
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:208
static void doputenv(const char *var, const char *val)
Definition: pg_regress.c:713
static char * user
Definition: pg_regress.c:93
void set_pglocale_pgservice(const char *argv0, const char *app)
Definition: exec.c:550
char * optarg
Definition: getopt.c:53
static _stringlist * schedulelist
Definition: pg_regress.c:83
struct _stringlist * next
Definition: pg_regress.h:25
int i
const char * strerror(int errnum)
Definition: strerror.c:19
static bool nolocale
Definition: pg_regress.c:87
static void open_result_files(void)
Definition: pg_regress.c:1888
#define SIGKILL
Definition: win32.h:192
static char * hostname
Definition: pg_regress.c:89
#define _(x)
Definition: elog.c:84
#define ULONGPID(x)
static void create_database(const char *dbname)
Definition: pg_regress.c:1935
void replace_string ( char *  string,
char *  replace,
char *  replacement 
)

Definition at line 441 of file pg_regress.c.

References free, pg_strdup(), and strlcpy().

Referenced by convert_sourcefiles_in(), ecpg_filter(), and ecpg_start_test().

442 {
443  char *ptr;
444 
445  while ((ptr = strstr(string, replace)) != NULL)
446  {
447  char *dup = pg_strdup(string);
448 
449  strlcpy(string, dup, ptr - string + 1);
450  strcat(string, replacement);
451  strcat(string, dup + (ptr - string) + strlen(replace));
452  free(dup);
453  }
454 }
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
#define free(a)
Definition: header.h:65
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
PID_TYPE spawn_process ( const char *  cmdline)

Definition at line 1127 of file pg_regress.c.

References _, logfile, progname, psprintf(), shellprog, and strerror().

Referenced by ecpg_start_test(), isolation_start_test(), psql_start_test(), and regression_main().

1128 {
1129 #ifndef WIN32
1130  pid_t pid;
1131 
1132  /*
1133  * Must flush I/O buffers before fork. Ideally we'd use fflush(NULL) here
1134  * ... does anyone still care about systems where that doesn't work?
1135  */
1136  fflush(stdout);
1137  fflush(stderr);
1138  if (logfile)
1139  fflush(logfile);
1140 
1141  pid = fork();
1142  if (pid == -1)
1143  {
1144  fprintf(stderr, _("%s: could not fork: %s\n"),
1145  progname, strerror(errno));
1146  exit(2);
1147  }
1148  if (pid == 0)
1149  {
1150  /*
1151  * In child
1152  *
1153  * Instead of using system(), exec the shell directly, and tell it to
1154  * "exec" the command too. This saves two useless processes per
1155  * parallel test case.
1156  */
1157  char *cmdline2;
1158 
1159  cmdline2 = psprintf("exec %s", cmdline);
1160  execl(shellprog, shellprog, "-c", cmdline2, (char *) NULL);
1161  fprintf(stderr, _("%s: could not exec \"%s\": %s\n"),
1162  progname, shellprog, strerror(errno));
1163  _exit(1); /* not exit() here... */
1164  }
1165  /* in parent */
1166  return pid;
1167 #else
1168  PROCESS_INFORMATION pi;
1169  char *cmdline2;
1170  HANDLE restrictedToken;
1171 
1172  memset(&pi, 0, sizeof(pi));
1173  cmdline2 = psprintf("cmd /c \"%s\"", cmdline);
1174 
1175  if ((restrictedToken =
1176  CreateRestrictedProcess(cmdline2, &pi, progname)) == 0)
1177  exit(2);
1178 
1179  CloseHandle(pi.hThread);
1180  return pi.hProcess;
1181 #endif
1182 }
static char * shellprog
Definition: pg_regress.c:55
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
static const char * progname
Definition: pg_regress.c:98
static FILE * logfile
Definition: pg_regress.c:100
const char * strerror(int errnum)
Definition: strerror.c:19
#define _(x)
Definition: elog.c:84

Variable Documentation

const char* basic_diff_opts

Definition at line 64 of file pg_regress.c.

Referenced by results_differ().

char* bindir

Definition at line 76 of file pg_regress.c.

Referenced by psql_command(), psql_start_test(), regression_main(), and stop_postmaster().

char* host_platform

Definition at line 52 of file pg_regress.c.

Referenced by load_resultmap().

char* launcher

Definition at line 77 of file pg_regress.c.

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

char* libdir
const char* pretty_diff_opts

Definition at line 65 of file pg_regress.c.

Referenced by regression_main(), and results_differ().