POOL_REPORT_POOLS* get_pools(int *nrows)
{
int child, pool, poolBE, backend_id;
ProcessInfo *pi = NULL;
int proc_id;
int lines = 0;
POOL_REPORT_POOLS* pools = malloc(
pool_config->num_init_children * pool_config->max_pool * NUM_BACKENDS * sizeof(POOL_REPORT_POOLS)
);
for (child = 0; child < pool_config->num_init_children; child++)
{
proc_id = process_info[child].pid;
pi = pool_get_process_info(proc_id);
for (pool = 0; pool < pool_config->max_pool; pool++)
{
for (backend_id = 0; backend_id < NUM_BACKENDS; backend_id++)
{
poolBE = pool*MAX_NUM_BACKENDS+backend_id;
pools[lines].pool_pid = proc_id;
pools[lines].start_time = pi->start_time;
pools[lines].pool_id = pool;
pools[lines].backend_id = backend_id;
if (strlen(pi->connection_info[poolBE].database) == 0)
{
strncpy(pools[lines].database, "", POOLCONFIG_MAXIDENTLEN);
strncpy(pools[lines].username, "", POOLCONFIG_MAXIDENTLEN);
pools[lines].create_time = 0;
pools[lines].pool_majorversion = 0;
pools[lines].pool_minorversion = 0;
}
else
{
strncpy(pools[lines].database, pi->connection_info[poolBE].database, POOLCONFIG_MAXIDENTLEN);
strncpy(pools[lines].username, pi->connection_info[poolBE].user, POOLCONFIG_MAXIDENTLEN);
pools[lines].create_time = pi->connection_info[poolBE].create_time;
pools[lines].pool_majorversion = pi->connection_info[poolBE].major;
pools[lines].pool_minorversion = pi->connection_info[poolBE].minor;
}
pools[lines].pool_counter = pi->connection_info[poolBE].counter;
pools[lines].pool_backendpid = ntohl(pi->connection_info[poolBE].pid);
pools[lines].pool_connected = pi->connection_info[poolBE].connected;
lines++;
}
}
}
*nrows = lines;
return pools;
}
POOL_REPORT_PROCESSES* get_processes(int *nrows)
{
int child;
int pool;
int poolBE;
ProcessInfo *pi = NULL;
int proc_id;
POOL_REPORT_PROCESSES* processes = malloc(pool_config->num_init_children * sizeof(POOL_REPORT_PROCESSES));
for (child = 0; child < pool_config->num_init_children; child++)
{
proc_id = process_info[child].pid;
pi = pool_get_process_info(proc_id);
snprintf(processes[child].pool_pid, POOLCONFIG_MAXCOUNTLEN, "%d", proc_id);
strftime(processes[child].start_time, POOLCONFIG_MAXDATELEN, "%Y-%m-%d %H:%M:%S", localtime(&pi->start_time));
strncpy(processes[child].database, "", POOLCONFIG_MAXIDENTLEN);
strncpy(processes[child].username, "", POOLCONFIG_MAXIDENTLEN);
strncpy(processes[child].create_time, "", POOLCONFIG_MAXDATELEN);
strncpy(processes[child].pool_counter, "", POOLCONFIG_MAXCOUNTLEN);
for (pool = 0; pool < pool_config->max_pool; pool++)
{
poolBE = pool*MAX_NUM_BACKENDS;
if (pi->connection_info[poolBE].connected && strlen(pi->connection_info[poolBE].database) > 0 && strlen(pi->connection_info[poolBE].user) > 0)
{
strncpy(processes[child].database, pi->connection_info[poolBE].database, POOLCONFIG_MAXIDENTLEN);
strncpy(processes[child].username, pi->connection_info[poolBE].user, POOLCONFIG_MAXIDENTLEN);
strftime(processes[child].create_time, POOLCONFIG_MAXDATELEN, "%Y-%m-%d %H:%M:%S", localtime(&pi->connection_info[poolBE].create_time));
snprintf(processes[child].pool_counter, POOLCONFIG_MAXCOUNTLEN, "%d", pi->connection_info[poolBE].counter);
}
}
}
*nrows = child;
return processes;
}
static void
inform_process_info(PCP_CONNECTION *frontend,char *buf)
{
int proc_id;
int wsize;
int num_proc = pool_config->num_init_children;
int i;
proc_id = atoi(buf);
if ((proc_id != 0) && (pool_get_process_info(proc_id) == NULL))
{
ereport(ERROR,
(errmsg("informing process info failed"),
errdetail("invalid process ID : %s",buf)));
}
else
{
/* First, send array size of connection_info */
char arr_code[] = "ArraySize";
char con_info_size[16];
/* Finally, indicate that all data is sent */
char fin_code[] = "CommandComplete";
POOL_REPORT_POOLS *pools = get_pools(&num_proc);
if (proc_id == 0)
{
snprintf(con_info_size, sizeof(con_info_size), "%d", num_proc);
}
else
{
snprintf(con_info_size, sizeof(con_info_size), "%d", pool_config->max_pool * NUM_BACKENDS);
}
pcp_write(frontend, "p", 1);
wsize = htonl(sizeof(arr_code) +
strlen(con_info_size)+1 +
sizeof(int));
pcp_write(frontend, &wsize, sizeof(int));
pcp_write(frontend, arr_code, sizeof(arr_code));
pcp_write(frontend, con_info_size, strlen(con_info_size)+1);
do_pcp_flush(frontend);
/* Second, send process information for all connection_info */
for (i=0; i<num_proc; i++)
{
char code[] = "ProcessInfo";
char proc_pid[16];
char proc_start_time[20];
char proc_create_time[20];
char majorversion[5];
char minorversion[5];
char pool_counter[16];
char backend_id[16];
char backend_pid[16];
char connected[2];
if (proc_id != 0 && proc_id != pools[i].pool_pid) continue;
snprintf(proc_pid, sizeof(proc_pid), "%d", pools[i].pool_pid);
snprintf(proc_start_time, sizeof(proc_start_time), "%ld", pools[i].start_time);
snprintf(proc_create_time, sizeof(proc_create_time), "%ld", pools[i].create_time);
snprintf(majorversion, sizeof(majorversion), "%d", pools[i].pool_majorversion);
snprintf(minorversion, sizeof(minorversion), "%d", pools[i].pool_minorversion);
snprintf(pool_counter, sizeof(pool_counter), "%d", pools[i].pool_counter);
snprintf(backend_id, sizeof(backend_pid), "%d", pools[i].backend_id);
snprintf(backend_pid, sizeof(backend_pid), "%d", pools[i].pool_backendpid);
snprintf(connected, sizeof(connected), "%d", pools[i].pool_connected);
pcp_write(frontend, "p", 1);
wsize = htonl( sizeof(code) +
strlen(proc_pid)+1 +
strlen(pools[i].database)+1 +
strlen(pools[i].username)+1 +
strlen(proc_start_time)+1 +
strlen(proc_create_time)+1 +
strlen(majorversion)+1 +
strlen(minorversion)+1 +
strlen(pool_counter)+1 +
strlen(backend_id)+1 +
strlen(backend_pid)+1 +
strlen(connected)+1 +
sizeof(int));
pcp_write(frontend, &wsize, sizeof(int));
pcp_write(frontend, code, sizeof(code));
pcp_write(frontend, proc_pid, strlen(proc_pid)+1);
pcp_write(frontend, pools[i].database, strlen(pools[i].database)+1);
pcp_write(frontend, pools[i].username, strlen(pools[i].username)+1);
pcp_write(frontend, proc_start_time, strlen(proc_start_time)+1);
pcp_write(frontend, proc_create_time, strlen(proc_create_time)+1);
pcp_write(frontend, majorversion, strlen(majorversion)+1);
pcp_write(frontend, minorversion, strlen(minorversion)+1);
pcp_write(frontend, pool_counter, strlen(pool_counter)+1);
pcp_write(frontend, backend_id, strlen(backend_id)+1);
pcp_write(frontend, backend_pid, strlen(backend_pid)+1);
pcp_write(frontend, connected, strlen(connected)+1);
do_pcp_flush(frontend);
}
pcp_write(frontend, "p", 1);
wsize = htonl(sizeof(fin_code) +
sizeof(int));
pcp_write(frontend, &wsize, sizeof(int));
pcp_write(frontend, fin_code, sizeof(fin_code));
do_pcp_flush(frontend);
ereport(DEBUG1,
(errmsg("PCP informing process info"),
errdetail("retrieved process information from shared memory")));
pfree(pools);
}
}
