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);
}
}
void pools_reporting(POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend)
{
static short num_fields = 12;
static char *field_names[] = {"pool_pid", "start_time", "pool_id", "backend_id", "database", "username", "create_time",
"majorversion", "minorversion", "pool_counter", "pool_backendpid", "pool_connected"};
short s;
int len;
int i;
static unsigned char nullmap[2] = {0xff, 0xff};
int nbytes = (num_fields + 7)/8;
int nrows;
int size;
int hsize;
char proc_pid[16];
char pool_id[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];
POOL_REPORT_POOLS *pools = get_pools(&nrows);
send_row_description(frontend, backend, num_fields, field_names);
if (MAJOR(backend) == PROTO_MAJOR_V2) hsize = 4;
else hsize = 0;
/* ascii row */
for (i=0;i<nrows;i++)
{
snprintf(proc_pid, sizeof(proc_pid), "%d", pools[i].pool_pid);
snprintf(pool_id, sizeof(pool_id), "%d", pools[i].pool_id);
if (pools[i].start_time)
strftime(proc_start_time, POOLCONFIG_MAXDATELEN, "%Y-%m-%d %H:%M:%S", localtime(&pools[i].start_time));
else
*proc_start_time = '\0';
if (pools[i].create_time)
strftime(proc_create_time, POOLCONFIG_MAXDATELEN, "%Y-%m-%d %H:%M:%S", localtime(&pools[i].create_time));
else
*proc_create_time = '\0';
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);
if (MAJOR(backend) == PROTO_MAJOR_V2)
{
pool_write(frontend, "D", 1);
pool_write_and_flush(frontend, nullmap, nbytes);
}
else
{
pool_write(frontend, "D", 1);
len = 6; /* int32 + int16; */
len += 4 + strlen(proc_pid); /* int32 + data */
len += 4 + strlen(proc_start_time); /* int32 + data */
len += 4 + strlen(pool_id); /* int32 + data */
len += 4 + strlen(backend_id); /* int32 + data */
len += 4 + strlen(pools[i].database); /* int32 + data */
len += 4 + strlen(pools[i].username); /* int32 + data */
len += 4 + strlen(proc_create_time); /* int32 + data */
len += 4 + strlen(majorversion); /* int32 + data */
len += 4 + strlen(minorversion); /* int32 + data */
len += 4 + strlen(pool_counter); /* int32 + data */
len += 4 + strlen(backend_pid); /* int32 + data */
len += 4 + strlen(connected); /* int32 + data */
len = htonl(len);
pool_write(frontend, &len, sizeof(len));
s = htons(num_fields);
pool_write(frontend, &s, sizeof(s));
}
len = strlen(proc_pid);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, proc_pid, len);
len = strlen(proc_start_time);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, proc_start_time, len);
len = strlen(pool_id);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, pool_id, len);
len = strlen(backend_id);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, backend_id, len);
len = strlen(pools[i].database);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, pools[i].database, len);
len = strlen(pools[i].username);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, pools[i].username, len);
len = strlen(proc_create_time);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, proc_create_time, len);
len = strlen(majorversion);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, majorversion, len);
len = strlen(minorversion);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, minorversion, len);
len = strlen(pool_counter);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, pool_counter, len);
len = strlen(backend_pid);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, backend_pid, len);
len = strlen(connected);
size = htonl(len+hsize);
pool_write(frontend, &size, sizeof(size));
pool_write(frontend, connected, len);
}
send_complete_and_ready(frontend, backend, nrows);
free(pools);
}
