static void
ngx_tcp_check_clean_event(ngx_tcp_check_peer_conf_t *peer_conf)
{
ngx_connection_t *c;
c = peer_conf->pc.connection;
ngx_log_debug2(NGX_LOG_DEBUG_TCP, c->log, 0,
"tcp check clean event: index:%d, fd: %d",
peer_conf->index, c->fd);
ngx_close_connection(c);
if (peer_conf->check_timeout_ev.timer_set) {
ngx_del_timer(&peer_conf->check_timeout_ev);
}
peer_conf->state = NGX_TCP_CHECK_ALL_DONE;
if (peer_conf->check_data != NULL && peer_conf->reinit) {
peer_conf->reinit(peer_conf);
}
ngx_spinlock(&peer_conf->shm->lock, ngx_pid, 1024);
peer_conf->shm->owner = NGX_INVALID_PID;
ngx_spinlock_unlock(&peer_conf->shm->lock);
}
void
ngx_tcp_check_get_peer(ngx_uint_t index)
{
ngx_tcp_check_peer_conf_t *peer_conf;
if (check_peers_ctx == NULL || index >= check_peers_ctx->peers.nelts) {
return;
}
peer_conf = check_peers_ctx->peers.elts;
ngx_spinlock(&peer_conf[index].shm->lock, ngx_pid, 1024);
peer_conf[index].shm->business++;
peer_conf[index].shm->access_count++;
ngx_spinlock_unlock(&peer_conf[index].shm->lock);
}
void
ngx_tcp_check_free_peer(ngx_uint_t index)
{
ngx_tcp_check_peer_conf_t *peer_conf;
if (check_peers_ctx == NULL || index >= check_peers_ctx->peers.nelts) {
return;
}
peer_conf = check_peers_ctx->peers.elts;
ngx_spinlock(&peer_conf[index].shm->lock, ngx_pid, 1024);
if (peer_conf[index].shm->business > 0) {
peer_conf[index].shm->business--;
}
ngx_spinlock_unlock(&peer_conf[index].shm->lock);
}
static void
ngx_tcp_check_begin_handler(ngx_event_t *event)
{
ngx_tcp_check_peer_conf_t *peer_conf;
ngx_tcp_upstream_srv_conf_t *uscf;
if (ngx_tcp_check_need_exit()) {
return;
}
peer_conf = event->data;
uscf = peer_conf->conf;
ngx_add_timer(event, uscf->check_interval/2);
/* This process are processing the event now. */
if (peer_conf->shm->owner == ngx_pid) {
return;
}
ngx_log_debug4(NGX_LOG_DEBUG_TCP, event->log, 0,
"tcp check begin handler index:%ud, owner: %d, "
"ngx_pid: %ud, time:%d",
peer_conf->index, peer_conf->shm->owner, ngx_pid,
(ngx_current_msec - peer_conf->shm->access_time));
ngx_spinlock(&peer_conf->shm->lock, ngx_pid, 1024);
if (((ngx_current_msec - peer_conf->shm->access_time) >= uscf->check_interval) &&
peer_conf->shm->owner == NGX_INVALID_PID)
{
peer_conf->shm->owner = ngx_pid;
}
ngx_spinlock_unlock(&peer_conf->shm->lock);
if (peer_conf->shm->owner == ngx_pid) {
ngx_tcp_check_connect_handler(event);
}
}
static void
ngx_http_check_begin_handler(ngx_event_t *event)
{
ngx_msec_t interval;
ngx_http_check_peer_t *peer;
ngx_http_check_peers_t *peers;
ngx_http_check_peers_shm_t *peers_shm;
ngx_http_upstream_check_srv_conf_t *ucscf;
if (ngx_http_check_need_exit()) {
return;
}
peers = check_peers_ctx;
if (peers == NULL) {
return;
}
peers_shm = peers->peers_shm;
if (peers_shm == NULL) {
return;
}
peer = event->data;
ucscf = peer->conf;
ngx_add_timer(event, ucscf->check_interval/2);
/* This process is processing this peer now. */
if ((peer->shm->owner == ngx_pid) ||
(peer->pc.connection != NULL) ||
(peer->check_timeout_ev.timer_set)) {
return;
}
interval = ngx_current_msec - peer->shm->access_time;
ngx_log_debug5(NGX_LOG_DEBUG_HTTP, event->log, 0,
"http check begin handler index: %ud, owner: %P, "
"ngx_pid: %P, interval: %M, check_interval: %M",
peer->index, peer->shm->owner,
ngx_pid, interval,
ucscf->check_interval);
ngx_spinlock(&peer->shm->lock, ngx_pid, 1024);
if (peers_shm->generation != ngx_http_check_shm_generation) {
ngx_spinlock_unlock(&peer->shm->lock);
return;
}
if ((interval >= ucscf->check_interval)
&& peer->shm->owner == NGX_INVALID_PID)
{
peer->shm->owner = ngx_pid;
}
else if (interval >= (ucscf->check_interval << 4)) {
/* If the check peer has been untouched for 4 times of
* the check interval, activates current timer.
* The checking process may be disappeared
* in some circumstance, and the clean event will never
* be triggered. */
peer->shm->owner = ngx_pid;
peer->shm->access_time = ngx_current_msec;
}
ngx_spinlock_unlock(&peer->shm->lock);
if (peer->shm->owner == ngx_pid) {
ngx_http_check_connect_handler(event);
}
}
