/*
* _PG_init
*
* Load point of library.
*/
void
_PG_init(void)
{
BackgroundWorker worker;
/* Register the worker processes */
MemSet(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
/*
* Function to call when starting bgworker, in this case library is
* already loaded.
*/
worker.bgw_main = hello_main;
snprintf(worker.bgw_name, BGW_MAXLEN, "hello world");
worker.bgw_restart_time = BGW_NEVER_RESTART;
worker.bgw_main_arg = (Datum) 0;
#if PG_VERSION_NUM >= 90400
/*
* Notify PID is present since 9.4. If this is not initialized
* a static background worker cannot start properly.
*/
worker.bgw_notify_pid = 0;
#endif
RegisterBackgroundWorker(&worker);
}
void
pgstrom_init_opencl_server(void)
{
BackgroundWorker worker;
/* number of opencl server threads */
DefineCustomIntVariable("pg_strom.opencl_num_threads",
"number of opencl server threads",
NULL,
&opencl_num_threads,
0, /* auto selection */
0,
INT_MAX,
PGC_POSTMASTER,
GUC_NOT_IN_SAMPLE,
NULL, NULL, NULL);
/* launch a background worker process */
memset(&worker, 0, sizeof(BackgroundWorker));
strcpy(worker.bgw_name, "PG-Strom OpenCL Server");
worker.bgw_flags = BGWORKER_SHMEM_ACCESS;
worker.bgw_start_time = BgWorkerStart_PostmasterStart;
worker.bgw_restart_time = BGW_NEVER_RESTART;
worker.bgw_main = pgstrom_opencl_main;
worker.bgw_main_arg = 0;
RegisterBackgroundWorker(&worker);
/* acquire shared memory */
RequestAddinShmemSpace(MAXALIGN(sizeof(*opencl_serv_shm_values)));
shmem_startup_hook_next = shmem_startup_hook;
shmem_startup_hook = pgstrom_startup_opencl_server;
}
/*
* Entry point for worker loading
*/
void
_PG_init(void)
{
BackgroundWorker worker;
/* Add parameters */
kill_idle_load_params();
/* Worker parameter and registration */
MemSet(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
worker.bgw_main = kill_idle_main;
snprintf(worker.bgw_name, BGW_MAXLEN, "%s", worker_name);
/* Wait 10 seconds for restart before crash */
worker.bgw_restart_time = 10;
worker.bgw_main_arg = (Datum) 0;
#if PG_VERSION_NUM >= 90400
/*
* Notify PID is present since 9.4. If this is not initialized
* a static background worker cannot start properly.
*/
worker.bgw_notify_pid = 0;
#endif
RegisterBackgroundWorker(&worker);
}
void
_PG_init(void)
{
BackgroundWorker worker;
if (!process_shared_preload_libraries_in_progress)
return;
DefineCustomStringVariable("pg_cmdworker.command",
"Sets the shell command to run.",
NULL,
&cmdworker_command,
NULL,
PGC_POSTMASTER,
0,
NULL,
NULL,
NULL);
EmitWarningsOnPlaceholders("pg_cmdworker");
worker.bgw_flags = 0;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_restart_time = BGW_NEVER_RESTART;
worker.bgw_main = cmdworker_main;
worker.bgw_notify_pid = 0;
snprintf(worker.bgw_name, BGW_MAXLEN, "pg_cmdworker");
RegisterBackgroundWorker(&worker);
}
/*
* Entrypoint of this module.
*
* We register more than one worker process here, to demonstrate how that can
* be done.
*/
void
_PG_init(void)
{
BackgroundWorker worker;
unsigned int i;
/* get the configuration */
DefineCustomIntVariable("worker_spi.naptime",
"Duration between each check (in seconds).",
NULL,
&worker_spi_naptime,
10,
1,
INT_MAX,
PGC_SIGHUP,
0,
NULL,
NULL,
NULL);
if (!process_shared_preload_libraries_in_progress)
return;
DefineCustomIntVariable("worker_spi.total_workers",
"Number of workers.",
NULL,
&worker_spi_total_workers,
2,
1,
100,
PGC_POSTMASTER,
0,
NULL,
NULL,
NULL);
/* set up common data for all our workers */
memset(&worker, 0, sizeof(worker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_restart_time = BGW_NEVER_RESTART;
sprintf(worker.bgw_library_name, "worker_spi");
sprintf(worker.bgw_function_name, "worker_spi_main");
worker.bgw_notify_pid = 0;
/*
* Now fill in worker-specific data, and do the actual registrations.
*/
for (i = 1; i <= worker_spi_total_workers; i++)
{
snprintf(worker.bgw_name, BGW_MAXLEN, "worker_spi worker %d", i);
snprintf(worker.bgw_type, BGW_MAXLEN, "worker_spi");
worker.bgw_main_arg = Int32GetDatum(i);
RegisterBackgroundWorker(&worker);
}
}
void worker_register(WorkerConfig *cfg)
{
BackgroundWorker worker = {};
strcpy(worker.bgw_name, "raftable worker");
worker.bgw_flags = BGWORKER_SHMEM_ACCESS;
worker.bgw_start_time = BgWorkerStart_PostmasterStart;
worker.bgw_restart_time = 1;
worker.bgw_main = worker_main;
worker.bgw_main_arg = PointerGetDatum(cfg);
RegisterBackgroundWorker(&worker);
}
/*
* Entrypoint of this module.
*/
void
_PG_init(void)
{
BackgroundWorker worker;
/* get GUC settings, if available */
DefineCustomStringVariable(
"config_log.database",
"Database used for config_log",
"Database used to store config_log records (default: postgres).",
&config_log_database,
"postgres",
PGC_POSTMASTER,
0,
NULL,
NULL,
NULL
);
DefineCustomStringVariable(
"config_log.schema",
"Schema used for config_log",
"Schema used to store config_log records (default: public).",
&config_log_schema,
"public",
PGC_POSTMASTER,
0,
NULL,
NULL,
NULL
);
/* register the worker processes */
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_main = config_log_main;
worker.bgw_restart_time = 1;
worker.bgw_main_arg = (Datum) 0;
#if PG_VERSION_NUM >= 90400
worker.bgw_notify_pid = 0;
#endif
/* this value is shown in the process list */
snprintf(worker.bgw_name, BGW_MAXLEN, "config_log");
RegisterBackgroundWorker(&worker);
}
void _PG_init(void)
{
BackgroundWorker worker;
DefineCustomIntVariable("powa.frequency",
"Defines the frequency in seconds of the snapshots",
NULL,
&powa_frequency,
300000,
-1,
INT_MAX / 1000,
PGC_SUSET, GUC_UNIT_MS, NULL, NULL, NULL);
DefineCustomIntVariable("powa.coalesce",
"Defines the amount of records to group together in the table (more compact)",
NULL,
&powa_coalesce,
100, 5, INT_MAX, PGC_SUSET, 0, NULL, NULL, NULL);
DefineCustomIntVariable("powa.retention",
"Automatically purge data older than N minutes",
NULL,
&powa_retention,
HOURS_PER_DAY * MINS_PER_HOUR,
0,
INT_MAX / SECS_PER_MINUTE,
PGC_SUSET, GUC_UNIT_MIN, NULL, NULL, NULL);
DefineCustomStringVariable("powa.database",
"Defines the database of the workload repository",
NULL,
&powa_database,
"powa", PGC_POSTMASTER, 0, NULL, NULL, NULL);
/*
Register the worker processes
*/
worker.bgw_flags =
BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished; /* Must write to the database */
worker.bgw_main = powa_main;
snprintf(worker.bgw_name, BGW_MAXLEN, "powa");
worker.bgw_restart_time = 10;
worker.bgw_main_arg = (Datum) 0;
#if (PG_VERSION_NUM >= 90400)
worker.bgw_notify_pid = 0;
#endif
RegisterBackgroundWorker(&worker);
}
void
_PG_init(void)
{
BackgroundWorker worker;
MemSet(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = 0;
worker.bgw_start_time = BgWorkerStart_PostmasterStart;
snprintf(worker.bgw_library_name, BGW_MAXLEN, "hello_signal");
snprintf(worker.bgw_function_name, BGW_MAXLEN, "hello_main");
snprintf(worker.bgw_name, BGW_MAXLEN, "%s", worker_name);
/* Wait 10 seconds for restart before crash */
worker.bgw_restart_time = 10;
worker.bgw_main_arg = (Datum) 0;
worker.bgw_notify_pid = 0;
RegisterBackgroundWorker(&worker);
}
/*
* _PG_init
*
* Load point of library.
*/
void
_PG_init(void)
{
BackgroundWorker worker;
/* Register the worker processes */
MemSet(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
snprintf(worker.bgw_library_name, BGW_MAXLEN, "hello_world");
snprintf(worker.bgw_function_name, BGW_MAXLEN, "hello_main");
snprintf(worker.bgw_name, BGW_MAXLEN, "hello world");
worker.bgw_restart_time = BGW_NEVER_RESTART;
worker.bgw_main_arg = (Datum) 0;
worker.bgw_notify_pid = 0;
RegisterBackgroundWorker(&worker);
}
/*
* Entrypoint of this module.
*
* We register more than one worker process here, to demonstrate how that can
* be done.
*/
void _PG_init(void)
{
struct BackgroundWorker worker = { "restgres master" };
/* get the configuration */
DefineCustomStringVariable("http.listen_addresses",
"Addresses to listen on; see PostgreSQL listen_addresses",
NULL, &restgres_listen_addresses, "*", PGC_SIGHUP, 0,
NULL,
NULL,
NULL);
DefineCustomIntVariable("http.port",
"Port to listen on (default: any available port)",
NULL, &restgres_listen_port, restgres_listen_port, 0, 32768,
PGC_SIGHUP, 0,
NULL,
NULL,
NULL);
DefineCustomIntVariable("http.max_connections",
"Maximum number of connections to serve at once (additional connections will have to wait or be rejected)",
NULL, &restgres_max_connections, 100, 0,
INT_MAX, PGC_SIGHUP, 0,
NULL,
NULL,
NULL);
DefineCustomIntVariable("http.max_concurrency",
"Maximum number of connections to serve at once (additional connections will have to wait or be rejected)",
NULL, &restgres_max_concurrency, 100, 0,
INT_MAX, PGC_SIGHUP, 0,
NULL,
NULL,
NULL);
/* set up common data for all our workers */
worker.bgw_flags = BGWORKER_SHMEM_ACCESS
| BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_restart_time = BGW_DEFAULT_RESTART_INTERVAL;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_main = restgres_main;
worker.bgw_notify_pid = 0;
RegisterBackgroundWorker(&worker);
}
/*
* Entrypoint of this module.
*
* We register more than one worker process here, to demonstrate how that can
* be done.
*/
void
_PG_init(void)
{
BackgroundWorker worker;
if (!process_shared_preload_libraries_in_progress)
{
return;
}
DefineCustomIntVariable("pg_octopus.health_check_period",
"Duration between each check (in milliseconds).",
NULL, &HealthCheckPeriod, 10000, 1, INT_MAX, PGC_SIGHUP,
0, NULL, NULL, NULL);
DefineCustomIntVariable("pg_octopus.health_check_timeout",
"Connect timeout (in milliseconds).",
NULL, &HealthCheckTimeout, 2000, 1, INT_MAX, PGC_SIGHUP,
0, NULL, NULL, NULL);
DefineCustomIntVariable("pg_octopus.health_check_max_retries",
"Maximum number of re-tries before marking a node as failed.",
NULL, &HealthCheckMaxRetries, 2, 1, 100, PGC_SIGHUP,
0, NULL, NULL, NULL);
DefineCustomIntVariable("pg_octopus.health_check_retry_delay",
"Delay between consecutive retries.",
NULL, &HealthCheckRetryDelay, 1000, 1, INT_MAX, PGC_SIGHUP,
0, NULL, NULL, NULL);
/* set up common data for all our workers */
worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_restart_time = BGW_NEVER_RESTART;
worker.bgw_main = PgOctopusWorkerMain;
worker.bgw_main_arg = Int32GetDatum(0);
worker.bgw_notify_pid = 0;
sprintf(worker.bgw_library_name, "pg_octopus");
snprintf(worker.bgw_name, BGW_MAXLEN, "pg_octopus_monitor");
RegisterBackgroundWorker(&worker);
}
/*
* Entry point for worker loading
*/
void
_PG_init(void)
{
BackgroundWorker worker;
/* Add parameters */
kill_idle_load_params();
/* Worker parameter and registration */
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
worker.bgw_main = kill_idle_main;
snprintf(worker.bgw_name, BGW_MAXLEN, "%s", worker_name);
/* Wait 10 seconds for restart before crash */
worker.bgw_restart_time = 10;
worker.bgw_main_arg = (Datum) 0;
RegisterBackgroundWorker(&worker);
}
void BgwPoolStart(int nWorkers, BgwPoolConstructor constructor)
{
int i;
BackgroundWorker worker;
MemSet(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
worker.bgw_main = BgwPoolMainLoop;
worker.bgw_restart_time = MULTIMASTER_BGW_RESTART_TIMEOUT;
for (i = 0; i < nWorkers; i++) {
BgwPoolExecutorCtx* ctx = (BgwPoolExecutorCtx*)malloc(sizeof(BgwPoolExecutorCtx));
snprintf(worker.bgw_name, BGW_MAXLEN, "bgw_pool_worker_%d", i+1);
ctx->id = i;
ctx->constructor = constructor;
worker.bgw_main_arg = (Datum)ctx;
RegisterBackgroundWorker(&worker);
}
}
static bool
RegisterWorker(int id)
{
BackgroundWorker worker;
/*
* Protect against the possibility of more members being added to the
* structure than we are using below.
*/
MemSet(&worker, 0, sizeof(worker));
worker.bgw_main_arg = Int32GetDatum(id);
worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION;
if (id == 0)
{
/* Register the BufferSaver background worker */
worker.bgw_start_time = BgWorkerStart_ConsistentState;
worker.bgw_restart_time = 0; /* Keep the BufferSaver running */
worker.bgw_main = BufferSaverMain;
snprintf(worker.bgw_name, BGW_MAXLEN, "Buffer Saver");
}
else
{
/* Register a BlockReader background worker process */
worker.bgw_start_time = BgWorkerStart_ConsistentState;
worker.bgw_restart_time = BGW_NEVER_RESTART; /* Don't restart BlockReaders upon error */
worker.bgw_main = BlockReaderMain;
snprintf(worker.bgw_name, BGW_MAXLEN, "Block Reader %d", id);
}
/*
* This API is deficient as it can't report failure; it just does an
* ereport(LOG) on failure.
*/
RegisterBackgroundWorker(&worker);
return true;
}
/*
* Entrypoint of this module.
*/
void
_PG_init(void)
{
BackgroundWorker worker;
/* register the worker processes */
MemSet(&worker, 0, sizeof(BackgroundWorker));
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_main = worker_spi_main;
snprintf(worker.bgw_name, BGW_MAXLEN, "count relations");
worker.bgw_restart_time = BGW_NEVER_RESTART;
worker.bgw_main_arg = (Datum) 0;
#if PG_VERSION_NUM >= 90400
/*
* Notify PID is present since 9.4. If this is not initialized
* a static background worker cannot start properly.
*/
worker.bgw_notify_pid = 0;
#endif
RegisterBackgroundWorker(&worker);
}
/*
* ApplyLauncherRegister
* Register a background worker running the logical replication launcher.
*/
void
ApplyLauncherRegister(void)
{
BackgroundWorker bgw;
if (max_logical_replication_workers == 0)
return;
memset(&bgw, 0, sizeof(bgw));
bgw.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
bgw.bgw_start_time = BgWorkerStart_RecoveryFinished;
snprintf(bgw.bgw_library_name, BGW_MAXLEN, "postgres");
snprintf(bgw.bgw_function_name, BGW_MAXLEN, "ApplyLauncherMain");
snprintf(bgw.bgw_name, BGW_MAXLEN,
"logical replication launcher");
snprintf(bgw.bgw_type, BGW_MAXLEN,
"logical replication launcher");
bgw.bgw_restart_time = 5;
bgw.bgw_notify_pid = 0;
bgw.bgw_main_arg = (Datum) 0;
RegisterBackgroundWorker(&bgw);
}
/*
* Entrypoint of this module.
*
* We register more than one worker process here, to demonstrate how that can
* be done.
*/
void
_PG_init(void)
{
BackgroundWorker worker;
if (!process_shared_preload_libraries_in_progress)
return;
/* get the configuration */
DefineCustomIntVariable("pg_keeper.keepalives_time",
"Specific time between polling to primary server",
NULL,
&keeper_keepalives_time,
5,
1,
INT_MAX,
PGC_SIGHUP,
0,
NULL,
NULL,
NULL);
DefineCustomIntVariable("pg_keeper.keepalives_count",
"Specific retry count until promoting standby server",
NULL,
&keeper_keepalives_count,
1,
1,
INT_MAX,
PGC_SIGHUP,
0,
NULL,
NULL,
NULL);
DefineCustomStringVariable("pg_keeper.node1_conninfo",
"Connection information for node1 server (first master server)",
NULL,
&keeper_node1_conninfo,
NULL,
PGC_POSTMASTER,
0,
NULL,
NULL,
NULL);
DefineCustomStringVariable("pg_keeper.node2_conninfo",
"Connection information for node2 server (first standby server)",
NULL,
&keeper_node2_conninfo,
NULL,
PGC_POSTMASTER,
0,
NULL,
NULL,
NULL);
DefineCustomStringVariable("pg_keeper.after_command",
"Shell command that will be called after promoted",
NULL,
&keeper_after_command,
NULL,
PGC_SIGHUP,
GUC_NOT_IN_SAMPLE,
NULL,
NULL,
NULL);
/* set up common data for all our workers */
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
worker.bgw_restart_time = BGW_NEVER_RESTART;
worker.bgw_main = KeeperMain;
worker.bgw_notify_pid = 0;
/*
* Now fill in worker-specific data, and do the actual registrations.
*/
snprintf(worker.bgw_name, BGW_MAXLEN, "pg_keeper");
worker.bgw_main_arg = Int32GetDatum(1);
RegisterBackgroundWorker(&worker);
}
void
_PG_init(void)
{
/*
* In order to create our shared memory area, we have to be loaded via
* shared_preload_libraries. If not, fall out without hooking into any of
* the main system. (We don't throw error here because it seems useful to
* allow the cs_* functions to be created even when the
* module isn't active. The functions must protect themselves against
* being called then, however.)
*/
if (!process_shared_preload_libraries_in_progress)
return;
DefineCustomIntVariable(
"multimaster.workers",
"Number of multimaster executor workers per node",
NULL,
&MMWorkers,
8,
1,
INT_MAX,
PGC_BACKEND,
0,
NULL,
NULL,
NULL
);
DefineCustomIntVariable(
"multimaster.queue_size",
"Multimaster queue size",
NULL,
&MMQueueSize,
1024*1024,
1024,
INT_MAX,
PGC_BACKEND,
0,
NULL,
NULL,
NULL
);
DefineCustomIntVariable(
"multimaster.local_xid_reserve",
"Number of XIDs reserved by node for local transactions",
NULL,
&DtmLocalXidReserve,
100,
1,
INT_MAX,
PGC_BACKEND,
0,
NULL,
NULL,
NULL
);
DefineCustomIntVariable(
"multimaster.buffer_size",
"Size of sockhub buffer for connection to DTM daemon, if 0, then direct connection will be used",
NULL,
&DtmBufferSize,
0,
0,
INT_MAX,
PGC_BACKEND,
0,
NULL,
NULL,
NULL
);
DefineCustomStringVariable(
"multimaster.arbiters",
"The comma separated host:port pairs where arbiters reside",
NULL,
&Arbiters,
"127.0.0.1:5431",
PGC_BACKEND, // context
0, // flags,
NULL, // GucStringCheckHook check_hook,
NULL, // GucStringAssignHook assign_hook,
NULL // GucShowHook show_hook
);
DefineCustomStringVariable(
"multimaster.conn_strings",
"Multimaster node connection strings separated by commas, i.e. 'replication=database dbname=postgres host=localhost port=5001,replication=database dbname=postgres host=localhost port=5002'",
NULL,
&MMConnStrs,
"",
PGC_BACKEND, // context
0, // flags,
NULL, // GucStringCheckHook check_hook,
NULL, // GucStringAssignHook assign_hook,
NULL // GucShowHook show_hook
);
DefineCustomIntVariable(
"multimaster.node_id",
"Multimaster node ID",
NULL,
&MMNodeId,
1,
1,
INT_MAX,
PGC_BACKEND,
0,
NULL,
NULL,
NULL
);
/*
* Request additional shared resources. (These are no-ops if we're not in
* the postmaster process.) We'll allocate or attach to the shared
* resources in dtm_shmem_startup().
*/
RequestAddinShmemSpace(DTM_SHMEM_SIZE + MMQueueSize);
RequestAddinLWLocks(2);
MMNodes = MMStartReceivers(MMConnStrs, MMNodeId);
if (MMNodes < 2) {
elog(ERROR, "Multimaster should have at least two nodes");
}
BgwPoolStart(MMWorkers, MMPoolConstructor);
ArbitersCopy = strdup(Arbiters);
if (DtmBufferSize != 0)
{
ArbiterConfig(Arbiters, Unix_socket_directories);
RegisterBackgroundWorker(&DtmWorker);
}
else
ArbiterConfig(Arbiters, NULL);
/*
* Install hooks.
*/
PreviousShmemStartupHook = shmem_startup_hook;
shmem_startup_hook = DtmShmemStartup;
PreviousExecutorFinishHook = ExecutorFinish_hook;
ExecutorFinish_hook = MMExecutorFinish;
PreviousProcessUtilityHook = ProcessUtility_hook;
ProcessUtility_hook = MMProcessUtility;
}
/*
* Entrypoint of this module.
*
* We register more than one worker process here, to demonstrate how that can
* be done.
*/
void
_PG_init(void)
{
BackgroundWorker worker;
unsigned int i;
/* Define wich database to attach */
DefineCustomStringVariable("wed_worker.db_name",
"WED-flow database to attach",
NULL,
&wed_worker_db_name,
__DB_NAME__,
PGC_SIGHUP,
0,
NULL,
NULL,
NULL);
/* get the configuration */
DefineCustomIntVariable("wed_worker.naptime",
"Duration between each check (in seconds).",
NULL,
&wed_worker_naptime,
10,
1,
INT_MAX,
PGC_SIGHUP,
0,
NULL,
NULL,
NULL);
if (!process_shared_preload_libraries_in_progress)
return;
DefineCustomIntVariable("wed_worker.total_workers",
"Number of workers.",
NULL,
&wed_worker_total_workers,
1,
1,
100,
PGC_POSTMASTER,
0,
NULL,
NULL,
NULL);
/* set up common data for all our workers */
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_restart_time = BGW_NEVER_RESTART;
worker.bgw_main = wed_worker_main;
worker.bgw_notify_pid = 0;
/*
* Now fill in worker-specific data, and do the actual registrations.
*/
for (i = 1; i <= wed_worker_total_workers; i++)
{
snprintf(worker.bgw_name, BGW_MAXLEN, "ww[%s] %d", wed_worker_db_name, i);
worker.bgw_main_arg = Int32GetDatum(i);
RegisterBackgroundWorker(&worker);
}
}
