/*
* flush write buffer and degenerate/failover if error occurs
*/
int pool_flush(POOL_CONNECTION *cp)
{
if (pool_flush_it(cp) == -1)
{
if (cp->isbackend)
{
/* if fail_over_on_backend_erro is true, then trigger failover */
if (pool_config->fail_over_on_backend_error)
{
notice_backend_error(cp->db_node_id);
child_exit(1);
}
else
return -1;
}
else
{
/*
* ignore error on frontend. we need to continue the
* processing with backends
*/
return 0;
}
}
return 0;
}
/*
* flush write buffer and degenerate/failover if error occurs
*/
int pool_flush(POOL_CONNECTION *cp)
{
if (pool_flush_it(cp) == -1)
{
if (cp->isbackend)
{
/* if fail_over_on_backend_erro is true, then trigger failover */
if (pool_config->fail_over_on_backend_error)
{
notice_backend_error(cp->db_node_id);
child_exit(1);
}
else
return -1;
}
else
{
/*
* If we are in replication mode, we need to continue the
* processing with backends to keep consistency among
* backends, thus ignore error.
*/
if (REPLICATION)
return 0;
else
return -1;
}
}
return 0;
}
static POOL_CONNECTION_POOL_SLOT *create_cp(POOL_CONNECTION_POOL_SLOT *cp, int secondary_backend)
{
int fd;
if (secondary_backend)
{
if (*pool_config.secondary_backend_host_name == '\0')
fd = connect_unix_domain_socket(1);
else
fd = connect_inet_domain_socket(1);
}
else
{
if (*pool_config.current_backend_host_name == '\0')
fd = connect_unix_domain_socket(0);
else
fd = connect_inet_domain_socket(0);
}
if (fd < 0)
{
/* fatal error, notice to parent and exit */
notice_backend_error(!secondary_backend);
exit(1);
}
cp->con = pool_open(fd);
cp->closetime = 0;
return cp;
}
int pool_ssl_write(POOL_CONNECTION *cp, const void *buf, int size) {
ereport(WARNING,
(errmsg("pool_ssl: SSL i/o called but SSL support is not available")));
notice_backend_error(cp->db_node_id);
child_exit(1);
return -1; /* never reached */
}
/*
* create actual connections to backends
*/
static POOL_CONNECTION_POOL *new_connection(POOL_CONNECTION_POOL *p)
{
POOL_CONNECTION_POOL_SLOT *s;
int active_backend_count = 0;
int i;
for (i=0;i<NUM_BACKENDS;i++)
{
pool_debug("new_connection: connecting %d backend", i);
if (!VALID_BACKEND(i))
{
pool_debug("new_connection: skipping slot %d because backend_status = %d",
i, BACKEND_INFO(i).backend_status);
continue;
}
s = malloc(sizeof(POOL_CONNECTION_POOL_SLOT));
if (s == NULL)
{
pool_error("new_connection: malloc() failed");
return NULL;
}
if (create_cp(s, i) == NULL)
{
/* connection failed. mark this backend down */
pool_error("new_connection: create_cp() failed");
/* If fail_over_on_backend_error is true, do failover.
* Otherwise, just exit this session.
*/
if (pool_config->fail_over_on_backend_error)
{
notice_backend_error(i);
}
else
{
pool_log("new_connection: do not failover because fail_over_on_backend_error is off");
}
child_exit(1);
}
p->info[i].create_time = time(NULL);
p->slots[i] = s;
if (pool_init_params(&s->con->params))
{
return NULL;
}
BACKEND_INFO(i).backend_status = CON_UP;
active_backend_count++;
}
if (active_backend_count > 0)
{
return p;
}
return NULL;
}
/*
* child main loop
*/
void do_child(int unix_fd, int inet_fd)
{
POOL_CONNECTION *frontend;
POOL_CONNECTION_POOL *backend;
struct timeval now;
struct timezone tz;
struct timeval timeout;
static int connected; /* non 0 if has been accepted connections from frontend */
int connections_count = 0; /* used if child_max_connections > 0 */
int found;
char psbuf[NI_MAXHOST + 128];
pool_debug("I am %d", getpid());
/* Identify myself via ps */
init_ps_display("", "", "", "");
/* set up signal handlers */
signal(SIGALRM, SIG_DFL);
signal(SIGTERM, die);
signal(SIGINT, die);
signal(SIGHUP, reload_config_handler);
signal(SIGQUIT, die);
signal(SIGCHLD, SIG_DFL);
signal(SIGUSR1, close_idle_connection);
signal(SIGUSR2, wakeup_handler);
signal(SIGPIPE, SIG_IGN);
#ifdef NONE_BLOCK
/* set listen fds to none-blocking */
pool_set_nonblock(unix_fd);
if (inet_fd)
{
pool_set_nonblock(inet_fd);
}
#endif
/* Initialize my backend status */
pool_initialize_private_backend_status();
/* Initialize per process context */
pool_init_process_context();
/* initialize random seed */
gettimeofday(&now, &tz);
#if defined(sun) || defined(__sun)
srand((unsigned int) now.tv_usec);
#else
srandom((unsigned int) now.tv_usec);
#endif
/* initialize system db connection */
init_system_db_connection();
/* initialize connection pool */
if (pool_init_cp())
{
child_exit(1);
}
/*
* Open pool_passwd in child process. This is necessary to avoid the
* file descriptor race condition reported in [pgpool-general: 1141].
*/
if (strcmp("", pool_config->pool_passwd))
{
pool_reopen_passwd_file();
}
timeout.tv_sec = pool_config->child_life_time;
timeout.tv_usec = 0;
for (;;)
{
StartupPacket *sp;
idle = 1;
/* pgpool stop request already sent? */
check_stop_request();
/* Check if restart request is set because of failback event
* happend. If so, exit myself with exit code 1 to be
* restarted by pgpool parent.
*/
if (pool_get_my_process_info()->need_to_restart)
{
pool_log("do_child: failback event found. restart myself.");
pool_get_my_process_info()->need_to_restart = 0;
child_exit(1);
}
accepted = 0;
/* perform accept() */
frontend = do_accept(unix_fd, inet_fd, &timeout);
if (frontend == NULL) /* connection request from frontend timed out */
{
/* check select() timeout */
if (connected && pool_config->child_life_time > 0 &&
timeout.tv_sec == 0 && timeout.tv_usec == 0)
{
pool_debug("child life %d seconds expired", pool_config->child_life_time);
/*
* Doesn't need to call this. child_exit() calls it.
* send_frontend_exits();
*/
child_exit(2);
}
continue;
}
/* set frontend fd to blocking */
pool_unset_nonblock(frontend->fd);
/* reset busy flag */
idle = 0;
/* check backend timer is expired */
if (backend_timer_expired)
{
pool_backend_timer();
backend_timer_expired = 0;
}
/* read the startup packet */
retry_startup:
sp = read_startup_packet(frontend);
if (sp == NULL)
{
/* failed to read the startup packet. return to the accept() loop */
pool_close(frontend);
connection_count_down();
continue;
}
/* cancel request? */
if (sp->major == 1234 && sp->minor == 5678)
{
cancel_request((CancelPacket *)sp->startup_packet);
pool_close(frontend);
pool_free_startup_packet(sp);
connection_count_down();
continue;
}
/* SSL? */
if (sp->major == 1234 && sp->minor == 5679 && !frontend->ssl_active)
{
pool_debug("SSLRequest from client");
pool_ssl_negotiate_serverclient(frontend);
goto retry_startup;
}
if (pool_config->enable_pool_hba)
{
/*
* do client authentication.
* Note that ClientAuthentication does not return if frontend
* was rejected; it simply terminates this process.
*/
frontend->protoVersion = sp->major;
frontend->database = strdup(sp->database);
if (frontend->database == NULL)
{
pool_error("do_child: strdup failed: %s\n", strerror(errno));
child_exit(1);
}
frontend->username = strdup(sp->user);
if (frontend->username == NULL)
{
pool_error("do_child: strdup failed: %s\n", strerror(errno));
child_exit(1);
}
ClientAuthentication(frontend);
}
/*
* Ok, negotiation with frontend has been done. Let's go to the
* next step. Connect to backend if there's no existing
* connection which can be reused by this frontend.
* Authentication is also done in this step.
*/
/* Check if restart request is set because of failback event
* happend. If so, close idle connections to backend and make
* a new copy of backend status.
*/
if (pool_get_my_process_info()->need_to_restart)
{
pool_log("do_child: failback event found. discard existing connections");
pool_get_my_process_info()->need_to_restart = 0;
close_idle_connection(0);
pool_initialize_private_backend_status();
}
/*
* if there's no connection associated with user and database,
* we need to connect to the backend and send the startup packet.
*/
/* look for existing connection */
found = 0;
backend = pool_get_cp(sp->user, sp->database, sp->major, 1);
if (backend != NULL)
{
found = 1;
/* existing connection associated with same user/database/major found.
* however we should make sure that the startup packet contents are identical.
* OPTION data and others might be different.
*/
if (sp->len != MASTER_CONNECTION(backend)->sp->len)
{
pool_debug("do_child: connection exists but startup packet length is not identical");
found = 0;
}
else if(memcmp(sp->startup_packet, MASTER_CONNECTION(backend)->sp->startup_packet, sp->len) != 0)
{
pool_debug("do_child: connection exists but startup packet contents is not identical");
found = 0;
}
if (found == 0)
{
/* we need to discard existing connection since startup packet is different */
pool_discard_cp(sp->user, sp->database, sp->major);
backend = NULL;
}
}
if (backend == NULL)
{
/* create a new connection to backend */
if ((backend = connect_backend(sp, frontend)) == NULL)
{
connection_count_down();
continue;
}
}
else
{
/* reuse existing connection */
if (!connect_using_existing_connection(frontend, backend, sp))
continue;
}
connected = 1;
/* show ps status */
sp = MASTER_CONNECTION(backend)->sp;
snprintf(psbuf, sizeof(psbuf), "%s %s %s idle",
sp->user, sp->database, remote_ps_data);
set_ps_display(psbuf, false);
/*
* Initialize per session context
*/
pool_init_session_context(frontend, backend);
/* Mark this connection pool is connected from frontend */
pool_coninfo_set_frontend_connected(pool_get_process_context()->proc_id, pool_pool_index());
/* query process loop */
for (;;)
{
POOL_STATUS status;
status = pool_process_query(frontend, backend, 0);
sp = MASTER_CONNECTION(backend)->sp;
switch (status)
{
/* client exits */
case POOL_END:
/*
* do not cache connection if:
* pool_config->connection_cahe == 0 or
* database name is template0, template1, postgres or regression
*/
if (pool_config->connection_cache == 0 ||
!strcmp(sp->database, "template0") ||
!strcmp(sp->database, "template1") ||
!strcmp(sp->database, "postgres") ||
!strcmp(sp->database, "regression"))
{
reset_connection();
pool_close(frontend);
pool_send_frontend_exits(backend);
pool_discard_cp(sp->user, sp->database, sp->major);
}
else
{
POOL_STATUS status1;
/* send reset request to backend */
status1 = pool_process_query(frontend, backend, 1);
pool_close(frontend);
/* if we detect errors on resetting connection, we need to discard
* this connection since it might be in unknown status
*/
if (status1 != POOL_CONTINUE)
{
pool_debug("error in resetting connections. discarding connection pools...");
pool_send_frontend_exits(backend);
pool_discard_cp(sp->user, sp->database, sp->major);
}
else
pool_connection_pool_timer(backend);
}
break;
/* error occurred. discard backend connection pool
and disconnect connection to the frontend */
case POOL_ERROR:
pool_log("do_child: exits with status 1 due to error");
child_exit(1);
break;
/* fatal error occurred. just exit myself... */
case POOL_FATAL:
notice_backend_error(1);
child_exit(1);
break;
/* not implemented yet */
case POOL_IDLE:
do_accept(unix_fd, inet_fd, &timeout);
pool_debug("accept while idle");
break;
default:
break;
}
if (status != POOL_CONTINUE)
break;
}
/* Destroy session context */
pool_session_context_destroy();
/* Mark this connection pool is not connected from frontend */
pool_coninfo_unset_frontend_connected(pool_get_process_context()->proc_id, pool_pool_index());
accepted = 0;
connection_count_down();
timeout.tv_sec = pool_config->child_life_time;
timeout.tv_usec = 0;
/* increment queries counter if necessary */
if ( pool_config->child_max_connections > 0 )
connections_count++;
/* check if maximum connections count for this child reached */
if ( ( pool_config->child_max_connections > 0 ) &&
( connections_count >= pool_config->child_max_connections ) )
{
pool_log("child exiting, %d connections reached", pool_config->child_max_connections);
send_frontend_exits();
child_exit(2);
}
}
child_exit(0);
}
/*
* read a string until EOF or NULL is encountered.
* if line is not 0, read until new line is encountered.
*/
char *pool_read_string(POOL_CONNECTION *cp, int *len, int line)
{
int readp;
int readsize;
int readlen;
int strlength;
int flag;
int consume_size;
#ifdef DEBUG
static char pbuf[READBUFSZ];
#endif
*len = 0;
readp = 0;
/* initialize read buffer */
if (cp->sbufsz == 0)
{
cp->sbuf = malloc(READBUFSZ);
if (cp->sbuf == NULL)
{
pool_error("pool_read_string: malloc failed");
return NULL;
}
cp->sbufsz = READBUFSZ;
*cp->sbuf = '\0';
}
/* any pending data? */
if (cp->len)
{
if (line)
strlength = mystrlinelen(cp->hp+cp->po, cp->len, &flag);
else
strlength = mystrlen(cp->hp+cp->po, cp->len, &flag);
/* buffer is too small? */
if ((strlength + 1) > cp->sbufsz)
{
cp->sbufsz = ((strlength+1)/READBUFSZ+1)*READBUFSZ;
cp->sbuf = realloc(cp->sbuf, cp->sbufsz);
if (cp->sbuf == NULL)
{
pool_error("pool_read_string: realloc failed");
return NULL;
}
}
/* consume pending and save to read string buffer */
consume_size = consume_pending_data(cp, cp->sbuf, strlength);
*len = strlength;
/* is the string null terminated? */
if (consume_size == strlength && !flag)
{
/* not null or line terminated.
* we need to read more since we have not encountered NULL or new line yet
*/
readsize = cp->sbufsz - strlength;
readp = strlength;
}
else
{
pool_debug("pool_read_string: read all from pending data. po:%d len:%d",
cp->po, cp->len);
return cp->sbuf;
}
} else
{
readsize = cp->sbufsz;
}
for (;;)
{
if (pool_check_fd(cp))
{
if (!IS_MASTER_NODE_ID(cp->db_node_id))
{
pool_log("pool_read_string: data is not ready in DB node:%d. abort this session",
cp->db_node_id);
exit(1);
}
else
{
pool_error("pool_read_string: pool_check_fd failed (%s)", strerror(errno));
return NULL;
}
}
if (cp->ssl_active > 0) {
readlen = pool_ssl_read(cp, cp->sbuf+readp, readsize);
} else {
readlen = read(cp->fd, cp->sbuf+readp, readsize);
}
if (readlen == -1)
{
pool_error("pool_read_string: read() failed. reason:%s", strerror(errno));
if (cp->isbackend)
{
notice_backend_error(cp->db_node_id);
child_exit(1);
}
else
{
return NULL;
}
}
else if (readlen == 0) /* EOF detected */
{
/*
* just returns an error, not trigger failover or degeneration
*/
pool_error("pool_read_string: read () EOF detected");
return NULL;
}
/* check overrun */
if (line)
strlength = mystrlinelen(cp->sbuf+readp, readlen, &flag);
else
strlength = mystrlen(cp->sbuf+readp, readlen, &flag);
if (strlength < readlen)
{
save_pending_data(cp, cp->sbuf+readp+strlength, readlen-strlength);
*len += strlength;
pool_debug("pool_read_string: total result %d with pending data po:%d len:%d", *len, cp->po, cp->len);
return cp->sbuf;
}
*len += readlen;
/* encountered null or newline? */
if (flag)
{
/* ok we have read all data */
pool_debug("pool_read_string: total result %d ", *len);
break;
}
readp += readlen;
readsize = READBUFSZ;
if ((*len+readsize) > cp->sbufsz)
{
cp->sbufsz += READBUFSZ;
cp->sbuf = realloc(cp->sbuf, cp->sbufsz);
if (cp->sbuf == NULL)
{
pool_error("pool_read_string: realloc failed");
return NULL;
}
}
}
return cp->sbuf;
}
/*
* read exactly len bytes from cp
* returns buffer address on success otherwise NULL.
*/
char *pool_read2(POOL_CONNECTION *cp, int len)
{
char *buf;
int req_size;
int alloc_size;
int consume_size;
int readlen;
req_size = cp->len + len;
if (req_size > cp->bufsz2)
{
alloc_size = ((req_size+1)/READBUFSZ+1)*READBUFSZ;
cp->buf2 = realloc(cp->buf2, alloc_size);
if (cp->buf2 == NULL)
{
pool_error("pool_read2: failed to realloc");
exit(1);
}
cp->bufsz2 = alloc_size;
}
buf = cp->buf2;
consume_size = consume_pending_data(cp, buf, len);
len -= consume_size;
buf += consume_size;
while (len > 0)
{
if (pool_check_fd(cp))
{
if (!IS_MASTER_NODE_ID(cp->db_node_id))
{
pool_log("pool_read2: data is not ready in DB node:%d. abort this session",
cp->db_node_id);
exit(1);
}
else
{
pool_error("pool_read2: pool_check_fd failed (%s)", strerror(errno));
return NULL;
}
}
if (cp->ssl_active > 0) {
readlen = pool_ssl_read(cp, buf, len);
} else {
readlen = read(cp->fd, buf, len);
}
if (readlen == -1)
{
if (errno == EINTR || errno == EAGAIN)
{
pool_debug("pool_read2: retrying due to %s", strerror(errno));
continue;
}
pool_error("pool_read2: read failed (%s)", strerror(errno));
if (cp->isbackend)
{
/* fatal error, notice to parent and exit */
notice_backend_error(cp->db_node_id);
child_exit(1);
}
else
{
return NULL;
}
}
else if (readlen == 0)
{
if (cp->isbackend)
{
pool_error("pool_read2: EOF encountered with backend");
return NULL;
#ifdef NOT_USED
/* fatal error, notice to parent and exit */
notice_backend_error(IS_MASTER_NODE_ID(cp->db_node_id));
child_exit(1);
#endif
}
else
{
/*
* if backend offers authentication method, frontend could close connection
*/
return NULL;
}
}
buf += readlen;
len -= readlen;
}
return cp->buf2;
}
/*
* read len bytes from cp
* returns 0 on success otherwise -1.
*/
int pool_read(POOL_CONNECTION *cp, void *buf, int len)
{
static char readbuf[READBUFSZ];
int consume_size;
int readlen;
consume_size = consume_pending_data(cp, buf, len);
len -= consume_size;
buf += consume_size;
while (len > 0)
{
if (pool_check_fd(cp))
{
if (!IS_MASTER_NODE_ID(cp->db_node_id))
{
pool_log("pool_read: data is not ready in DB node: %d. abort this session",
cp->db_node_id);
exit(1);
}
else
{
pool_error("pool_read: pool_check_fd failed (%s)", strerror(errno));
return -1;
}
}
if (cp->ssl_active > 0) {
readlen = pool_ssl_read(cp, readbuf, READBUFSZ);
} else {
readlen = read(cp->fd, readbuf, READBUFSZ);
}
if (readlen == -1)
{
if (errno == EINTR || errno == EAGAIN)
{
pool_debug("pool_read: retrying due to %s", strerror(errno));
continue;
}
pool_error("pool_read: read failed (%s)", strerror(errno));
if (cp->isbackend)
{
/* fatal error, notice to parent and exit */
notice_backend_error(cp->db_node_id);
child_exit(1);
}
else
{
return -1;
}
}
else if (readlen == 0)
{
if (cp->isbackend)
{
pool_error("pool_read: EOF encountered with backend");
return -1;
#ifdef NOT_USED
/* fatal error, notice to parent and exit */
notice_backend_error(IS_MASTER_NODE_ID(cp->db_node_id));
child_exit(1);
#endif
}
else
{
/*
* if backend offers authentication method, frontend could close connection
*/
return -1;
}
}
if (len < readlen)
{
/* overrun. we need to save remaining data to pending buffer */
if (save_pending_data(cp, readbuf+len, readlen-len))
return -1;
memmove(buf, readbuf, len);
break;
}
memmove(buf, readbuf, readlen);
buf += readlen;
len -= readlen;
}
return 0;
}