/**
* Writes a response from srun to the client
*/
static int
cse_write_response(stream_t *s, int len, request_rec *r)
{
while (len > 0) {
int writelen;
int sentlen;
if (s->read_length <= s->read_offset && cse_fill_buffer(s) < 0)
return -1;
writelen = s->read_length - s->read_offset;
if (len < writelen)
writelen = len;
while (writelen > 0) {
sentlen = ap_rwrite(s->read_buf + s->read_offset, writelen, r);
if (sentlen < 0) {
cse_close(s, "write");
return -1;
}
writelen -= sentlen;
s->read_offset += sentlen;
len -= sentlen;
}
}
return 1;
}
/**
* Print the statistics for each JVM.
*/
static void
jvm_status(cluster_t *cluster, request_rec *r)
{
int i;
stream_t s;
ap_rputs("<center><table border=2 width='80%'>\n", r);
ap_rputs("<tr><th width=\"30%\">Host</th>\n", r);
ap_rputs(" <th>Active</th>\n", r);
ap_rputs(" <th>Pooled</th>\n", r);
ap_rputs(" <th>Connect<br>Timeout</th>\n", r);
ap_rputs(" <th>Live<br>Time</th>\n", r);
ap_rputs(" <th>Dead<br>Time</th>\n", r);
ap_rputs("</tr>\n", r);
for (; cluster; cluster = cluster->next) {
for (i = 0; i < cluster->srun_capacity; i++) {
cluster_srun_t *cluster_srun = cluster->srun_list + i;
srun_t *srun = cluster_srun->srun;
int port;
int pool_count;
if (! srun)
continue;
port = srun->port;
pool_count = ((srun->conn_head - srun->conn_tail + CONN_POOL_SIZE) %
CONN_POOL_SIZE);
ap_rputs("<tr>", r);
if (! cse_open(&s, cluster, cluster_srun, r->pool, 0)) {
ap_rprintf(r, "<td bgcolor='#ff6666'>%d. %s:%d%s (down)</td>",
cluster_srun->index + 1,
srun->hostname ? srun->hostname : "localhost",
port, cluster_srun->is_backup ? "*" : "");
}
else {
ap_rprintf(r, "<td bgcolor='#66ff66'>%d. %s:%d%s (ok)</td>",
cluster_srun->index + 1,
srun->hostname ? srun->hostname : "localhost",
port, cluster_srun->is_backup ? "*" : "");
}
/* This needs to be close, because cse_open doesn't use recycle. */
cse_close(&s, "caucho-status");
LOG(("close\n"));
ap_rprintf(r, "<td align=right>%d</td><td align=right>%d</td>",
srun->active_sockets, pool_count);
ap_rprintf(r, "<td align=right>%d</td><td align=right>%d</td><td align=right>%d</td>",
srun->connect_timeout, srun->live_time, srun->dead_time);
ap_rputs("</tr>\n", r);
}
}
ap_rputs("</table></center>\n", r);
}
/**
* Handle a request.
*/
static int
caucho_request(request_rec *r, config_t *config, resin_host_t *host,
unsigned int now)
{
stream_t s;
int retval;
int code = -1;
int session_index;
int backup_index = 0;
char *ip;
srun_t *srun;
if ((retval = ap_setup_client_block(r, REQUEST_CHUNKED_DECHUNK)))
return retval;
session_index = get_session_index(config, r, &backup_index);
ip = r->connection->REMOTE_IP;
if (host) {
}
else if (config->manual_host) {
host = config->manual_host;
}
else {
host = cse_match_host(config,
ap_get_server_name(r),
ap_get_server_port(r),
now);
}
LOG(("%s:%d:caucho_request(): session index: %d\n",
__FILE__, __LINE__, session_index));
if (! host) {
ERR(("%s:%d:caucho_request(): no host: %p\n",
__FILE__, __LINE__, host));
return HTTP_SERVICE_UNAVAILABLE;
}
else if (! cse_open_connection(&s, &host->cluster,
session_index, backup_index,
now, r->pool)) {
ERR(("%s:%d:caucho_request(): no connection: cluster(%p)\n",
__FILE__, __LINE__, &host->cluster));
return HTTP_SERVICE_UNAVAILABLE;
}
srun = s.cluster_srun->srun;
apr_thread_mutex_lock(srun->lock);
srun->active_sockets++;
apr_thread_mutex_unlock(srun->lock);
code = write_request(&s, r, config, session_index, backup_index);
apr_thread_mutex_lock(srun->lock);
srun->active_sockets--;
apr_thread_mutex_unlock(srun->lock);
/* on failure, do not failover but simply fail */
if (code == HMUX_QUIT)
cse_free_idle(&s, now);
else
cse_close(&s, "no reuse");
if (code != HMUX_QUIT && code != HMUX_EXIT) {
ERR(("%s:%d:caucho_request(): protocol failure code:%d\n",
__FILE__, __LINE__, code));
return HTTP_SERVICE_UNAVAILABLE;
}
else if (r->status == HTTP_SERVICE_UNAVAILABLE) {
cse_close(&s, "close from 503");
cse_srun_unavail(srun, now);
return HTTP_SERVICE_UNAVAILABLE;
}
else {
/*
* See pages like jms/index.xtp
int status = r->status;
r->status = HTTP_OK;
return status;
*/
return OK;
}
}
/**
* Handle a request.
*/
static int
caucho_request(request_rec *r)
{
config_t *config = cse_get_module_config(r);
resin_host_t *host = 0;
stream_t s;
int retval;
int keepalive = 0;
int reuse;
int session_index;
int backup_index;
char *ip;
time_t now = r->request_time;
char *session_id = 0;
if (! config)
return HTTP_SERVICE_UNAVAILABLE;
if ((retval = ap_setup_client_block(r, REQUEST_CHUNKED_DECHUNK)))
return retval;
/* ap_soft_timeout("servlet request", r); */
if (r->request_config && ! *config->alt_session_url_prefix &&
((session_id = ap_get_module_config(r->request_config, &caucho_module)) ||
r->prev &&
(session_id = ap_get_module_config(r->prev->request_config, &caucho_module)))) {
/* *session_id = *config->session_url_prefix; */
}
session_index = get_session_index(config, r, &backup_index);
ip = r->connection->remote_ip;
if (host) {
}
else if (config->manual_host)
host = config->manual_host;
else {
host = cse_match_host(config,
ap_get_server_name(r),
ap_get_server_port(r),
now);
}
if (! host ||
! cse_open_connection(&s, &host->cluster, session_index, backup_index,
now, r->pool)) {
return HTTP_SERVICE_UNAVAILABLE;
}
reuse = write_request(&s, r, config, &host->cluster, &keepalive,
session_index, backup_index,
ip, session_id);
/*
ap_kill_timeout(r);
*/
ap_rflush(r);
if (reuse == HMUX_QUIT)
cse_recycle(&s, now);
else
cse_close(&s, "no reuse");
if (reuse == HTTP_SERVICE_UNAVAILABLE)
return reuse;
else
return OK;
}
