Google Git
Sign in
apache / tomcat55 / ca1e1273b08d1752b1c1ec2e316a9eea6243f112 / . / connectors / jk / native / common / jk_status.c
blob: 8a6f3f38525e9e88410caab6ecb0c7a5071840e5 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: Status worker, display and manages JK workers *
* Author: Mladen Turk <mturk@jboss.com> *
* Author: Rainer Jung <rjung@apache.org> *
* Version: $Revision$ *
***************************************************************************/
#include "jk_pool.h"
#include "jk_service.h"
#include "jk_util.h"
#include "jk_worker.h"
#include "jk_status.h"
#include "jk_mt.h"
#include "jk_shm.h"
#include "jk_ajp_common.h"
#include "jk_lb_worker.h"
#include "jk_ajp13_worker.h"
#include "jk_ajp14_worker.h"
#include "jk_connect.h"
#include "jk_uri_worker_map.h"
#define HUGE_BUFFER_SIZE (8*1024)
/**
* Command line reference:
* cmd=list (default) display configuration
* cmd=show display detailed configuration
* cmd=edit form to change configuration
* cmd=update commit update configuration
* cmd=reset reset lb runtime states, or lb member runtime states
* cmd=version show only software version
* Query arguments:
* re=n (refresh time in seconds, n=0: disabled)
* w=worker (cmd should be executed for worker "worker")
* sw=sub_worker (cmd should be executed for "sub_worker" of worker "worker")
* from=lastcmd (the last viewing command was "lastcmd")
* opt=option (changes meaning of edit and list/show)
*/
#define JK_STATUS_ARG_CMD "cmd"
#define JK_STATUS_ARG_MIME "mime"
#define JK_STATUS_ARG_FROM "from"
#define JK_STATUS_ARG_REFRESH "re"
#define JK_STATUS_ARG_WORKER "w"
#define JK_STATUS_ARG_SUB_WORKER "sw"
#define JK_STATUS_ARG_ATTRIBUTE "att"
#define JK_STATUS_ARG_MULT_VALUE_BASE "val"
#define JK_STATUS_ARG_OPTIONS "opt"
#define JK_STATUS_ARG_OPTION_NO_MEMBERS 0x0001
#define JK_STATUS_ARG_OPTION_NO_MAPS 0x0002
#define JK_STATUS_ARG_OPTION_NO_LEGEND 0x0004
#define JK_STATUS_ARG_OPTION_NO_LB 0x0008
#define JK_STATUS_ARG_OPTION_NO_AJP 0x0010
#define JK_STATUS_ARG_OPTION_READ_ONLY 0x0020
#define JK_STATUS_ARG_LB_RETRIES ("lr")
#define JK_STATUS_ARG_LB_RECOVER_TIME ("lt")
#define JK_STATUS_ARG_LB_STICKY ("ls")
#define JK_STATUS_ARG_LB_STICKY_FORCE ("lf")
#define JK_STATUS_ARG_LB_METHOD ("lm")
#define JK_STATUS_ARG_LB_LOCK ("ll")
#define JK_STATUS_ARG_LB_TEXT_RETRIES "Retries"
#define JK_STATUS_ARG_LB_TEXT_RECOVER_TIME "Recover Wait Time"
#define JK_STATUS_ARG_LB_TEXT_STICKY "Sticky Sessions"
#define JK_STATUS_ARG_LB_TEXT_STICKY_FORCE "Force Sticky Sessions"
#define JK_STATUS_ARG_LB_TEXT_METHOD "LB Method"
#define JK_STATUS_ARG_LB_TEXT_LOCK "Locking"
#define JK_STATUS_ARG_LBM_ACTIVATION ("wa")
#define JK_STATUS_ARG_LBM_FACTOR ("wf")
#define JK_STATUS_ARG_LBM_ROUTE ("wn")
#define JK_STATUS_ARG_LBM_REDIRECT ("wr")
#define JK_STATUS_ARG_LBM_DOMAIN ("wc")
#define JK_STATUS_ARG_LBM_DISTANCE ("wd")
#define JK_STATUS_ARG_LBM_TEXT_ACTIVATION "Activation"
#define JK_STATUS_ARG_LBM_TEXT_FACTOR "LB Factor"
#define JK_STATUS_ARG_LBM_TEXT_ROUTE "Route"
#define JK_STATUS_ARG_LBM_TEXT_REDIRECT "Redirect Route"
#define JK_STATUS_ARG_LBM_TEXT_DOMAIN "Cluster Domain"
#define JK_STATUS_ARG_LBM_TEXT_DISTANCE "Distance"
#define JK_STATUS_CMD_UNKNOWN (0)
#define JK_STATUS_CMD_LIST (1)
#define JK_STATUS_CMD_SHOW (2)
#define JK_STATUS_CMD_EDIT (3)
#define JK_STATUS_CMD_UPDATE (4)
#define JK_STATUS_CMD_RESET (5)
#define JK_STATUS_CMD_VERSION (6)
#define JK_STATUS_CMD_RECOVER (7)
#define JK_STATUS_CMD_DEF (JK_STATUS_CMD_LIST)
#define JK_STATUS_CMD_MAX (JK_STATUS_CMD_RECOVER)
#define JK_STATUS_CMD_TEXT_UNKNOWN ("unknown")
#define JK_STATUS_CMD_TEXT_LIST ("list")
#define JK_STATUS_CMD_TEXT_SHOW ("show")
#define JK_STATUS_CMD_TEXT_EDIT ("edit")
#define JK_STATUS_CMD_TEXT_UPDATE ("update")
#define JK_STATUS_CMD_TEXT_RESET ("reset")
#define JK_STATUS_CMD_TEXT_VERSION ("version")
#define JK_STATUS_CMD_TEXT_RECOVER ("recover")
#define JK_STATUS_CMD_TEXT_DEF (JK_STATUS_CMD_TEXT_LIST)
#define JK_STATUS_MIME_UNKNOWN (0)
#define JK_STATUS_MIME_HTML (1)
#define JK_STATUS_MIME_XML (2)
#define JK_STATUS_MIME_TXT (3)
#define JK_STATUS_MIME_PROP (4)
#define JK_STATUS_MIME_DEF (JK_STATUS_MIME_HTML)
#define JK_STATUS_MIME_MAX (JK_STATUS_MIME_PROP)
#define JK_STATUS_MIME_TEXT_UNKNOWN ("unknown")
#define JK_STATUS_MIME_TEXT_HTML ("html")
#define JK_STATUS_MIME_TEXT_XML ("xml")
#define JK_STATUS_MIME_TEXT_TXT ("txt")
#define JK_STATUS_MIME_TEXT_PROP ("prop")
#define JK_STATUS_MIME_TEXT_DEF (JK_STATUS_MIME_TEXT_HTML)
#define JK_STATUS_MASK_ACTIVE 0x000000FF
#define JK_STATUS_MASK_DISABLED 0x0000FF00
#define JK_STATUS_MASK_STOPPED 0x00FF0000
#define JK_STATUS_MASK_OK 0x00010101
#define JK_STATUS_MASK_NA 0x00020202
#define JK_STATUS_MASK_BUSY 0x00040404
#define JK_STATUS_MASK_RECOVER 0x00080808
#define JK_STATUS_MASK_ERROR 0x00101010
#define JK_STATUS_MASK_GOOD_DEF 0x0000000F
#define JK_STATUS_MASK_BAD_DEF 0x00FF1010
#define JK_STATUS_WAIT_AFTER_UPDATE "3"
#define JK_STATUS_REFRESH_DEF "10"
#define JK_STATUS_ESC_CHARS ("<>?&")
#define JK_STATUS_HEAD "<!DOCTYPE HTML PUBLIC \"-//W3C//" \
"DTD HTML 3.2 Final//EN\">\n" \
"<html><head><title>JK Status Manager</title>"
#define JK_STATUS_COPYRIGHT "Copyright &#169; 1999-2006, The Apache Software Foundation<br />" \
"Licensed under the <a href=\"http://www.apache.org/licenses/LICENSE-2.0\">" \
"Apache License, Version 2.0</a>."
#define JK_STATUS_HEND "</head>\n<body>\n"
#define JK_STATUS_BEND "</body>\n</html>\n"
#define JK_STATUS_XMLH "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
#define JK_STATUS_NS_DEF "jk:"
#define JK_STATUS_XMLNS_DEF "xmlns:jk=\"http://tomcat.apache.org\""
#define JK_STATUS_PREFIX_DEF "worker"
#define JK_STATUS_FORM_START "<form method=\"%s\" action=\"%s\">\n"
#define JK_STATUS_FORM_HIDDEN_INT "<input type=\"hidden\" name=\"%s\" value=\"%d\"/>\n"
#define JK_STATUS_FORM_HIDDEN_STRING "<input type=\"hidden\" name=\"%s\" value=\"%s\"/>\n"
#define JK_STATUS_TABLE_HEAD_3_STRING "<tr><th>%s</th><th>%s</th><th>%s</th></tr>\n"
#define JK_STATUS_TABLE_ROW_3_STRING "<tr><td>%s</td><td>%s</td><td>%s</td></tr>\n"
#define JK_STATUS_SHOW_AJP_HEAD "<tr>" \
"<th>Type</th>" \
"<th>Host</th>" \
"<th>Addr</th>" \
"</tr>\n"
#define JK_STATUS_SHOW_AJP_ROW "<tr>" \
"<td>%s</td>" \
"<td>%s:%d</td>" \
"<td>%s</td>" \
"</tr>\n"
#define JK_STATUS_SHOW_LB_HEAD "<tr>" \
"<th>Type</th>" \
"<th>" JK_STATUS_ARG_LB_TEXT_STICKY "</th>" \
"<th>" JK_STATUS_ARG_LB_TEXT_STICKY_FORCE "</th>" \
"<th>" JK_STATUS_ARG_LB_TEXT_RETRIES "</th>" \
"<th>" JK_STATUS_ARG_LB_TEXT_METHOD "</th>" \
"<th>" JK_STATUS_ARG_LB_TEXT_LOCK "</th>" \
"<th>" JK_STATUS_ARG_LB_TEXT_RECOVER_TIME "</th>" \
"</tr>\n"
#define JK_STATUS_SHOW_LB_ROW "<tr>" \
"<td>%s</td>" \
"<td>%s</td>" \
"<td>%s</td>" \
"<td>%d</td>" \
"<td>%s</td>" \
"<td>%s</td>" \
"<td>%d</td>" \
"</tr>\n"
#define JK_STATUS_SHOW_MEMBER_HEAD "<tr>" \
"<th>&nbsp;</th><th>Name</th><th>Type</th>" \
"<th>Host</th><th>Addr</th>" \
"<th>Act</th><th>Stat</th>" \
"<th>D</th><th>F</th><th>M</th>" \
"<th>V</th><th>Acc</th>" \
"<th>Err</th><th>CE</th>" \
"<th>Wr</th><th>Rd</th><th>Busy</th><th>Max</th>" \
"<th>" JK_STATUS_ARG_LBM_TEXT_ROUTE "</th>" \
"<th>RR</th><th>Cd</th><th>Rs</th>" \
"</tr>\n"
#define JK_STATUS_SHOW_MEMBER_ROW "<td>%s</td>" \
"<td>%s</td>" \
"<td>%s:%d</td>" \
"<td>%s</td>" \
"<td>%s</td>" \
"<td>%s</td>" \
"<td>%d</td>" \
"<td>%d</td>" \
"<td>%" JK_UINT64_T_FMT "</td>" \
"<td>%" JK_UINT64_T_FMT "</td>" \
"<td>%" JK_UINT64_T_FMT "</td>" \
"<td>%" JK_UINT32_T_FMT "</td>" \
"<td>%" JK_UINT32_T_FMT "</td>" \
"<td>%s</td>" \
"<td>%s</td>" \
"<td>%d</td>" \
"<td>%d</td>" \
"<td>%s</td>" \
"<td>%s</td>" \
"<td>%s</td>" \
"<td>%d/%d</td>" \
"</tr>\n"
typedef struct status_worker status_worker_t;
struct status_endpoint
{
status_worker_t *worker;
jk_map_t *req_params;
char *msg;
jk_endpoint_t endpoint;
};
typedef struct status_endpoint status_endpoint_t;
struct status_worker
{
jk_pool_t p;
jk_pool_atom_t buf[TINY_POOL_SIZE];
const char *name;
const char *css;
const char *ns;
const char *xmlns;
const char *doctype;
const char *prefix;
int read_only;
char **user_names;
unsigned int num_of_users;
int user_case_insensitive;
jk_uint32_t good_mask;
jk_uint32_t bad_mask;
jk_worker_t worker;
jk_worker_env_t *we;
};
static const char *worker_type[] = {
"unknown",
"ajp12",
"ajp13",
"ajp14",
"jni",
"lb",
"status",
NULL
};
static const char *headers_names[] = {
"Content-Type",
"Cache-Control",
"Pragma",
NULL
};
static const char *cmd_type[] = {
JK_STATUS_CMD_TEXT_UNKNOWN,
JK_STATUS_CMD_TEXT_LIST,
JK_STATUS_CMD_TEXT_SHOW,
JK_STATUS_CMD_TEXT_EDIT,
JK_STATUS_CMD_TEXT_UPDATE,
JK_STATUS_CMD_TEXT_RESET,
JK_STATUS_CMD_TEXT_VERSION,
JK_STATUS_CMD_TEXT_RECOVER,
NULL
};
static const char *mime_type[] = {
JK_STATUS_MIME_TEXT_UNKNOWN,
JK_STATUS_MIME_TEXT_HTML,
JK_STATUS_MIME_TEXT_XML,
JK_STATUS_MIME_TEXT_TXT,
JK_STATUS_MIME_TEXT_PROP,
NULL
};
#define HEADERS_NO_CACHE "no-cache", "no-cache", NULL
static const char *headers_vhtml[] = {
"text/html",
HEADERS_NO_CACHE
};
static const char *headers_vxml[] = {
"text/xml",
HEADERS_NO_CACHE
};
static const char *headers_vtxt[] = {
"text/plain",
HEADERS_NO_CACHE
};
static void jk_puts(jk_ws_service_t *s, const char *str)
{
if (str)
s->write(s, str, (unsigned int)strlen(str));
else
s->write(s, "(null)", 6);
}
static void jk_putv(jk_ws_service_t *s, ...)
{
va_list va;
const char *str;
va_start(va, s);
while (1) {
str = va_arg(va, const char *);
if (str == NULL)
break;
s->write(s, str, (unsigned int)strlen(str));
}
va_end(va);
}
static int jk_printf(jk_ws_service_t *s, const char *fmt, ...)
{
int rc = 0;
va_list args;
#ifdef NETWARE
/* On NetWare, this can get called on a thread that has a limited stack so */
/* we will allocate and free the temporary buffer in this function */
char *buf;
#else
char buf[HUGE_BUFFER_SIZE];
#endif
if (!s || !fmt) {
return -1;
}
va_start(args, fmt);
#ifdef NETWARE
buf = (char *)malloc(HUGE_BUFFER_SIZE);
if (NULL == buf)
return -1;
#endif
rc = vsnprintf(buf, HUGE_BUFFER_SIZE, fmt, args);
va_end(args);
if (rc > 0)
s->write(s, buf, rc);
#ifdef NETWARE
free(buf);
#endif
return rc;
}
static void jk_print_xml_start_elt(jk_ws_service_t *s, status_worker_t *w,
int indentation, int close_tag,
const char *name)
{
if (close_tag) {
jk_printf(s, "%*s<%s%s>\n", indentation, "", w->ns, name);
}
else {
jk_printf(s, "%*s<%s%s\n", indentation, "", w->ns, name);
}
}
static void jk_print_xml_close_elt(jk_ws_service_t *s, status_worker_t *w,
int indentation,
const char *name)
{
jk_printf(s, "%*s</%s%s>\n", indentation, "", w->ns, name);
}
static void jk_print_xml_stop_elt(jk_ws_service_t *s,
int indentation, int close_tag)
{
if (close_tag) {
jk_printf(s, "%*s/>\n", indentation, "");
}
else {
jk_printf(s, "%*s>\n", indentation, "");
}
}
static void jk_print_xml_att_string(jk_ws_service_t *s,
int indentation,
const char *key, const char *value)
{
jk_printf(s, "%*s%s=\"%s\"\n", indentation, "", key, value ? value : "");
}
static void jk_print_xml_att_int(jk_ws_service_t *s,
int indentation,
const char *key, int value)
{
jk_printf(s, "%*s%s=\"%d\"\n", indentation, "", key, value);
}
static void jk_print_xml_att_uint32(jk_ws_service_t *s,
int indentation,
const char *key, jk_uint32_t value)
{
jk_printf(s, "%*s%s=\"%" JK_UINT32_T_FMT "\"\n", indentation, "", key, value);
}
static void jk_print_xml_att_uint64(jk_ws_service_t *s,
int indentation,
const char *key, jk_uint64_t value)
{
jk_printf(s, "%*s%s=\"%" JK_UINT64_T_FMT "\"\n", indentation, "", key, value);
}
static void jk_print_prop_att_string(jk_ws_service_t *s, status_worker_t *w,
const char *name,
const char *key, const char *value)
{
if (name) {
jk_printf(s, "%s.%s.%s=%s\n", w->prefix, name, key, value ? value : "");
}
else {
jk_printf(s, "%s.%s=%s\n", w->prefix, key, value ? value : "");
}
}
static void jk_print_prop_att_int(jk_ws_service_t *s, status_worker_t *w,
const char *name,
const char *key, int value)
{
if (name) {
jk_printf(s, "%s.%s.%s=%d\n", w->prefix, name, key, value);
}
else {
jk_printf(s, "%s.%s=%d\n", w->prefix, key, value);
}
}
static void jk_print_prop_att_uint32(jk_ws_service_t *s, status_worker_t *w,
const char *name,
const char *key, jk_uint32_t value)
{
if (name) {
jk_printf(s, "%s.%s.%s=%" JK_UINT32_T_FMT "\n", w->prefix, name, key, value);
}
else {
jk_printf(s, "%s.%s=%" JK_UINT32_T_FMT "\n", w->prefix, key, value);
}
}
static void jk_print_prop_att_uint64(jk_ws_service_t *s, status_worker_t *w,
const char *name,
const char *key, jk_uint64_t value)
{
if (name) {
jk_printf(s, "%s.%s.%s=%" JK_UINT64_T_FMT "\n", w->prefix, name, key, value);
}
else {
jk_printf(s, "%s.%s=%" JK_UINT64_T_FMT "\n", w->prefix, key, value);
}
}
static void jk_print_prop_item_string(jk_ws_service_t *s, status_worker_t *w,
const char *name, const char *list, int num,
const char *key, const char *value)
{
if (name) {
jk_printf(s, "%s.%s.%s.%d.%s=%s\n", w->prefix, name, list, num, key, value ? value : "");
}
else {
jk_printf(s, "%s.%s.%d.%s=%s\n", w->prefix, list, num, key, value ? value : "");
}
}
/* Actually APR's apr_strfsize */
static char *status_strfsize(jk_uint64_t size, char *buf)
{
const char ord[] = "KMGTPE";
const char *o = ord;
unsigned int remain, siz;
if (size < 973) {
if (sprintf(buf, "%3d ", (int) size) < 0)
return strcpy(buf, "****");
return buf;
}
do {
remain = (unsigned int)(size & 0x03FF);
size >>= 10;
if (size >= 973) {
++o;
continue;
}
siz = (unsigned int)(size & 0xFFFF);
if (siz < 9 || (siz == 9 && remain < 973)) {
if ((remain = ((remain * 5) + 256) / 512) >= 10)
++siz, remain = 0;
if (sprintf(buf, "%d.%d%c", siz, remain, *o) < 0)
return strcpy(buf, "****");
return buf;
}
if (remain >= 512)
++siz;
if (sprintf(buf, "%3d%c", siz, *o) < 0)
return strcpy(buf, "****");
return buf;
} while (1);
}
static int status_rate(worker_record_t *wr, status_worker_t *w,
jk_logger_t *l)
{
jk_uint32_t mask = 0;
int activation = wr->s->activation;
int state = wr->s->state;
jk_uint32_t good = w->good_mask;
jk_uint32_t bad = w->bad_mask;
int rv = 0;
switch (activation)
{
case JK_LB_ACTIVATION_ACTIVE:
mask = JK_STATUS_MASK_ACTIVE;
break;
case JK_LB_ACTIVATION_DISABLED:
mask = JK_STATUS_MASK_DISABLED;
break;
case JK_LB_ACTIVATION_STOPPED:
mask = JK_STATUS_MASK_STOPPED;
break;
default:
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' unknown activation type '%d'",
w->name, activation);
}
switch (state)
{
case JK_LB_STATE_OK:
mask &= JK_STATUS_MASK_OK;
break;
case JK_LB_STATE_NA:
mask &= JK_STATUS_MASK_NA;
break;
case JK_LB_STATE_BUSY:
mask &= JK_STATUS_MASK_BUSY;
break;
case JK_LB_STATE_ERROR:
mask &= JK_STATUS_MASK_ERROR;
break;
case JK_LB_STATE_RECOVER:
mask &= JK_STATUS_MASK_RECOVER;
break;
case JK_LB_STATE_FORCE:
mask &= JK_STATUS_MASK_RECOVER;
break;
case JK_LB_STATE_PROBE:
mask &= JK_STATUS_MASK_RECOVER;
break;
default:
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' unknown state type '%d'",
w->name, state);
}
if (mask&bad)
rv = -1;
else if (mask&good)
rv = 1;
else
rv = 0;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' rating of activation '%s' and state '%s' for good '%08" JK_UINT32_T_HEX_FMT
"' and bad '%08" JK_UINT32_T_HEX_FMT "' is %d",
w->name, jk_lb_get_activation(wr, l), jk_lb_get_state(wr, l),
good, bad, rv);
return rv;
}
static jk_uint32_t status_get_single_rating(const char rating, jk_logger_t *l)
{
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"rating retrieval for '%c'",
rating);
switch (rating)
{
case 'A':
case 'a':
return JK_STATUS_MASK_ACTIVE;
case 'D':
case 'd':
return JK_STATUS_MASK_DISABLED;
case 'S':
case 's':
return JK_STATUS_MASK_STOPPED;
case 'O':
case 'o':
return JK_STATUS_MASK_OK;
case 'N':
case 'n':
return JK_STATUS_MASK_NA;
case 'B':
case 'b':
return JK_STATUS_MASK_BUSY;
case 'R':
case 'r':
return JK_STATUS_MASK_RECOVER;
case 'E':
case 'e':
return JK_STATUS_MASK_ERROR;
default:
jk_log(l, JK_LOG_WARNING,
"Unknown rating type '%c'",
rating);
return 0;
}
}
static jk_uint32_t status_get_rating(const char *rating,
jk_logger_t *l)
{
int off = 0;
jk_uint32_t mask = 0;
while (rating[off] == ' ' || rating[off] == '\t' || rating[off] == '.') {
off++;
}
mask = status_get_single_rating(rating[off], l);
while (rating[off] != '\0' && rating[off] != '.') {
off++;
}
if (rating[off] == '.') {
off++;
}
if (rating[off] != '\0') {
mask &= status_get_single_rating(rating[off], l);
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"rating for '%s' is '%08" JK_UINT32_T_HEX_FMT "'",
rating, mask);
return mask;
}
static const char *status_worker_type(int t)
{
if (t < 0 || t > 6)
t = 0;
return worker_type[t];
}
static int status_get_string(status_endpoint_t *p,
const char *param,
const char *def,
const char **result,
jk_logger_t *l)
{
int rv;
*result = jk_map_get_string(p->req_params,
param, NULL);
if (*result) {
rv = JK_TRUE;
}
else {
*result = def;
rv = JK_FALSE;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"retrieved string arg '%s' as '%s'%s",
param, *result ? *result : "(null)",
rv == JK_FALSE ? " (default)" : "");
return rv;
}
static int status_get_int(status_endpoint_t *p,
const char *param,
int def,
jk_logger_t *l)
{
const char *arg;
int rv = def;
if (status_get_string(p, param, NULL, &arg, l) == JK_TRUE) {
rv = atoi(arg);
}
return rv;
}
static int status_get_bool(status_endpoint_t *p,
const char *param,
int def,
jk_logger_t *l)
{
const char *arg;
if (status_get_string(p, param, NULL, &arg, l) == JK_TRUE) {
return jk_get_bool_code(arg, def);
}
return def;
}
const char *status_cmd_text(int cmd)
{
return cmd_type[cmd];
}
static int status_cmd_int(const char *cmd)
{
if (!cmd)
return JK_STATUS_CMD_DEF;
if (!strcmp(cmd, JK_STATUS_CMD_TEXT_LIST))
return JK_STATUS_CMD_LIST;
else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_SHOW))
return JK_STATUS_CMD_SHOW;
else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_EDIT))
return JK_STATUS_CMD_EDIT;
else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_UPDATE))
return JK_STATUS_CMD_UPDATE;
else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_RESET))
return JK_STATUS_CMD_RESET;
else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_VERSION))
return JK_STATUS_CMD_VERSION;
else if (!strcmp(cmd, JK_STATUS_CMD_TEXT_RECOVER))
return JK_STATUS_CMD_RECOVER;
return JK_STATUS_CMD_UNKNOWN;
}
const char *status_mime_text(int mime)
{
return mime_type[mime];
}
static int status_mime_int(const char *mime)
{
if (!mime)
return JK_STATUS_MIME_DEF;
if (!strcmp(mime, JK_STATUS_MIME_TEXT_HTML))
return JK_STATUS_MIME_HTML;
else if (!strcmp(mime, JK_STATUS_MIME_TEXT_XML))
return JK_STATUS_MIME_XML;
else if (!strcmp(mime, JK_STATUS_MIME_TEXT_TXT))
return JK_STATUS_MIME_TXT;
else if (!strcmp(mime, JK_STATUS_MIME_TEXT_PROP))
return JK_STATUS_MIME_PROP;
return JK_STATUS_MIME_UNKNOWN;
}
static void status_start_form(jk_ws_service_t *s,
status_endpoint_t *p,
const char *method,
int cmd,
jk_logger_t *l)
{
int i;
int sz;
jk_map_t *m = p->req_params;
if (method)
jk_printf(s, JK_STATUS_FORM_START, method, s->req_uri);
else
return;
if (cmd != JK_STATUS_CMD_UNKNOWN) {
jk_printf(s, JK_STATUS_FORM_HIDDEN_STRING,
JK_STATUS_ARG_CMD, status_cmd_text(cmd));
}
sz = jk_map_size(m);
for (i = 0; i < sz; i++) {
const char *k = jk_map_name_at(m, i);
const char *v = jk_map_value_at(m, i);
if (strcmp(k, JK_STATUS_ARG_CMD) || cmd == JK_STATUS_CMD_UNKNOWN) {
jk_printf(s, JK_STATUS_FORM_HIDDEN_STRING, k, v);
}
}
}
static void status_write_uri(jk_ws_service_t *s,
status_endpoint_t *p,
const char *text,
int cmd, int mime,
const char *worker, const char *sub_worker,
unsigned int add_options, unsigned int rm_options,
const char *attribute,
jk_logger_t *l)
{
int i;
int sz;
int started = 0;
int from;
int prev;
unsigned int opt = 0;
const char *arg;
jk_map_t *m = p->req_params;
if (text)
jk_puts(s, "<a href=\"");
jk_puts(s, s->req_uri);
status_get_string(p, JK_STATUS_ARG_FROM, NULL, &arg, l);
from = status_cmd_int(arg);
status_get_string(p, JK_STATUS_ARG_CMD, NULL, &arg, l);
prev = status_cmd_int(arg);
if (cmd == JK_STATUS_CMD_UNKNOWN) {
if (prev == JK_STATUS_CMD_UPDATE ||
prev == JK_STATUS_CMD_RESET ||
prev == JK_STATUS_CMD_RECOVER) {
cmd = from;
}
}
if (cmd != JK_STATUS_CMD_UNKNOWN) {
jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
JK_STATUS_ARG_CMD, status_cmd_text(cmd));
if (cmd == JK_STATUS_CMD_EDIT ||
cmd == JK_STATUS_CMD_RESET ||
cmd == JK_STATUS_CMD_RECOVER) {
jk_printf(s, "%s%s=%s", "&amp;",
JK_STATUS_ARG_FROM, status_cmd_text(prev));
}
started=1;
}
if (mime != JK_STATUS_MIME_UNKNOWN) {
jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
JK_STATUS_ARG_MIME, status_mime_text(mime));
started=1;
}
if (worker && worker[0]) {
jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
JK_STATUS_ARG_WORKER, worker);
started=1;
}
if (sub_worker && sub_worker[0]) {
jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
JK_STATUS_ARG_SUB_WORKER, sub_worker);
started=1;
}
if (attribute && attribute[0]) {
jk_printf(s, "%s%s=%s", started ? "&amp;" : "?",
JK_STATUS_ARG_ATTRIBUTE, attribute);
started=1;
}
sz = jk_map_size(m);
for (i = 0; i < sz; i++) {
const char *k = jk_map_name_at(m, i);
const char *v = jk_map_value_at(m, i);
if (!strcmp(k, JK_STATUS_ARG_CMD) && cmd != JK_STATUS_CMD_UNKNOWN) {
continue;
}
if (!strcmp(k, JK_STATUS_ARG_MIME) && mime != JK_STATUS_MIME_UNKNOWN) {
continue;
}
if (!strcmp(k, JK_STATUS_ARG_FROM)) {
continue;
}
if (!strcmp(k, JK_STATUS_ARG_WORKER) && worker) {
continue;
}
if (!strcmp(k, JK_STATUS_ARG_SUB_WORKER) && sub_worker) {
continue;
}
if (!strcmp(k, JK_STATUS_ARG_ATTRIBUTE) && attribute) {
continue;
}
if (!strcmp(k, JK_STATUS_ARG_ATTRIBUTE) && cmd != JK_STATUS_CMD_UPDATE && cmd != JK_STATUS_CMD_EDIT) {
continue;
}
if (!strncmp(k, JK_STATUS_ARG_MULT_VALUE_BASE, 3) && cmd != JK_STATUS_CMD_UPDATE) {
continue;
}
if (strlen(k) == 2 && (k[0] == 'l' || k[0] == 'w') && cmd != JK_STATUS_CMD_UPDATE) {
continue;
}
if (!strcmp(k, JK_STATUS_ARG_OPTIONS)) {
opt = atoi(v);
continue;
}
jk_printf(s, "%s%s=%s", started ? "&amp;" : "?", k, v);
started=1;
}
if (opt | add_options | rm_options)
jk_printf(s, "%s%s=%u", started ? "&amp;" : "?",
JK_STATUS_ARG_OPTIONS, (opt | add_options) & ~rm_options);
if (text)
jk_putv(s, "\">", text, "</a>", NULL);
}
static int status_parse_uri(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
jk_map_t *m;
status_worker_t *w = p->worker;
#ifdef _REENTRANT
char *lasts;
#endif
char *param;
char *query;
JK_TRACE_ENTER(l);
if (!jk_map_alloc(&(p->req_params))) {
jk_log(l, JK_LOG_ERROR,
"Status worker '%s' could not alloc map for request parameters",
w->name);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (!s->query_string) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' query string is empty",
w->name);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
m = p->req_params;
query = jk_pool_strdup(s->pool, s->query_string);
if (!query) {
jk_log(l, JK_LOG_ERROR,
"Status worker '%s' could not copy string",
w->name);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
#ifdef _REENTRANT
for (param = strtok_r(query, "&", &lasts);
param; param = strtok_r(NULL, "&", &lasts)) {
#else
for (param = strtok(query, "&"); param; param = strtok(NULL, "&")) {
#endif
char *key = jk_pool_strdup(s->pool, param);
char *value;
if (!key) {
jk_log(l, JK_LOG_ERROR,
"Status worker '%s' could not copy string",
w->name);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
value = strchr(key, '=');
if (value) {
char *off;
*value = '\0';
value++;
/* XXX Depending on the params values, we might need to trim and decode */
/* XXX For now we simply mask special chars with '@' to prevent cross code injection */
off = value;
while ((off = strpbrk(off, JK_STATUS_ESC_CHARS)))
off[0] = '@';
if (strlen(key)) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' adding request param '%s' with value '%s'",
w->name, key, value);
jk_map_put(m, key, value, NULL);
}
}
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int fetch_worker_and_sub_worker(status_endpoint_t *p,
const char *operation,
const char **worker,
const char **sub_worker,
jk_logger_t *l)
{
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
status_get_string(p, JK_STATUS_ARG_WORKER, NULL, worker, l);
status_get_string(p, JK_STATUS_ARG_SUB_WORKER, NULL, sub_worker, l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s worker '%s' sub worker '%s'",
w->name, operation,
*worker ? *worker : "(null)", *sub_worker ? *sub_worker : "(null)");
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int check_valid_lb(jk_ws_service_t *s,
status_endpoint_t *p,
jk_worker_t *jw,
const char *worker,
lb_worker_t **lbp,
int implemented,
jk_logger_t *l)
{
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
if (jw->type != JK_LB_WORKER_TYPE) {
if (implemented) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' worker type of worker '%s' has no sub workers",
w->name, worker);
p->msg = "worker type has no sub workers";
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' worker type of worker '%s' not implemented",
w->name, worker);
p->msg = "worker type not implemented";
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
*lbp = (lb_worker_t *)jw->worker_private;
if (!*lbp) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' lb structure of worker '%s' is (null)",
w->name, worker);
p->msg = "lb structure is (null)";
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p->msg = "OK";
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int search_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_worker_t **jwp,
const char *worker,
jk_logger_t *l)
{
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
*jwp = NULL;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' searching worker '%s'",
w->name, worker ? worker : "(null)");
if (!worker || !worker[0]) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' NULL or EMPTY worker param",
w->name);
p->msg = "NULL or EMPTY worker param";
JK_TRACE_EXIT(l);
return JK_FALSE;
}
*jwp = wc_get_worker_for_name(worker, l);
if (!*jwp) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' could not find worker '%s'",
w->name, worker);
p->msg = "Could not find given worker";
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p->msg = "OK";
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int search_sub_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_worker_t *jw,
const char *worker,
worker_record_t **wrp,
const char *sub_worker,
jk_logger_t *l)
{
lb_worker_t *lb = NULL;
worker_record_t *wr = NULL;
status_worker_t *w = p->worker;
unsigned int i;
JK_TRACE_ENTER(l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' searching sub worker '%s' of worker '%s'",
w->name, sub_worker ? sub_worker : "(null)",
worker ? worker : "(null)");
if (!sub_worker || !sub_worker[0]) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' NULL or EMPTY sub_worker param",
w->name);
p->msg = "NULL or EMPTY sub_worker param";
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (check_valid_lb(s, p, jw, worker, &lb, 1, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
for (i = 0; i < (int)lb->num_of_workers; i++) {
wr = &(lb->lb_workers[i]);
if (strcmp(sub_worker, wr->s->name) == 0)
break;
}
*wrp = wr;
if (!wr || i == (int)lb->num_of_workers) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' could not find sub worker '%s' of worker '%s'",
w->name, sub_worker, worker ? worker : "(null)");
p->msg = "could not find sub worker";
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p->msg = "OK";
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int count_maps(jk_ws_service_t *s,
const char *worker,
jk_logger_t *l)
{
unsigned int i;
int count=0;
jk_uri_worker_map_t *uw_map = s->uw_map;
JK_TRACE_ENTER(l);
for (i = 0; i < uw_map->size; i++) {
uri_worker_record_t *uwr = uw_map->maps[i];
if (strcmp(uwr->worker_name, worker)) {
continue;
}
count++;
}
JK_TRACE_EXIT(l);
return count;
}
static void display_maps(jk_ws_service_t *s,
status_endpoint_t *p,
const char *worker,
jk_logger_t *l)
{
char buf[64];
unsigned int i;
int mime;
unsigned int hide;
int count=0;
const char *arg;
status_worker_t *w = p->worker;
jk_uri_worker_map_t *uw_map = s->uw_map;
JK_TRACE_ENTER(l);
status_get_string(p, JK_STATUS_ARG_MIME, NULL, &arg, l);
mime = status_mime_int(arg);
hide = status_get_int(p, JK_STATUS_ARG_OPTIONS, 0, l) &
JK_STATUS_ARG_OPTION_NO_MAPS;
count = count_maps(s, worker, l);
if (count) {
if (hide) {
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "<p>\n");
status_write_uri(s, p, "Show URI Mappings", JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, JK_STATUS_ARG_OPTION_NO_MAPS, NULL, l);
jk_puts(s, "</p>\n");
}
}
else {
if (mime == JK_STATUS_MIME_HTML) {
jk_printf(s, "<hr/><h3>URI Mappings for %s (%d maps) [", worker, count);
status_write_uri(s, p, "Hide", JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, JK_STATUS_ARG_OPTION_NO_MAPS, 0, NULL, l);
jk_puts(s, "]</h3><table>\n");
jk_printf(s, JK_STATUS_TABLE_HEAD_3_STRING,
"Match Type", "Uri", "Source");
}
}
}
if (hide) {
return;
JK_TRACE_EXIT(l);
}
count = 0;
for (i = 0; i < uw_map->size; i++) {
uri_worker_record_t *uwr = uw_map->maps[i];
if (strcmp(uwr->worker_name, worker)) {
continue;
}
count++;
if (mime == JK_STATUS_MIME_HTML) {
jk_printf(s, JK_STATUS_TABLE_ROW_3_STRING,
uri_worker_map_get_match(uwr, buf, l), uwr->uri,
uri_worker_map_get_source(uwr, l));
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 6, 0, "map");
jk_print_xml_att_int(s, 8, "id", count);
jk_print_xml_att_string(s, 8, "type", uri_worker_map_get_match(uwr, buf, l));
jk_print_xml_att_string(s, 8, "uri", uwr->uri);
jk_print_xml_att_string(s, 8, "source", uri_worker_map_get_source(uwr, l));
jk_print_xml_stop_elt(s, 6, 1);
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "Map:");
jk_printf(s, " id=%d", count);
jk_printf(s, " type=\"%s\"", uri_worker_map_get_match(uwr, buf, l));
jk_printf(s, " uri=\"%s\"", uwr->uri);
jk_printf(s, " source=\"%s\"", uri_worker_map_get_source(uwr, l));
jk_puts(s, "\n");
}
else if (mime == JK_STATUS_MIME_PROP) {
char *mount = jk_pool_alloc(s->pool, sizeof(char *) * (strlen(uwr->uri)+3));
char *off = mount;
if (uwr->match_type & MATCH_TYPE_DISABLED) {
*off = '-';
off++;
}
if (uwr->match_type & MATCH_TYPE_NO_MATCH) {
*off = '!';
off++;
}
strcpy(off, uwr->uri);
jk_print_prop_att_string(s, w, worker, "mount", mount);
jk_print_prop_item_string(s, w, worker, "map", count, "type", uri_worker_map_get_match(uwr, buf, l));
jk_print_prop_item_string(s, w, worker, "map", count, "uri", uwr->uri);
jk_print_prop_item_string(s, w, worker, "map", count, "source", uri_worker_map_get_source(uwr, l));
}
}
if (count) {
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "</table>\n");
}
}
else {
if (mime == JK_STATUS_MIME_HTML) {
jk_putv(s, "<hr/><h3>Warning: No URI Mappings defined for ",
worker, " !</h3>\n", NULL);
}
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' displayed %d maps for worker '%s'",
w->name, count, worker);
JK_TRACE_EXIT(l);
}
static void display_worker_lb(jk_ws_service_t *s,
status_endpoint_t *p,
lb_worker_t *lb,
jk_logger_t *l)
{
char buf[32];
char buf_rd[32];
char buf_wr[32];
int cmd;
int mime;
int read_only = 0;
int single = 0;
unsigned int hide_members;
const char *arg;
time_t now = time(NULL);
unsigned int good = 0;
unsigned int degraded = 0;
unsigned int bad = 0;
int map_count;
int ms_min;
int ms_max;
unsigned int j;
const char *name = lb->s->name;
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
status_get_string(p, JK_STATUS_ARG_CMD, NULL, &arg, l);
cmd = status_cmd_int(arg);
status_get_string(p, JK_STATUS_ARG_MIME, NULL, &arg, l);
mime = status_mime_int(arg);
hide_members = status_get_int(p, JK_STATUS_ARG_OPTIONS, 0, l) &
JK_STATUS_ARG_OPTION_NO_MEMBERS;
if (w->read_only) {
read_only = 1;
}
else {
read_only = status_get_int(p, JK_STATUS_ARG_OPTIONS, 0, l) &
JK_STATUS_ARG_OPTION_READ_ONLY;
}
if (cmd == JK_STATUS_CMD_SHOW) {
single = 1;
}
jk_shm_lock();
if (lb->sequence != lb->s->sequence)
jk_lb_pull(lb, l);
jk_shm_unlock();
for (j = 0; j < lb->num_of_workers; j++) {
worker_record_t *wr = &(lb->lb_workers[j]);
int rate;
rate = status_rate(wr, w, l);
if (rate > 0 )
good++;
else if (rate < 0 )
bad++;
else
degraded++;
}
map_count = count_maps(s, name, l);
ms_min = lb->maintain_time - (int)difftime(now, lb->s->last_maintain_time);
ms_max = ms_min + lb->maintain_time;
ms_min -= JK_LB_MAINTAIN_TOLERANCE;
if (ms_min < 0) {
ms_min = 0;
}
if (ms_max < 0) {
ms_max = 0;
}
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "<hr/><h3>[");
if (single) {
jk_puts(s, "S");
}
else {
status_write_uri(s, p, "S", JK_STATUS_CMD_SHOW, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, "", l);
}
if (!read_only) {
jk_puts(s, "|");
status_write_uri(s, p, "E", JK_STATUS_CMD_EDIT, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, "", l);
jk_puts(s, "|");
status_write_uri(s, p, "R", JK_STATUS_CMD_RESET, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, "", l);
}
jk_puts(s, "]&nbsp;&nbsp;");
jk_putv(s, "Worker Status for ", name, "</h3>\n", NULL);
jk_puts(s, "<table>" JK_STATUS_SHOW_LB_HEAD);
jk_printf(s, JK_STATUS_SHOW_LB_ROW,
status_worker_type(JK_LB_WORKER_TYPE),
jk_get_bool(lb->sticky_session),
jk_get_bool(lb->sticky_session_force),
lb->retries,
jk_lb_get_method(lb, l),
jk_lb_get_lock(lb, l),
lb->recover_wait_time);
jk_puts(s, "</table>\n<br/>\n");
jk_puts(s, "<table><tr>"
"<th>Good</th><th>Degraded</th><th>Bad/Stopped</th><th>Busy</th><th>Max Busy</th><th>Next Maintenance</th>"
"</tr>\n<tr>");
jk_printf(s, "<td>%d</td>", good);
jk_printf(s, "<td>%d</td>", degraded);
jk_printf(s, "<td>%d</td>", bad);
jk_printf(s, "<td>%d</td>", lb->s->busy);
jk_printf(s, "<td>%d</td>", lb->s->max_busy);
jk_printf(s, "<td>%d/%d</td>", ms_min, ms_max);
jk_puts(s, "</tr>\n</table>\n\n");
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 2, 0, "balancer");
jk_print_xml_att_string(s, 4, "name", name);
jk_print_xml_att_string(s, 4, "type", status_worker_type(JK_LB_WORKER_TYPE));
jk_print_xml_att_string(s, 4, "sticky_session", jk_get_bool(lb->sticky_session));
jk_print_xml_att_string(s, 4, "sticky_session_force", jk_get_bool(lb->sticky_session_force));
jk_print_xml_att_int(s, 4, "retries", lb->retries);
jk_print_xml_att_int(s, 4, "recover_time", lb->recover_wait_time);
jk_print_xml_att_string(s, 4, "method", jk_lb_get_method(lb, l));
jk_print_xml_att_string(s, 4, "lock", jk_lb_get_lock(lb, l));
jk_print_xml_att_int(s, 4, "member_count", lb->num_of_workers);
jk_print_xml_att_int(s, 4, "good", good);
jk_print_xml_att_int(s, 4, "degraded", degraded);
jk_print_xml_att_int(s, 4, "bad", bad);
jk_print_xml_att_int(s, 4, "busy", lb->s->busy);
jk_print_xml_att_int(s, 4, "max_busy", lb->s->max_busy);
jk_print_xml_att_int(s, 4, "map_count", map_count);
jk_print_xml_att_int(s, 4, "time_to_maintenance_min", ms_min);
jk_print_xml_att_int(s, 4, "time_to_maintenance_max", ms_max);
jk_print_xml_stop_elt(s, 2, 0);
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "Balancer Worker:");
jk_printf(s, " name=%s", name);
jk_printf(s, " type=%s", status_worker_type(JK_LB_WORKER_TYPE));
jk_printf(s, " sticky_session=%s", jk_get_bool(lb->sticky_session));
jk_printf(s, " sticky_session_force=%s", jk_get_bool(lb->sticky_session_force));
jk_printf(s, " retries=%d", lb->retries);
jk_printf(s, " recover_time=%d", lb->recover_wait_time);
jk_printf(s, " method=%s", jk_lb_get_method(lb, l));
jk_printf(s, " lock=%s", jk_lb_get_lock(lb, l));
jk_printf(s, " member_count=%d", lb->num_of_workers);
jk_printf(s, " good=%d", good);
jk_printf(s, " degraded=%d", degraded);
jk_printf(s, " bad=%d", bad);
jk_printf(s, " busy=%d", lb->s->busy);
jk_printf(s, " max_busy=%d", lb->s->max_busy);
jk_printf(s, " map_count=%d", map_count);
jk_printf(s, " time_to_maintenance_min=%d", ms_min);
jk_printf(s, " time_to_maintenance_max=%d", ms_max);
jk_puts(s, "\n");
}
else if (mime == JK_STATUS_MIME_PROP) {
jk_print_prop_att_string(s, w, NULL, "list", name);
jk_print_prop_att_string(s, w, name, "type", status_worker_type(JK_LB_WORKER_TYPE));
jk_print_prop_att_string(s, w, name, "sticky_session", jk_get_bool(lb->sticky_session));
jk_print_prop_att_string(s, w, name, "sticky_session_force", jk_get_bool(lb->sticky_session_force));
jk_print_prop_att_int(s, w, name, "retries", lb->retries);
jk_print_prop_att_int(s, w, name, "recover_time", lb->recover_wait_time);
jk_print_prop_att_string(s, w, name, "method", jk_lb_get_method(lb, l));
jk_print_prop_att_string(s, w, name, "lock", jk_lb_get_lock(lb, l));
jk_print_prop_att_int(s, w, name, "member_count", lb->num_of_workers);
jk_print_prop_att_int(s, w, name, "good", good);
jk_print_prop_att_int(s, w, name, "degraded", degraded);
jk_print_prop_att_int(s, w, name, "bad", bad);
jk_print_prop_att_int(s, w, name, "busy", lb->s->busy);
jk_print_prop_att_int(s, w, name, "max_busy", lb->s->max_busy);
jk_print_prop_att_int(s, w, name, "map_count", map_count);
jk_print_prop_att_int(s, w, name, "time_to_maintenance_min", ms_min);
jk_print_prop_att_int(s, w, name, "time_to_maintenance_max", ms_max);
}
if (!hide_members) {
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "<h4>Balancer Members [");
if (single) {
status_write_uri(s, p, "Hide", JK_STATUS_CMD_SHOW, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, JK_STATUS_ARG_OPTION_NO_MEMBERS, 0, "", l);
}
else {
status_write_uri(s, p, "Hide", JK_STATUS_CMD_LIST, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, JK_STATUS_ARG_OPTION_NO_MEMBERS, 0, "", l);
}
jk_puts(s, "]</h4>\n");
jk_puts(s, "<table>" JK_STATUS_SHOW_MEMBER_HEAD);
}
for (j = 0; j < lb->num_of_workers; j++) {
worker_record_t *wr = &(lb->lb_workers[j]);
ajp_worker_t *a = (ajp_worker_t *)wr->w->worker_private;
int rs_min = 0;
int rs_max = 0;
if (wr->s->state == JK_LB_STATE_ERROR) {
rs_min = lb->recover_wait_time - (int)difftime(now, wr->s->error_time);
if (rs_min < 0) {
rs_min = 0;
}
rs_max = rs_min + lb->maintain_time;
if (rs_min < ms_min) {
rs_min = ms_min;
}
}
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "<tr>\n<td>");
if (!read_only) {
jk_puts(s, "[");
status_write_uri(s, p, "E", JK_STATUS_CMD_EDIT, JK_STATUS_MIME_UNKNOWN,
name, wr->s->name, 0, 0, "", l);
jk_puts(s, "|");
status_write_uri(s, p, "R", JK_STATUS_CMD_RESET, JK_STATUS_MIME_UNKNOWN,
name, wr->s->name, 0, 0, "", l);
if (wr->s->state == JK_LB_STATE_ERROR) {
jk_puts(s, "|");
status_write_uri(s, p, "T", JK_STATUS_CMD_RECOVER, JK_STATUS_MIME_UNKNOWN,
name, wr->s->name, 0, 0, "", l);
}
jk_puts(s, "]");
}
jk_puts(s, "&nbsp;</td>");
jk_printf(s, JK_STATUS_SHOW_MEMBER_ROW,
wr->s->name,
status_worker_type(wr->w->type),
a->host, a->port,
jk_dump_hinfo(&a->worker_inet_addr, buf),
jk_lb_get_activation(wr, l),
jk_lb_get_state(wr, l),
wr->s->distance,
wr->s->lb_factor,
wr->s->lb_mult,
wr->s->lb_value,
wr->s->elected,
wr->s->errors,
wr->s->client_errors,
status_strfsize(wr->s->transferred, buf_wr),
status_strfsize(wr->s->readed, buf_rd),
wr->s->busy,
wr->s->max_busy,
wr->s->route,
wr->s->redirect ? (*wr->s->redirect ? wr->s->redirect : "&nbsp;") : "&nbsp",
wr->s->domain ? (*wr->s->domain ? wr->s->domain : "&nbsp;") : "&nbsp",
rs_min,
rs_max);
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 6, 0, "member");
jk_print_xml_att_string(s, 8, "name", wr->s->name);
jk_print_xml_att_string(s, 8, "type", status_worker_type(wr->w->type));
jk_print_xml_att_string(s, 8, "host", a->host);
jk_print_xml_att_int(s, 8, "port", a->port);
jk_print_xml_att_string(s, 8, "address", jk_dump_hinfo(&a->worker_inet_addr, buf));
jk_print_xml_att_string(s, 8, "activation", jk_lb_get_activation(wr, l));
jk_print_xml_att_int(s, 8, "lbfactor", wr->s->lb_factor);
jk_print_xml_att_string(s, 8, "route", wr->s->route);
jk_print_xml_att_string(s, 8, "redirect", wr->s->redirect);
jk_print_xml_att_string(s, 8, "domain", wr->s->domain);
jk_print_xml_att_int(s, 8, "distance", wr->s->distance);
jk_print_xml_att_string(s, 8, "state", jk_lb_get_state(wr, l));
jk_print_xml_att_uint64(s, 8, "lbmult", wr->s->lb_mult);
jk_print_xml_att_uint64(s, 8, "lbvalue", wr->s->lb_value);
jk_print_xml_att_uint64(s, 8, "elected", wr->s->elected);
jk_print_xml_att_uint32(s, 8, "errors", wr->s->errors);
jk_print_xml_att_uint32(s, 8, "client_errors", wr->s->client_errors);
jk_print_xml_att_uint64(s, 8, "transferred", wr->s->transferred);
jk_print_xml_att_uint64(s, 8, "read", wr->s->readed);
jk_print_xml_att_int(s, 8, "busy", wr->s->busy);
jk_print_xml_att_int(s, 8, "max_busy", wr->s->max_busy);
jk_print_xml_att_int(s, 8, "time_to_recover_min", rs_min);
jk_print_xml_att_int(s, 8, "time_to_recover_max", rs_max);
/* Terminate the tag */
jk_print_xml_stop_elt(s, 6, 1);
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "Member:");
jk_printf(s, " name=%s", wr->s->name);
jk_printf(s, " type=%s", status_worker_type(wr->w->type));
jk_printf(s, " host=%s", a->host);
jk_printf(s, " port=%d", a->port);
jk_printf(s, " address=%s", jk_dump_hinfo(&a->worker_inet_addr, buf));
jk_printf(s, " activation=%s", jk_lb_get_activation(wr, l));
jk_printf(s, " lbfactor=%d", wr->s->lb_factor);
jk_printf(s, " route=\"%s\"", wr->s->route ? wr->s->route : "");
jk_printf(s, " redirect=\"%s\"", wr->s->redirect ? wr->s->redirect : "");
jk_printf(s, " domain=\"%s\"", wr->s->domain ? wr->s->domain : "");
jk_printf(s, " distance=%d", wr->s->distance);
jk_printf(s, " state=%s", jk_lb_get_state(wr, l));
jk_printf(s, " lbmult=%" JK_UINT64_T_FMT, wr->s->lb_mult);
jk_printf(s, " lbvalue=%" JK_UINT64_T_FMT, wr->s->lb_value);
jk_printf(s, " elected=%" JK_UINT64_T_FMT, wr->s->elected);
jk_printf(s, " errors=%" JK_UINT32_T_FMT, wr->s->errors);
jk_printf(s, " client_errors=%" JK_UINT32_T_FMT, wr->s->client_errors);
jk_printf(s, " transferred=%" JK_UINT64_T_FMT, wr->s->transferred);
jk_printf(s, " read=%" JK_UINT64_T_FMT, wr->s->readed);
jk_printf(s, " busy=%d", wr->s->busy);
jk_printf(s, " max_busy=%d", wr->s->max_busy);
jk_printf(s, " time_to_recover_min=%d", rs_min);
jk_printf(s, " time_to_recover_max=%d", rs_max);
jk_puts(s, "\n");
}
else if (mime == JK_STATUS_MIME_PROP) {
jk_print_prop_att_string(s, w, name, "balance_workers", wr->s->name);
jk_print_prop_att_string(s, w, wr->s->name, "type", status_worker_type(wr->w->type));
jk_print_prop_att_string(s, w, wr->s->name, "host", a->host);
jk_print_prop_att_int(s, w, wr->s->name, "port", a->port);
jk_print_prop_att_string(s, w, wr->s->name, "address", jk_dump_hinfo(&a->worker_inet_addr, buf));
jk_print_prop_att_string(s, w, wr->s->name, "activation", jk_lb_get_activation(wr, l));
jk_print_prop_att_int(s, w, wr->s->name, "lbfactor", wr->s->lb_factor);
jk_print_prop_att_string(s, w, wr->s->name, "route", wr->s->route);
jk_print_prop_att_string(s, w, wr->s->name, "redirect", wr->s->redirect);
jk_print_prop_att_string(s, w, wr->s->name, "domain", wr->s->domain);
jk_print_prop_att_int(s, w, wr->s->name, "distance", wr->s->distance);
jk_print_prop_att_string(s, w, wr->s->name, "state", jk_lb_get_state(wr, l));
jk_print_prop_att_uint64(s, w, wr->s->name, "lbmult", wr->s->lb_mult);
jk_print_prop_att_uint64(s, w, wr->s->name, "lbvalue", wr->s->lb_value);
jk_print_prop_att_uint64(s, w, wr->s->name, "elected", wr->s->elected);
jk_print_prop_att_uint32(s, w, wr->s->name, "errors", wr->s->errors);
jk_print_prop_att_uint32(s, w, wr->s->name, "client_errors", wr->s->client_errors);
jk_print_prop_att_uint64(s, w, wr->s->name, "transferred", wr->s->transferred);
jk_print_prop_att_uint64(s, w, wr->s->name, "read", wr->s->readed);
jk_print_prop_att_int(s, w, wr->s->name, "busy", wr->s->busy);
jk_print_prop_att_int(s, w, wr->s->name, "max_busy", wr->s->max_busy);
jk_print_prop_att_int(s, w, wr->s->name, "time_to_recover_min", rs_min);
jk_print_prop_att_int(s, w, wr->s->name, "time_to_recover_max", rs_max);
}
}
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "</table><br/>\n");
if (!read_only) {
jk_puts(s, "<b>E</b>dit one attribute for all members: [");
status_write_uri(s, p, JK_STATUS_ARG_LBM_TEXT_ACTIVATION, JK_STATUS_CMD_EDIT, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, JK_STATUS_ARG_LBM_ACTIVATION, l);
jk_puts(s, "\n|");
status_write_uri(s, p, JK_STATUS_ARG_LBM_TEXT_FACTOR, JK_STATUS_CMD_EDIT, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, JK_STATUS_ARG_LBM_FACTOR, l);
jk_puts(s, "\n|");
status_write_uri(s, p, JK_STATUS_ARG_LBM_TEXT_ROUTE, JK_STATUS_CMD_EDIT, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, JK_STATUS_ARG_LBM_ROUTE, l);
jk_puts(s, "\n|");
status_write_uri(s, p, JK_STATUS_ARG_LBM_TEXT_REDIRECT, JK_STATUS_CMD_EDIT, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, JK_STATUS_ARG_LBM_REDIRECT, l);
jk_puts(s, "\n|");
status_write_uri(s, p, JK_STATUS_ARG_LBM_TEXT_DOMAIN, JK_STATUS_CMD_EDIT, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, JK_STATUS_ARG_LBM_DOMAIN, l);
jk_puts(s, "\n|");
status_write_uri(s, p, JK_STATUS_ARG_LBM_TEXT_DISTANCE, JK_STATUS_CMD_EDIT, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, JK_STATUS_ARG_LBM_DISTANCE, l);
jk_puts(s, "\n]<br/>\n");
}
}
}
else {
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "<p>\n");
if (single) {
status_write_uri(s, p, "Show Balancer Members", JK_STATUS_CMD_SHOW, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, JK_STATUS_ARG_OPTION_NO_MEMBERS, "", l);
}
else {
status_write_uri(s, p, "Show Balancer Members", JK_STATUS_CMD_LIST, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, JK_STATUS_ARG_OPTION_NO_MEMBERS, "", l);
}
jk_puts(s, "</p>\n");
}
}
if (name)
display_maps(s, p, name, l);
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_close_elt(s, w, 2, "balancer");
}
JK_TRACE_EXIT(l);
}
static void display_worker_ajp(jk_ws_service_t *s,
status_endpoint_t *p,
ajp_worker_t *aw,
jk_logger_t *l)
{
char buf[32];
int cmd;
int mime;
int single = 0;
const char *arg;
int map_count;
const char *name = aw->name;
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
status_get_string(p, JK_STATUS_ARG_CMD, NULL, &arg, l);
cmd = status_cmd_int(arg);
status_get_string(p, JK_STATUS_ARG_MIME, NULL, &arg, l);
mime = status_mime_int(arg);
if (cmd == JK_STATUS_CMD_SHOW) {
single = 1;
}
map_count = count_maps(s, name, l);
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "<hr/><h3>[");
if (single)
jk_puts(s, "S");
else
status_write_uri(s, p, "S", JK_STATUS_CMD_SHOW, JK_STATUS_MIME_UNKNOWN,
name, "", 0, 0, "", l);
jk_puts(s, "]&nbsp;&nbsp;");
jk_putv(s, "Worker Status for ", name, "</h3>\n", NULL);
jk_puts(s, "<table>" JK_STATUS_SHOW_AJP_HEAD);
jk_printf(s, JK_STATUS_SHOW_AJP_ROW,
status_worker_type(aw->worker.type),
aw->host, aw->port,
jk_dump_hinfo(&aw->worker_inet_addr, buf));
jk_puts(s, "</table>\n");
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 0, 0, "ajp");
jk_print_xml_att_string(s, 2, "name", name);
jk_print_xml_att_string(s, 2, "type", status_worker_type(aw->worker.type));
jk_print_xml_att_string(s, 2, "host", aw->host);
jk_print_xml_att_int(s, 2, "port", aw->port);
jk_print_xml_att_string(s, 2, "address", jk_dump_hinfo(&aw->worker_inet_addr, buf));
jk_print_xml_att_int(s, 2, "map_count", map_count);
/* Terminate the tag */
jk_print_xml_stop_elt(s, 0, 0);
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "AJP Worker:");
jk_printf(s, " name=%s", name);
jk_printf(s, " type=%s", status_worker_type(aw->worker.type));
jk_printf(s, " host=%s", aw->host);
jk_printf(s, " port=%d", aw->port);
jk_printf(s, " address=%s", jk_dump_hinfo(&aw->worker_inet_addr, buf));
jk_printf(s, " map_count=%d", map_count);
jk_puts(s, "\n");
}
else if (mime == JK_STATUS_MIME_PROP) {
jk_print_prop_att_string(s, w, NULL, "list", name);
jk_print_prop_att_string(s, w, name, "type", status_worker_type(aw->worker.type));
jk_print_prop_att_string(s, w, name, "host", aw->host);
jk_print_prop_att_int(s, w, name, "port", aw->port);
jk_print_prop_att_string(s, w, name, "address", jk_dump_hinfo(&aw->worker_inet_addr, buf));
jk_print_prop_att_int(s, w, name, "map_count", map_count);
}
if (name)
display_maps(s, p, name, l);
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_close_elt(s, w, 0, "ajp");
}
JK_TRACE_EXIT(l);
}
static void display_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_worker_t *jw,
jk_logger_t *l)
{
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
if (jw->type == JK_LB_WORKER_TYPE) {
lb_worker_t *lb = (lb_worker_t *)jw->worker_private;
if (lb) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s'",
w->name, "displaying", lb->s->name);
display_worker_lb(s, p, lb, l);
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' lb worker is (null)",
w->name);
}
}
else if (jw->type == JK_AJP13_WORKER_TYPE ||
jw->type == JK_AJP14_WORKER_TYPE) {
ajp_worker_t *aw = (ajp_worker_t *)jw->worker_private;
if (aw) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s ajp worker '%s'",
w->name, "displaying", aw->name);
display_worker_ajp(s, p, aw, l);
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' aw worker is (null)",
w->name);
}
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' worker type not implemented",
w->name);
JK_TRACE_EXIT(l);
return;
}
}
static void form_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_worker_t *jw,
jk_logger_t *l)
{
const char *name = NULL;
lb_worker_t *lb = NULL;
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
if (jw->type == JK_LB_WORKER_TYPE) {
lb = (lb_worker_t *)jw->worker_private;
name = lb->s->name;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' producing edit form for lb worker '%s'",
w->name, name);
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' worker type not implemented",
w->name);
JK_TRACE_EXIT(l);
return;
}
if (!lb) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' lb structure is (null)",
w->name);
JK_TRACE_EXIT(l);
return;
}
jk_shm_lock();
if (lb->sequence != lb->s->sequence)
jk_lb_pull(lb, l);
jk_shm_unlock();
jk_putv(s, "<hr/><h3>Edit load balancer settings for ",
name, "</h3>\n", NULL);
status_start_form(s, p, "GET", JK_STATUS_CMD_UPDATE, l);
jk_putv(s, "<table>\n<tr><td>", JK_STATUS_ARG_LB_TEXT_RETRIES,
":</td><td><input name=\"",
JK_STATUS_ARG_LB_RETRIES, "\" type=\"text\" ", NULL);
jk_printf(s, "value=\"%d\"/></td></tr>\n", lb->retries);
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LB_TEXT_RECOVER_TIME,
":</td><td><input name=\"",
JK_STATUS_ARG_LB_RECOVER_TIME, "\" type=\"text\" ", NULL);
jk_printf(s, "value=\"%d\"/></td></tr>\n", lb->recover_wait_time);
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LB_TEXT_STICKY,
":</td><td><input name=\"",
JK_STATUS_ARG_LB_STICKY, "\" type=\"checkbox\"", NULL);
if (lb->sticky_session)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LB_TEXT_STICKY_FORCE,
":</td><td><input name=\"",
JK_STATUS_ARG_LB_STICKY_FORCE, "\" type=\"checkbox\"", NULL);
if (lb->sticky_session_force)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LB_TEXT_METHOD,
":</td><td></td></tr>\n", NULL);
jk_putv(s, "<tr><td>&nbsp;&nbsp;Requests</td><td><input name=\"",
JK_STATUS_ARG_LB_METHOD, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_METHOD_REQUESTS);
if (lb->lbmethod == JK_LB_METHOD_REQUESTS)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>&nbsp;&nbsp;Traffic</td><td><input name=\"",
JK_STATUS_ARG_LB_METHOD, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_METHOD_TRAFFIC);
if (lb->lbmethod == JK_LB_METHOD_TRAFFIC)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>&nbsp;&nbsp;Busyness</td><td><input name=\"",
JK_STATUS_ARG_LB_METHOD, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_METHOD_BUSYNESS);
if (lb->lbmethod == JK_LB_METHOD_BUSYNESS)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>&nbsp;&nbsp;Sessions</td><td><input name=\"",
JK_STATUS_ARG_LB_METHOD, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_METHOD_SESSIONS);
if (lb->lbmethod == JK_LB_METHOD_SESSIONS)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LB_TEXT_LOCK,
":</td><td></td></tr>\n", NULL);
jk_putv(s, "<tr><td>&nbsp;&nbsp;Optimistic</td><td><input name=\"",
JK_STATUS_ARG_LB_LOCK, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_LOCK_OPTIMISTIC);
if (lb->lblock == JK_LB_LOCK_OPTIMISTIC)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>&nbsp;&nbsp;Pessimistic</td><td><input name=\"",
JK_STATUS_ARG_LB_LOCK, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_LOCK_PESSIMISTIC);
if (lb->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_puts(s, "</table>\n");
jk_puts(s, "<br/><input type=\"submit\" value=\"Update Balancer\"/></form>\n");
JK_TRACE_EXIT(l);
}
static void form_member(jk_ws_service_t *s,
status_endpoint_t *p,
worker_record_t *wr,
const char *lb_name,
jk_logger_t *l)
{
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' producing edit form for sub worker '%s' of lb worker '%s'",
w->name, wr->s->name, lb_name);
jk_putv(s, "<hr/><h3>Edit worker settings for ",
wr->s->name, "</h3>\n", NULL);
status_start_form(s, p, "GET", JK_STATUS_CMD_UPDATE, l);
jk_puts(s, "<table>\n");
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LBM_TEXT_ACTIVATION,
":</td><td></td></tr>\n", NULL);
jk_putv(s, "<tr><td>&nbsp;&nbsp;Active</td><td><input name=\"",
JK_STATUS_ARG_LBM_ACTIVATION, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_ACTIVATION_ACTIVE);
if (wr->s->activation == JK_LB_ACTIVATION_ACTIVE)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>&nbsp;&nbsp;Disabled</td><td><input name=\"",
JK_STATUS_ARG_LBM_ACTIVATION, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_ACTIVATION_DISABLED);
if (wr->s->activation == JK_LB_ACTIVATION_DISABLED)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>&nbsp;&nbsp;Stopped</td><td><input name=\"",
JK_STATUS_ARG_LBM_ACTIVATION, "\" type=\"radio\"", NULL);
jk_printf(s, " value=\"%d\"", JK_LB_ACTIVATION_STOPPED);
if (wr->s->activation == JK_LB_ACTIVATION_STOPPED)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/></td></tr>\n");
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LBM_TEXT_FACTOR,
":</td><td><input name=\"",
JK_STATUS_ARG_LBM_FACTOR, "\" type=\"text\" ", NULL);
jk_printf(s, "value=\"%d\"/></td></tr>\n", wr->s->lb_factor);
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LBM_TEXT_ROUTE,
":</td><td><input name=\"",
JK_STATUS_ARG_LBM_ROUTE, "\" type=\"text\" ", NULL);
jk_printf(s, "value=\"%s\"/></td></tr>\n", wr->s->route);
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LBM_TEXT_REDIRECT,
":</td><td><input name=\"",
JK_STATUS_ARG_LBM_REDIRECT, "\" type=\"text\" ", NULL);
jk_putv(s, "value=\"", wr->s->redirect, NULL);
jk_puts(s, "\"/></td></tr>\n");
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LBM_TEXT_DOMAIN,
":</td><td><input name=\"",
JK_STATUS_ARG_LBM_DOMAIN, "\" type=\"text\" ", NULL);
jk_putv(s, "value=\"", wr->s->domain, NULL);
jk_puts(s, "\"/></td></tr>\n");
jk_putv(s, "<tr><td>", JK_STATUS_ARG_LBM_TEXT_DISTANCE,
":</td><td><input name=\"",
JK_STATUS_ARG_LBM_DISTANCE, "\" type=\"text\" ", NULL);
jk_printf(s, "value=\"%d\"/></td></tr>\n", wr->s->distance);
jk_puts(s, "</table>\n");
jk_puts(s, "<br/><input type=\"submit\" value=\"Update Worker\"/>\n</form>\n");
JK_TRACE_EXIT(l);
}
static void form_all_members(jk_ws_service_t *s,
status_endpoint_t *p,
jk_worker_t *jw,
const char *attribute,
jk_logger_t *l)
{
const char *name = NULL;
lb_worker_t *lb = NULL;
status_worker_t *w = p->worker;
const char *aname;
unsigned int i;
JK_TRACE_ENTER(l);
if (!attribute) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' missing request parameter '%s'",
w->name, JK_STATUS_ARG_ATTRIBUTE);
JK_TRACE_EXIT(l);
return;
}
else {
if (!strcmp(attribute, JK_STATUS_ARG_LBM_ACTIVATION))
aname=JK_STATUS_ARG_LBM_TEXT_ACTIVATION;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_FACTOR))
aname=JK_STATUS_ARG_LBM_TEXT_FACTOR;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_ROUTE))
aname=JK_STATUS_ARG_LBM_TEXT_ROUTE;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_REDIRECT))
aname=JK_STATUS_ARG_LBM_TEXT_REDIRECT;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_DOMAIN))
aname=JK_STATUS_ARG_LBM_TEXT_DOMAIN;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_DISTANCE))
aname=JK_STATUS_ARG_LBM_TEXT_DISTANCE;
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' unknown attribute '%s'",
w->name, attribute);
JK_TRACE_EXIT(l);
return;
}
}
if (jw->type == JK_LB_WORKER_TYPE) {
lb = (lb_worker_t *)jw->worker_private;
name = lb->s->name;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' producing edit form for attribute '%s' [%s] of all members of lb worker '%s'",
w->name, attribute, aname, name);
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' worker type not implemented",
w->name);
JK_TRACE_EXIT(l);
return;
}
if (lb) {
jk_putv(s, "<hr/><h3>Edit attribute '", aname,
"' for all members of load balancer ",
name, "</h3>\n", NULL);
status_start_form(s, p, "GET", JK_STATUS_CMD_UPDATE, l);
jk_putv(s, "<table><tr>"
"<th>Balanced Worker</th><th>", aname, "</th>"
"</tr>", NULL);
for (i = 0; i < lb->num_of_workers; i++) {
worker_record_t *wr = &(lb->lb_workers[i]);
jk_putv(s, "<tr><td>", wr->s->name, "</td><td>\n", NULL);
if (!strcmp(attribute, JK_STATUS_ARG_LBM_ACTIVATION)) {
jk_printf(s, "Active:&nbsp;<input name=\"" JK_STATUS_ARG_MULT_VALUE_BASE "%d\" type=\"radio\"", i);
jk_printf(s, " value=\"%d\"", JK_LB_ACTIVATION_ACTIVE);
if (wr->s->activation == JK_LB_ACTIVATION_ACTIVE)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/>&nbsp;|&nbsp;\n");
jk_printf(s, "Disabled:&nbsp;<input name=\"" JK_STATUS_ARG_MULT_VALUE_BASE "%d\" type=\"radio\"", i);
jk_printf(s, " value=\"%d\"", JK_LB_ACTIVATION_DISABLED);
if (wr->s->activation == JK_LB_ACTIVATION_DISABLED)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/>&nbsp;|&nbsp;\n");
jk_printf(s, "Stopped:&nbsp;<input name=\"" JK_STATUS_ARG_MULT_VALUE_BASE "%d\" type=\"radio\"", i);
jk_printf(s, " value=\"%d\"", JK_LB_ACTIVATION_STOPPED);
if (wr->s->activation == JK_LB_ACTIVATION_STOPPED)
jk_puts(s, " checked=\"checked\"");
jk_puts(s, "/>\n");
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_FACTOR)) {
jk_printf(s, "<input name=\"" JK_STATUS_ARG_MULT_VALUE_BASE "%d\" type=\"text\"", i);
jk_printf(s, "value=\"%d\"/>\n", wr->s->lb_factor);
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_ROUTE)) {
jk_printf(s, "<input name=\"" JK_STATUS_ARG_MULT_VALUE_BASE "%d\" type=\"text\"", i);
jk_putv(s, "value=\"", wr->s->route, "\"/>\n", NULL);
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_REDIRECT)) {
jk_printf(s, "<input name=\"" JK_STATUS_ARG_MULT_VALUE_BASE "%d\" type=\"text\"", i);
jk_putv(s, "value=\"", wr->s->redirect, "\"/>\n", NULL);
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_DOMAIN)) {
jk_printf(s, "<input name=\"" JK_STATUS_ARG_MULT_VALUE_BASE "%d\" type=\"text\"", i);
jk_putv(s, "value=\"", wr->s->domain, "\"/>\n", NULL);
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_DISTANCE)) {
jk_printf(s, "<input name=\"" JK_STATUS_ARG_MULT_VALUE_BASE "%d\" type=\"text\"", i);
jk_printf(s, "value=\"%d\"/>\n", wr->s->distance);
}
jk_puts(s, "</td></tr>");
}
jk_puts(s, "</table>\n");
jk_puts(s, "<br/><input type=\"submit\" value=\"Update Balancer\"/></form>\n");
}
JK_TRACE_EXIT(l);
}
static void commit_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_worker_t *jw,
jk_logger_t *l)
{
const char *name = NULL;
lb_worker_t *lb = NULL;
status_worker_t *w = p->worker;
const char *arg;
int i;
JK_TRACE_ENTER(l);
if (jw->type == JK_LB_WORKER_TYPE) {
lb = (lb_worker_t *)jw->worker_private;
name = lb->s->name;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' committing changes for lb worker '%s'",
w->name, name);
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' worker type not implemented",
w->name);
JK_TRACE_EXIT(l);
return;
}
if (!lb) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' lb structure is (null)",
w->name);
JK_TRACE_EXIT(l);
return;
}
if (lb->sequence != lb->s->sequence)
jk_lb_pull(lb, l);
i = status_get_int(p, JK_STATUS_ARG_LB_RETRIES,
lb->retries, l);
if (i != lb->retries && i > 0) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'retries' for lb worker '%s' to '%i'",
w->name, name, i);
lb->retries = i;
}
i = status_get_int(p, JK_STATUS_ARG_LB_RECOVER_TIME,
lb->recover_wait_time, l);
if (i != lb->recover_wait_time && i > 0) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'recover_time' for lb worker '%s' to '%i'",
w->name, name, i);
lb->recover_wait_time = i;
}
i = status_get_bool(p, JK_STATUS_ARG_LB_STICKY, 0, l);
if (i != lb->sticky_session) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'sticky_session' for lb worker '%s' to '%i'",
w->name, name, i);
lb->sticky_session = i;
}
i = status_get_bool(p, JK_STATUS_ARG_LB_STICKY_FORCE, 0, l);
if (i != lb->sticky_session_force) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'sticky_session_force' for lb worker '%s' to '%i'",
w->name, name, i);
lb->sticky_session_force = i;
}
if (status_get_string(p, JK_STATUS_ARG_LB_METHOD, NULL, &arg, l) == JK_TRUE) {
i = jk_lb_get_method_code(arg);
if (i != lb->lbmethod && i >= 0 && i <= JK_LB_METHOD_MAX) {
lb->lbmethod = i;
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'method' for lb worker '%s' to '%s'",
w->name, name, jk_lb_get_method(lb, l));
}
}
if (status_get_string(p, JK_STATUS_ARG_LB_LOCK, NULL, &arg, l) == JK_TRUE) {
i = jk_lb_get_lock_code(arg);
if (i != lb->lblock && i >= 0 && i <= JK_LB_LOCK_MAX) {
lb->lblock = i;
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'lock' for lb worker '%s' to '%s'",
w->name, name, jk_lb_get_lock(lb, l));
}
}
lb->sequence++;
jk_lb_push(lb, l);
}
static int commit_member(jk_ws_service_t *s,
status_endpoint_t *p,
worker_record_t *wr,
const char *lb_name,
jk_logger_t *l)
{
const char *arg;
status_worker_t *w = p->worker;
int rc = 0;
int rv;
int i;
JK_TRACE_ENTER(l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' committing changes for sub worker '%s' of lb worker '%s'",
w->name, wr->s->name, lb_name);
if (status_get_string(p, JK_STATUS_ARG_LBM_ACTIVATION, NULL, &arg, l) == JK_TRUE) {
i = jk_lb_get_activation_code(arg);
if (i != wr->s->activation && i >= 0 && i <= JK_LB_ACTIVATION_MAX) {
wr->s->activation = i;
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'activation' for sub worker '%s' of lb worker '%s' to '%s'",
w->name, wr->s->name, lb_name, jk_lb_get_activation(wr, l));
rc |= 1;
}
}
i = status_get_int(p, JK_STATUS_ARG_LBM_FACTOR,
wr->s->lb_factor, l);
if (i != wr->s->lb_factor && i > 0) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'lbfactor' for sub worker '%s' of lb worker '%s' to '%i'",
w->name, wr->s->name, lb_name, i);
wr->s->lb_factor = i;
/* Recalculate the load multiplicators wrt. lb_factor */
rc |= 2;
}
if ((rv = status_get_string(p, JK_STATUS_ARG_LBM_ROUTE,
NULL, &arg, l)) == JK_TRUE) {
if (strncmp(wr->s->route, arg, JK_SHM_STR_SIZ)) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'route' for sub worker '%s' of lb worker '%s' to '%s'",
w->name, wr->s->name, lb_name, arg);
strncpy(wr->s->route, arg, JK_SHM_STR_SIZ);
if (!wr->s->domain[0]) {
char * id_domain = strchr(wr->s->route, '.');
if (id_domain) {
*id_domain = '\0';
strcpy(wr->s->domain, wr->s->route);
*id_domain = '.';
}
}
}
}
if ((rv = status_get_string(p, JK_STATUS_ARG_LBM_REDIRECT,
NULL, &arg, l)) == JK_TRUE) {
if (strncmp(wr->s->redirect, arg, JK_SHM_STR_SIZ)) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'redirect' for sub worker '%s' of lb worker '%s' to '%s'",
w->name, wr->s->name, lb_name, arg);
strncpy(wr->s->redirect, arg, JK_SHM_STR_SIZ);
}
}
if ((rv = status_get_string(p, JK_STATUS_ARG_LBM_DOMAIN,
NULL, &arg, l)) == JK_TRUE) {
if (strncmp(wr->s->domain, arg, JK_SHM_STR_SIZ)) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'domain' for sub worker '%s' of lb worker '%s' to '%s'",
w->name, wr->s->name, lb_name, arg);
strncpy(wr->s->domain, arg, JK_SHM_STR_SIZ);
}
}
i = status_get_int(p, JK_STATUS_ARG_LBM_DISTANCE,
wr->s->distance, l);
if (i != wr->s->distance && i > 0) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'distance' for sub worker '%s' of lb worker '%s' to '%i'",
w->name, wr->s->name, lb_name, i);
wr->s->distance = i;
}
return rc;
}
static void commit_all_members(jk_ws_service_t *s,
status_endpoint_t *p,
jk_worker_t *jw,
const char *attribute,
jk_logger_t *l)
{
const char *arg;
char vname[32];
const char *name = NULL;
lb_worker_t *lb = NULL;
status_worker_t *w = p->worker;
const char *aname;
int i;
int rc = 0;
unsigned int j;
JK_TRACE_ENTER(l);
if (!attribute) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' missing request parameter '%s'",
w->name, JK_STATUS_ARG_ATTRIBUTE);
JK_TRACE_EXIT(l);
return;
}
else {
if (!strcmp(attribute, JK_STATUS_ARG_LBM_ACTIVATION))
aname=JK_STATUS_ARG_LBM_TEXT_ACTIVATION;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_FACTOR))
aname=JK_STATUS_ARG_LBM_TEXT_FACTOR;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_ROUTE))
aname=JK_STATUS_ARG_LBM_TEXT_ROUTE;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_REDIRECT))
aname=JK_STATUS_ARG_LBM_TEXT_REDIRECT;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_DOMAIN))
aname=JK_STATUS_ARG_LBM_TEXT_DOMAIN;
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_DISTANCE))
aname=JK_STATUS_ARG_LBM_TEXT_DISTANCE;
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' unknown attribute '%s'",
w->name, attribute);
JK_TRACE_EXIT(l);
return;
}
}
if (jw->type == JK_LB_WORKER_TYPE) {
lb = (lb_worker_t *)jw->worker_private;
name = lb->s->name;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' committing changes for attribute '%s' [%s] of all members of lb worker '%s'",
w->name, attribute, aname, name);
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' worker type not implemented",
w->name);
JK_TRACE_EXIT(l);
return;
}
if (lb) {
for (j = 0; j < lb->num_of_workers; j++) {
worker_record_t *wr = &(lb->lb_workers[j]);
snprintf(vname, 32-1, "" JK_STATUS_ARG_MULT_VALUE_BASE "%d", j);
if (!strcmp(attribute, JK_STATUS_ARG_LBM_FACTOR)) {
i = status_get_int(p, vname, wr->s->lb_factor, l);
if (i != wr->s->lb_factor && i > 0) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'lbfactor' for sub worker '%s' of lb worker '%s' to '%i'",
w->name, wr->s->name, name, i);
wr->s->lb_factor = i;
rc = 2;
}
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_DISTANCE)) {
i = status_get_int(p, vname, wr->s->distance, l);
if (i != wr->s->distance && i > 0) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'distance' for sub worker '%s' of lb worker '%s' to '%i'",
w->name, wr->s->name, name, i);
wr->s->lb_factor = i;
}
}
else {
int rv = status_get_string(p, vname, NULL, &arg, l);
if (!strcmp(attribute, JK_STATUS_ARG_LBM_ACTIVATION)) {
if (rv == JK_TRUE) {
i = jk_lb_get_activation_code(arg);
if (i != wr->s->activation && i >= 0 && i <= JK_LB_ACTIVATION_MAX) {
wr->s->activation = i;
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'activation' for sub worker '%s' of lb worker '%s' to '%s'",
w->name, wr->s->name, name, jk_lb_get_activation(wr, l));
rc = 1;
}
}
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_ROUTE)) {
if (rv == JK_TRUE) {
if (strncmp(wr->s->route, arg, JK_SHM_STR_SIZ)) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'route' for sub worker '%s' of lb worker '%s' to '%s'",
w->name, wr->s->name, name, arg);
strncpy(wr->s->route, arg, JK_SHM_STR_SIZ);
if (!wr->s->domain[0]) {
char * id_domain = strchr(wr->s->route, '.');
if (id_domain) {
*id_domain = '\0';
strcpy(wr->s->domain, wr->s->route);
*id_domain = '.';
}
}
}
}
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_REDIRECT)) {
if (rv == JK_TRUE) {
if (strncmp(wr->s->redirect, arg, JK_SHM_STR_SIZ)) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'redirect' for sub worker '%s' of lb worker '%s' to '%s'",
w->name, wr->s->name, name, arg);
strncpy(wr->s->redirect, arg, JK_SHM_STR_SIZ);
}
}
}
else if (!strcmp(attribute, JK_STATUS_ARG_LBM_DOMAIN)) {
if (rv == JK_TRUE) {
if (strncmp(wr->s->domain, arg, JK_SHM_STR_SIZ)) {
jk_log(l, JK_LOG_INFO,
"Status worker '%s' setting 'domain' for sub worker '%s' of lb worker '%s' to '%s'",
w->name, wr->s->name, name, arg);
strncpy(wr->s->domain, arg, JK_SHM_STR_SIZ);
}
}
}
}
}
if (rc == 1)
reset_lb_values(lb, l);
else if (rc == 2)
/* Recalculate the load multiplicators wrt. lb_factor */
update_mult(lb, l);
}
JK_TRACE_EXIT(l);
}
static void display_legend(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
int mime;
const char *arg;
unsigned int hide_legend;
JK_TRACE_ENTER(l);
status_get_string(p, JK_STATUS_ARG_MIME, NULL, &arg, l);
mime = status_mime_int(arg);
if (mime != JK_STATUS_MIME_HTML) {
JK_TRACE_EXIT(l);
return;
}
hide_legend = status_get_int(p, JK_STATUS_ARG_OPTIONS, 0, l) &
JK_STATUS_ARG_OPTION_NO_LEGEND;
if (hide_legend) {
jk_puts(s, "<p>\n");
status_write_uri(s, p, "Show Legend", JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, JK_STATUS_ARG_OPTION_NO_LEGEND, NULL, l);
jk_puts(s, "</p>\n");
}
else {
jk_puts(s, "<h2>Legend [");
status_write_uri(s, p, "Hide", JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, JK_STATUS_ARG_OPTION_NO_LEGEND, 0, NULL, l);
jk_puts(s, "]</h2>\n");
jk_puts(s, "<table>\n"
"<tbody valign=\"baseline\">\n"
"<tr><th>Name</th><td>Worker name</td></tr>\n"
"<tr><th>Type</th><td>Worker type</td></tr>\n"
"<tr><th>Route</th><td>Worker route</td></tr>\n"
"<tr><th>Addr</th><td>Backend Address info</td></tr>\n"
"<tr><th>Act</th><td>Worker activation configuration<br/>\n"
"ACT=Active, DIS=Disabled, STP=Stopped</td></tr>\n"
"<tr><th>Stat</th><td>Worker error status<br/>\n"
"OK=OK, N/A=Unknown, ERR=Error, BSY=Busy<br/>\n"
"REC=Recovering, PRB=Probing, FRC=Forced Recovery</td></tr>\n"
"<tr><th>D</th><td>Worker distance</td></tr>\n"
"<tr><th>F</th><td>Load Balancer factor</td></tr>\n"
"<tr><th>M</th><td>Load Balancer multiplicity</td></tr>\n"
"<tr><th>V</th><td>Load Balancer value</td></tr>\n"
"<tr><th>Acc</th><td>Number of requests</td></tr>\n"
"<tr><th>Err</th><td>Number of failed requests</td></tr>\n"
"<tr><th>CE</th><td>Number of client errors</td></tr>\n"
"<tr><th>Wr</th><td>Number of bytes transferred/min</td></tr>\n"
"<tr><th>Rd</th><td>Number of bytes read/min</td></tr>\n"
"<tr><th>Busy</th><td>Current number of busy connections</td></tr>\n"
"<tr><th>Max</th><td>Maximum number of busy connections</td></tr>\n"
"<tr><th>RR</th><td>Route redirect</td></tr>\n"
"<tr><th>Cd</th><td>Cluster domain</td></tr>\n"
"<tr><th>Rs</th><td>Recovery scheduled in app. min/max seconds</td></tr>\n"
"</tbody>\n"
"</table>\n");
}
JK_TRACE_EXIT(l);
}
static int check_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
jk_worker_t *jw = NULL;
worker_record_t *wr = NULL;
JK_TRACE_ENTER(l);
fetch_worker_and_sub_worker(p, "checking", &worker, &sub_worker, l);
if (search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (sub_worker && sub_worker[0]) {
if(search_sub_worker(s, p, jw, worker, &wr, sub_worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static void count_workers(jk_ws_service_t *s,
status_endpoint_t *p,
int *lb_cnt, int *ajp_cnt,
jk_logger_t *l)
{
unsigned int i;
jk_worker_t *jw = NULL;
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
*lb_cnt = 0;
*ajp_cnt = 0;
for (i = 0; i < w->we->num_of_workers; i++) {
jw = wc_get_worker_for_name(w->we->worker_list[i], l);
if (!jw) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' could not find worker '%s'",
w->name, w->we->worker_list[i]);
continue;
}
if (jw->type == JK_LB_WORKER_TYPE) {
(*lb_cnt)++;
}
else if (jw->type == JK_AJP13_WORKER_TYPE ||
jw->type == JK_AJP14_WORKER_TYPE) {
(*ajp_cnt)++;
}
}
JK_TRACE_EXIT(l);
}
static void list_workers_type(jk_ws_service_t *s,
status_endpoint_t *p,
int list_lb, int count,
jk_logger_t *l)
{
const char *arg;
unsigned int i;
int mime;
unsigned int hide;
jk_worker_t *jw = NULL;
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
status_get_string(p, JK_STATUS_ARG_MIME, NULL, &arg, l);
mime = status_mime_int(arg);
if (list_lb) {
hide = status_get_int(p, JK_STATUS_ARG_OPTIONS, 0, l) &
JK_STATUS_ARG_OPTION_NO_LB;
if (hide) {
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "<p>\n");
status_write_uri(s, p, "Show Load Balancing Workers", JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, JK_STATUS_ARG_OPTION_NO_LB, NULL, l);
jk_puts(s, "</p>\n");
}
}
else {
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 0, 0, "balancers");
jk_print_xml_att_int(s, 2, "count", count);
jk_print_xml_stop_elt(s, 0, 0);
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_printf(s, "Balancer Workers: count=%d\n", count);
}
else if (mime == JK_STATUS_MIME_PROP) {
jk_print_prop_att_int(s, w, NULL, "lb_count", count);
}
else {
jk_printf(s, "<hr/><h2>Listing Load Balancing Worker%s (%d Worker%s) [",
count>1 ? "s" : "", count, count>1 ? "s" : "");
status_write_uri(s, p, "Hide", JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, JK_STATUS_ARG_OPTION_NO_LB, 0, NULL, l);
jk_puts(s, "]</h2>\n");
}
}
}
else {
hide = status_get_int(p, JK_STATUS_ARG_OPTIONS, 0, l) &
JK_STATUS_ARG_OPTION_NO_AJP;
if (hide) {
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "<p>\n");
status_write_uri(s, p, "Show AJP Workers", JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, JK_STATUS_ARG_OPTION_NO_AJP, NULL, l);
jk_puts(s, "</p>\n");
}
}
else {
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 0, 0, "ajp_workers");
jk_print_xml_att_int(s, 2, "count", count);
jk_print_xml_stop_elt(s, 0, 0);
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_printf(s, "AJP Workers: count=%d\n", count);
}
else if (mime == JK_STATUS_MIME_PROP) {
jk_print_prop_att_int(s, w, NULL, "ajp_count", count);
}
else {
jk_printf(s, "<hr/><h2>Listing AJP Worker%s (%d Worker%s) [",
count>1 ? "s" : "", count, count>1 ? "s" : "");
status_write_uri(s, p, "Hide", JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, JK_STATUS_ARG_OPTION_NO_AJP, 0, NULL, l);
jk_puts(s, "]</h2>\n");
}
}
}
if (hide) {
JK_TRACE_EXIT(l);
return;
}
for (i = 0; i < w->we->num_of_workers; i++) {
jw = wc_get_worker_for_name(w->we->worker_list[i], l);
if (!jw) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' could not find worker '%s'",
w->name, w->we->worker_list[i]);
continue;
}
if ((list_lb && jw->type == JK_LB_WORKER_TYPE) ||
(!list_lb && jw->type != JK_LB_WORKER_TYPE)) {
display_worker(s, p, jw, l);
}
}
if (list_lb) {
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_close_elt(s, w, 0, "balancers");
}
else if (mime == JK_STATUS_MIME_TXT) {
}
else if (mime == JK_STATUS_MIME_PROP) {
}
else if (mime == JK_STATUS_MIME_HTML) {
}
}
else {
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_close_elt(s, w, 0, "ajp_workers");
}
else if (mime == JK_STATUS_MIME_TXT) {
}
else if (mime == JK_STATUS_MIME_PROP) {
}
else if (mime == JK_STATUS_MIME_HTML) {
}
}
JK_TRACE_EXIT(l);
}
static int list_workers(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
int lb_cnt = 0;
int ajp_cnt = 0;
JK_TRACE_ENTER(l);
count_workers(s, p, &lb_cnt, &ajp_cnt, l);
if (lb_cnt) {
list_workers_type(s, p, 1, lb_cnt, l);
}
if (ajp_cnt) {
list_workers_type(s, p, 0, ajp_cnt, l);
}
display_legend(s, p, l);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int show_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
jk_worker_t *jw = NULL;
JK_TRACE_ENTER(l);
fetch_worker_and_sub_worker(p, "showing", &worker, &sub_worker, l);
if (search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
display_worker(s, p, jw, l);
display_legend(s, p, l);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int edit_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
jk_worker_t *jw = NULL;
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
fetch_worker_and_sub_worker(p, "editing", &worker, &sub_worker, l);
if (search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (!sub_worker || !sub_worker[0]) {
const char *arg;
if (status_get_string(p, JK_STATUS_ARG_ATTRIBUTE,
NULL, &arg, l) == JK_TRUE)
form_all_members(s, p, jw, arg, l);
else
form_worker(s, p, jw, l);
}
else {
worker_record_t *wr = NULL;
if (jw->type != JK_LB_WORKER_TYPE) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' worker type not implemented",
w->name);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if(search_sub_worker(s, p, jw, worker, &wr, sub_worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
form_member(s, p, wr, worker, l);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int update_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
jk_worker_t *jw = NULL;
JK_TRACE_ENTER(l);
fetch_worker_and_sub_worker(p, "updating", &worker, &sub_worker, l);
if (search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (!sub_worker || !sub_worker[0]) {
const char *arg;
if (status_get_string(p, JK_STATUS_ARG_ATTRIBUTE,
NULL, &arg, l) == JK_TRUE)
commit_all_members(s, p, jw, arg, l);
else
commit_worker(s, p, jw, l);
}
else {
lb_worker_t *lb = NULL;
worker_record_t *wr = NULL;
int rc = 0;
if (check_valid_lb(s, p, jw, worker, &lb, 0, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if(search_sub_worker(s, p, jw, worker, &wr, sub_worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
rc = commit_member(s, p, wr, lb->s->name, l);
if (rc & 1)
reset_lb_values(lb, l);
if (rc & 2)
/* Recalculate the load multiplicators wrt. lb_factor */
update_mult(lb, l);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int reset_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
unsigned int i;
const char *worker;
const char *sub_worker;
jk_worker_t *jw = NULL;
lb_worker_t *lb = NULL;
worker_record_t *wr = NULL;
JK_TRACE_ENTER(l);
fetch_worker_and_sub_worker(p, "resetting", &worker, &sub_worker, l);
if (search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
/* XXX Until now, we only have something to reset for lb workers or their members */
if (check_valid_lb(s, p, jw, worker, &lb, 0, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (!sub_worker || !sub_worker[0]) {
lb->s->max_busy = 0;
for (i = 0; i < lb->num_of_workers; i++) {
wr = &(lb->lb_workers[i]);
wr->s->client_errors = 0;
wr->s->elected = 0;
wr->s->elected_snapshot = 0;
wr->s->error_time = 0;
wr->s->errors = 0;
wr->s->lb_value = 0;
wr->s->max_busy = 0;
wr->s->recoveries = 0;
wr->s->recovery_errors = 0;
wr->s->readed = 0;
wr->s->transferred = 0;
wr->s->state = JK_LB_STATE_NA;
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
if(search_sub_worker(s, p, jw, worker, &wr, sub_worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
wr->s->client_errors = 0;
wr->s->elected = 0;
wr->s->elected_snapshot = 0;
wr->s->error_time = 0;
wr->s->errors = 0;
wr->s->lb_value = 0;
wr->s->max_busy = 0;
wr->s->recoveries = 0;
wr->s->recovery_errors = 0;
wr->s->readed = 0;
wr->s->transferred = 0;
wr->s->state = JK_LB_STATE_NA;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int recover_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
jk_worker_t *jw = NULL;
worker_record_t *wr = NULL;
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
fetch_worker_and_sub_worker(p, "recovering", &worker, &sub_worker, l);
if (search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if(search_sub_worker(s, p, jw, worker, &wr, sub_worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (wr->s->state == JK_LB_STATE_ERROR) {
wr->s->state = JK_LB_STATE_RECOVER;
jk_log(l, JK_LOG_INFO,
"Status worker '%s' marked worker '%s' sub worker '%s' for recovery",
w->name, worker ? worker : "(null)", sub_worker ? sub_worker : "(null)");
JK_TRACE_EXIT(l);
return JK_TRUE;
}
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' could not mark worker '%s' sub worker '%s' for recovery - state %s is not an error state",
w->name, worker ? worker : "(null)", sub_worker ? sub_worker : "(null)",
jk_lb_get_state(wr, l));
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD service(jk_endpoint_t *e,
jk_ws_service_t *s,
jk_logger_t *l, int *is_error)
{
int cmd;
int mime;
int refresh;
int read_only = 0;
const char *arg;
char *err = NULL;
status_endpoint_t *p;
status_worker_t *w;
int denied = 0;
JK_TRACE_ENTER(l);
if (is_error)
*is_error = JK_FALSE;
if (!e || !e->endpoint_private || !s || !is_error) {
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p = e->endpoint_private;
w = p->worker;
if (w->num_of_users) {
if (s->remote_user) {
unsigned int i;
denied = 1;
for (i = 0; i < w->num_of_users; i++) {
if (w->user_case_insensitive) {
if (!strcasecmp(s->remote_user, w->user_names[i])) {
denied = 0;
break;
}
}
else {
if (!strcmp(s->remote_user, w->user_names[i])) {
denied = 0;
break;
}
}
}
}
else {
denied = 2;
}
}
/* Step 1: Process GET params and update configuration */
if (status_parse_uri(s, p, l) != JK_TRUE) {
err = "Error during parsing of URI";
}
status_get_string(p, JK_STATUS_ARG_CMD, NULL, &arg, l);
cmd = status_cmd_int(arg);
status_get_string(p, JK_STATUS_ARG_MIME, NULL, &arg, l);
mime = status_mime_int(arg);
refresh = status_get_int(p, JK_STATUS_ARG_REFRESH, 0, l);
if (w->read_only) {
read_only = 1;
}
else {
read_only = status_get_int(p, JK_STATUS_ARG_OPTIONS, 0, l) &
JK_STATUS_ARG_OPTION_READ_ONLY;
}
if (mime == JK_STATUS_MIME_HTML) {
s->start_response(s, 200, "OK", headers_names, headers_vhtml, 3);
jk_puts(s, JK_STATUS_HEAD);
}
else if (mime == JK_STATUS_MIME_XML) {
s->start_response(s, 200, "OK", headers_names, headers_vxml, 3);
jk_puts(s, JK_STATUS_XMLH);
if (w->doctype) {
jk_putv(s, w->doctype, "\n", NULL);
}
jk_print_xml_start_elt(s, w, 0, 0, "status");
if (w->xmlns && strlen(w->xmlns))
jk_putv(s, " ", w->xmlns, NULL);
jk_print_xml_stop_elt(s, 0, 0);
}
else {
s->start_response(s, 200, "OK", headers_names, headers_vtxt, 3);
}
if (denied == 0) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' service allowed for user '%s' [%s] from %s [%s]",
w->name,
s->remote_user ? s->remote_user : "(null)",
s->auth_type ? s->auth_type : "(null)",
s->remote_addr ? s->remote_addr : "(null)",
s->remote_host ? s->remote_host : "(null)");
}
else if (denied == 1) {
err = "Access denied.";
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' service denied for user '%s' [%s] from %s [%s]",
w->name,
s->remote_user ? s->remote_user : "(null)",
s->auth_type ? s->auth_type : "(null)",
s->remote_addr ? s->remote_addr : "(null)",
s->remote_host ? s->remote_host : "(null)");
}
else if (denied == 2) {
err = "Access denied.";
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' service denied (no user) [%s] from %s [%s]",
w->name,
s->remote_user ? s->remote_user : "(null)",
s->auth_type ? s->auth_type : "(null)",
s->remote_addr ? s->remote_addr : "(null)",
s->remote_host ? s->remote_host : "(null)");
}
else {
err = "Access denied.";
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' service denied (unknown reason) for user '%s' [%s] from %s [%s]",
w->name,
s->remote_user ? s->remote_user : "(null)",
s->auth_type ? s->auth_type : "(null)",
s->remote_addr ? s->remote_addr : "(null)",
s->remote_host ? s->remote_host : "(null)");
}
if (!err) {
if (read_only &&
(cmd == JK_STATUS_CMD_EDIT ||
cmd == JK_STATUS_CMD_UPDATE ||
cmd == JK_STATUS_CMD_RESET ||
cmd == JK_STATUS_CMD_RECOVER)) {
err = "This command is not allowed in read only mode.";
}
}
if (!err) {
if (cmd == JK_STATUS_CMD_UNKNOWN) {
err = "Invalid command.";
}
else if (mime == JK_STATUS_MIME_UNKNOWN) {
err = "Invalid mime type.";
}
else if (cmd != JK_STATUS_CMD_LIST &&
cmd != JK_STATUS_CMD_VERSION &&
(check_worker(s, p, l) != JK_TRUE)) {
err = p->msg;
}
}
if (!err) {
if (cmd == JK_STATUS_CMD_UPDATE) {
/* lock shared memory */
jk_shm_lock();
if (update_worker(s, p, l) == JK_FALSE) {
err = "Update failed";
}
/* unlock the shared memory */
jk_shm_unlock();
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "\n<meta http-equiv=\"Refresh\" content=\""
JK_STATUS_WAIT_AFTER_UPDATE ";url=");
status_write_uri(s, p, NULL, JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, 0, NULL, l);
jk_puts(s, "\">");
if (!err) {
jk_putv(s, "<p><b>Result: OK - You will be redirected in "
JK_STATUS_WAIT_AFTER_UPDATE " seconds.</b><p/>", NULL);
}
}
}
else if (cmd == JK_STATUS_CMD_RESET) {
/* lock shared memory */
jk_shm_lock();
if (reset_worker(s, p, l) == JK_FALSE) {
err = "Reset failed";
}
/* unlock the shared memory */
jk_shm_unlock();
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "\n<meta http-equiv=\"Refresh\" content=\""
JK_STATUS_WAIT_AFTER_UPDATE ";url=");
status_write_uri(s, p, NULL, JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, 0, NULL, l);
jk_puts(s, "\">");
if (!err) {
jk_putv(s, "<p><b>Result: OK - You will be redirected in "
JK_STATUS_WAIT_AFTER_UPDATE " seconds.</b><p/>", NULL);
}
}
}
else if (cmd == JK_STATUS_CMD_RECOVER) {
/* lock shared memory */
jk_shm_lock();
if (recover_worker(s, p, l) == JK_FALSE) {
err = "Marking worker for recovery failed";
}
/* unlock the shared memory */
jk_shm_unlock();
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "\n<meta http-equiv=\"Refresh\" content=\""
JK_STATUS_WAIT_AFTER_UPDATE ";url=");
status_write_uri(s, p, NULL, JK_STATUS_CMD_UNKNOWN, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, 0, NULL, l);
jk_puts(s, "\">");
if (!err) {
jk_putv(s, "<p><b>Result: OK - You will be redirected in "
JK_STATUS_WAIT_AFTER_UPDATE " seconds.</b><p/>", NULL);
}
}
}
else {
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 0, 0, "server");
jk_print_xml_att_string(s, 2, "name", s->server_name);
jk_print_xml_att_int(s, 2, "port", s->server_port);
jk_print_xml_stop_elt(s, 0, 1);
if ((cmd == JK_STATUS_CMD_LIST) ||
(cmd == JK_STATUS_CMD_SHOW) ||
(cmd == JK_STATUS_CMD_VERSION)) {
jk_print_xml_start_elt(s, w, 0, 0, "software");
jk_print_xml_att_string(s, 2, "web_server", s->server_software);
jk_print_xml_att_string(s, 2, "jk_version", JK_EXPOSED_VERSION);
jk_print_xml_stop_elt(s, 0, 1);
}
if (cmd == JK_STATUS_CMD_LIST) {
/* Step 2: Display configuration */
if (list_workers(s, p, l) != JK_TRUE) {
err = "Error in listing the workers.";
}
}
else if (cmd == JK_STATUS_CMD_SHOW) {
/* Step 2: Display detailed configuration */
if(show_worker(s, p, l) != JK_TRUE) {
err = "Error in showing this worker.";
}
}
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "Server:");
jk_printf(s, " name=%s", s->server_name);
jk_printf(s, " port=%d", s->server_port);
jk_puts(s, "\n");
if ((cmd == JK_STATUS_CMD_LIST) ||
(cmd == JK_STATUS_CMD_SHOW) ||
(cmd == JK_STATUS_CMD_VERSION)) {
jk_puts(s, "Software:");
jk_printf(s, " web_server=\"%s\"", s->server_software);
jk_printf(s, " jk_version=%s", JK_EXPOSED_VERSION);
jk_puts(s, "\n");
}
if (cmd == JK_STATUS_CMD_LIST) {
/* Step 2: Display configuration */
if (list_workers(s, p, l) != JK_TRUE) {
err = "Error in listing the workers.";
}
}
else if (cmd == JK_STATUS_CMD_SHOW) {
/* Step 2: Display detailed configuration */
if(show_worker(s, p, l) != JK_TRUE) {
err = "Error in showing this worker.";
}
}
}
else if (mime == JK_STATUS_MIME_PROP) {
jk_print_prop_att_string(s, w, NULL, "server_name", s->server_name);
jk_print_prop_att_int(s, w, NULL, "server_port", s->server_port);
if ((cmd == JK_STATUS_CMD_LIST) ||
(cmd == JK_STATUS_CMD_SHOW) ||
(cmd == JK_STATUS_CMD_VERSION)) {
jk_print_prop_att_string(s, w, NULL, "web_server", s->server_software);
jk_print_prop_att_string(s, w, NULL, "jk_version", JK_EXPOSED_VERSION);
}
if (cmd == JK_STATUS_CMD_LIST) {
/* Step 2: Display configuration */
if (list_workers(s, p, l) != JK_TRUE) {
err = "Error in listing the workers.";
}
}
else if (cmd == JK_STATUS_CMD_SHOW) {
/* Step 2: Display detailed configuration */
if(show_worker(s, p, l) != JK_TRUE) {
err = "Error in showing this worker.";
}
}
}
else if (mime == JK_STATUS_MIME_HTML) {
if ((cmd == JK_STATUS_CMD_LIST ||
cmd == JK_STATUS_CMD_SHOW) &&
refresh > 0) {
jk_printf(s, "\n<meta http-equiv=\"Refresh\" content=\"%d;url=%s?%s\">",
refresh, s->req_uri, s->query_string);
}
if (w->css) {
jk_putv(s, "\n<link rel=\"stylesheet\" type=\"text/css\" href=\"",
w->css, "\" />\n", NULL);
}
jk_puts(s, JK_STATUS_HEND);
jk_puts(s, "<h1>JK Status Manager for ");
jk_puts(s, s->server_name);
jk_printf(s, ":%d", s->server_port);
if (read_only) {
jk_puts(s, " (read only)");
}
jk_puts(s, "</h1>\n\n");
if ((cmd == JK_STATUS_CMD_LIST) ||
(cmd == JK_STATUS_CMD_SHOW) ||
(cmd == JK_STATUS_CMD_VERSION)) {
jk_putv(s, "<table><tr><td>Server Version:</td><td>",
s->server_software, "</td></tr>\n", NULL);
jk_putv(s, "<tr><td>JK Version:</td><td>",
JK_EXPOSED_VERSION, "</td></tr></table>\n", NULL);
jk_puts(s, "<hr/>\n");
}
if (cmd == JK_STATUS_CMD_LIST ||
cmd == JK_STATUS_CMD_SHOW) {
if (refresh > 0) {
const char *str = s->query_string;
char *buf = jk_pool_alloc(s->pool, sizeof(char *) * (strlen(str)+1));
int result = 0;
size_t scan = 0;
size_t len = strlen(JK_STATUS_ARG_REFRESH);
while (str[scan] != '\0') {
if (strncmp(&str[scan], JK_STATUS_ARG_REFRESH, len) == 0 &&
str[scan+len] == '=') {
scan += len + 1;
while (str[scan] != '\0' && str[scan] != '&')
scan++;
if (str[scan] == '&')
scan++;
}
else {
if (result > 0 && str[scan] != '\0' && str[scan] != '&') {
buf[result] = '&';
result++;
}
while (str[scan] != '\0' && str[scan] != '&') {
buf[result] = str[scan];
result++;
scan++;
}
if (str[scan] == '&')
scan++;
}
}
buf[result] = '\0';
jk_putv(s, "[<a href=\"", s->req_uri, NULL);
if (buf && buf[0])
jk_putv(s, "?", buf, NULL);
jk_puts(s, "\">Stop auto refresh</a>]&nbsp;&nbsp;");
}
else {
status_start_form(s, p, "GET", JK_STATUS_CMD_UNKNOWN, l);
jk_puts(s, "<input type=\"submit\" value=\"Start auto refresh\"/>\n");
jk_putv(s, "(every ",
"<input name=\"", JK_STATUS_ARG_REFRESH,
"\" type=\"text\" size=\"3\" value=\"",
JK_STATUS_REFRESH_DEF "\"/> ",
"seconds)", NULL);
jk_puts(s, "</form>\n");
}
}
if (cmd == JK_STATUS_CMD_SHOW ||
cmd == JK_STATUS_CMD_EDIT ||
cmd == JK_STATUS_CMD_VERSION) {
int from;
status_get_string(p, JK_STATUS_ARG_FROM, NULL, &arg, l);
from = status_cmd_int(arg);
jk_puts(s, "[");
if (cmd == JK_STATUS_CMD_SHOW ||
cmd == JK_STATUS_CMD_VERSION ||
from == JK_STATUS_CMD_LIST) {
status_write_uri(s, p, "Back to worker list", JK_STATUS_CMD_LIST, JK_STATUS_MIME_UNKNOWN,
"", "", 0, 0, "", l);
}
else {
status_write_uri(s, p, "Back to worker view", JK_STATUS_CMD_SHOW, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, 0, "", l);
}
jk_puts(s, "]&nbsp;&nbsp;");
}
if (cmd == JK_STATUS_CMD_LIST ||
cmd == JK_STATUS_CMD_SHOW ||
cmd == JK_STATUS_CMD_VERSION) {
jk_puts(s, "[Change&nbsp;Format: ");
status_write_uri(s, p, "XML", 0, JK_STATUS_MIME_XML,
NULL, NULL, 0, 0, NULL, l);
jk_puts(s, "&nbsp;|&nbsp;");
status_write_uri(s, p, "Property", 0, JK_STATUS_MIME_PROP,
NULL, NULL, 0, 0, NULL, l);
jk_puts(s, "&nbsp;|&nbsp;");
status_write_uri(s, p, "Text", 0, JK_STATUS_MIME_TXT,
NULL, NULL, 0, 0, NULL, l);
jk_puts(s, "]&nbsp;&nbsp;");
}
if (cmd == JK_STATUS_CMD_LIST || cmd == JK_STATUS_CMD_SHOW) {
if (!w->read_only) {
jk_puts(s, "[");
if (read_only) {
status_write_uri(s, p, "Read/Write", 0, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, 0, JK_STATUS_ARG_OPTION_READ_ONLY, NULL, l);
}
else {
status_write_uri(s, p, "Read Only", 0, JK_STATUS_MIME_UNKNOWN,
NULL, NULL, JK_STATUS_ARG_OPTION_READ_ONLY, 0, NULL, l);
}
jk_puts(s, "]&nbsp;&nbsp;\n");
}
}
if (cmd == JK_STATUS_CMD_LIST || cmd == JK_STATUS_CMD_SHOW) {
jk_puts(s, "[");
if (cmd == JK_STATUS_CMD_LIST)
jk_puts(s, "<b>S</b>=Show only this worker");
if (!read_only && cmd == JK_STATUS_CMD_LIST)
jk_puts(s, ", ");
if (!read_only)
jk_puts(s, "<b>E</b>=Edit worker, <b>R</b>=Reset worker state, <b>T</b>=Try worker recovery");
jk_puts(s, "]\n");
}
if (cmd == JK_STATUS_CMD_LIST) {
/* Step 2: Display configuration */
if (list_workers(s, p, l) != JK_TRUE) {
err = "Error in listing the workers.";
}
}
else if (cmd == JK_STATUS_CMD_SHOW) {
/* Step 2: Display detailed configuration */
if(show_worker(s, p, l) != JK_TRUE) {
err = "Error in showing this worker.";
}
}
else if (cmd == JK_STATUS_CMD_EDIT) {
/* Step 2: Display edit form */
if(edit_worker(s, p, l) != JK_TRUE) {
err = "Error in generating this worker's configuration form.";
}
}
}
}
}
if (err) {
jk_log(l, JK_LOG_WARNING, "Status worker '%s': %s", w->name, err);
if (mime == JK_STATUS_MIME_HTML) {
jk_putv(s, "<p><b>Result: ERROR - ", err, "</b><br/>", NULL);
jk_putv(s, "<a href=\"", s->req_uri, "\">JK Status Manager Start Page</a></p>", NULL);
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 2, 0, "result");
jk_print_xml_att_string(s, 4, "type", "ERROR");
jk_print_xml_att_string(s, 4, "message", err);
jk_print_xml_stop_elt(s, 2, 1);
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "Result:");
jk_printf(s, " type=%s", "ERROR");
jk_printf(s, " message=\"%s\"", err);
jk_puts(s, "\n");
}
else {
jk_print_prop_att_string(s, w, "result", "type", "ERROR");
jk_print_prop_att_string(s, w, "result", "message", err);
}
}
else {
if (mime == JK_STATUS_MIME_HTML) {
jk_putv(s, "<p><a href=\"", s->req_uri, "\">JK Status Manager Start Page</a></p>", NULL);
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, w, 2, 0, "result");
jk_print_xml_att_string(s, 4, "type", "OK");
jk_print_xml_att_string(s, 4, "message", "Action finished");
jk_print_xml_stop_elt(s, 2, 1);
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "Result:");
jk_printf(s, " type=%s", "OK");
jk_printf(s, " message=\"%s\"", "Action finished");
jk_puts(s, "\n");
}
else {
jk_print_prop_att_string(s, w, "result", "type", "OK");
jk_print_prop_att_string(s, w, "result", "message", "Action finished");
}
}
if (mime == JK_STATUS_MIME_HTML) {
if (w->css) {
jk_putv(s, "<hr/><div class=\"footer\">", JK_STATUS_COPYRIGHT,
"</div>\n", NULL);
}
else {
jk_putv(s, "<hr/><p align=\"center\"><small>", JK_STATUS_COPYRIGHT,
"</small></p>\n", NULL);
}
jk_puts(s, JK_STATUS_BEND);
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_close_elt(s, w, 0, "status");
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int JK_METHOD done(jk_endpoint_t **e, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (e && *e && (*e)->endpoint_private) {
status_endpoint_t *p = (*e)->endpoint_private;
free(p);
*e = NULL;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD validate(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && pThis->worker_private) {
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD init(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && pThis->worker_private) {
status_worker_t *p = pThis->worker_private;
char **good_rating;
unsigned int num_of_good;
char **bad_rating;
unsigned int num_of_bad;
unsigned int i;
p->we = we;
p->css = jk_get_worker_style_sheet(props, p->name, NULL);
p->prefix = jk_get_worker_prop_prefix(props, p->name, JK_STATUS_PREFIX_DEF);
p->ns = jk_get_worker_name_space(props, p->name, JK_STATUS_NS_DEF);
p->xmlns = jk_get_worker_xmlns(props, p->name, JK_STATUS_XMLNS_DEF);
p->doctype = jk_get_worker_xml_doctype(props, p->name, NULL);
p->read_only = jk_get_is_read_only(props, p->name);
p->user_case_insensitive = jk_get_worker_user_case_insensitive(props, p->name);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' is %s and has css '%s', prefix '%s', name space '%s', xml name space '%s', document type '%s'",
p->name,
p->read_only ? "read-only" : "read/write",
p->css ? p->css : "(null)",
p->prefix ? p->prefix : "(null)",
p->ns ? p->ns : "(null)",
p->xmlns ? p->xmlns : "(null)",
p->doctype ? p->doctype : "(null)");
if (jk_get_worker_user_list(props, p->name,
&(p->user_names),
&(p->num_of_users)) && p->num_of_users) {
for (i = 0; i < p->num_of_users; i++) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' restricting access to user '%s' case %s",
p->name, p->user_names[i],
p->user_case_insensitive ? "insensitive" : "sensitive");
}
}
if (jk_get_worker_good_rating(props, p->name,
&good_rating,
&num_of_good) && num_of_good) {
p->good_mask = 0;
for (i = 0; i < num_of_good; i++) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' rating as good: '%s'",
p->name, good_rating[i]);
p->good_mask |= status_get_rating(good_rating[i], l);
}
}
else {
p->good_mask = JK_STATUS_MASK_GOOD_DEF;
}
if (jk_get_worker_bad_rating(props, p->name,
&bad_rating,
&num_of_bad) && num_of_bad) {
p->bad_mask = 0;
for (i = 0; i < num_of_bad; i++) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' rating as bad: '%s'",
p->name, bad_rating[i]);
p->bad_mask |= status_get_rating(bad_rating[i], l);
}
}
else {
p->bad_mask = JK_STATUS_MASK_BAD_DEF;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' has good rating for '%08" JK_UINT32_T_HEX_FMT
"' and bad rating for '%08" JK_UINT32_T_HEX_FMT "'",
p->name,
p->good_mask,
p->bad_mask);
if (p->good_mask & p->bad_mask)
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' has non empty intersection '%08" JK_UINT32_T_HEX_FMT
"' between good rating for '%08" JK_UINT32_T_HEX_FMT
"' and bad rating for '%08" JK_UINT32_T_HEX_FMT "'",
p->name,
p->good_mask & p->bad_mask,
p->good_mask,
p->bad_mask);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int JK_METHOD get_endpoint(jk_worker_t *pThis,
jk_endpoint_t **pend, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && pThis->worker_private && pend) {
status_endpoint_t *p = (status_endpoint_t *) malloc(sizeof(status_endpoint_t));
p->worker = pThis->worker_private;
p->endpoint.endpoint_private = p;
p->endpoint.service = service;
p->endpoint.done = done;
p->req_params = NULL;
p->msg = NULL;
*pend = &p->endpoint;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
JK_LOG_NULL_PARAMS(l);
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD destroy(jk_worker_t **pThis, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && *pThis && (*pThis)->worker_private) {
status_worker_t *private_data = (*pThis)->worker_private;
jk_close_pool(&private_data->p);
free(private_data);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
int JK_METHOD status_worker_factory(jk_worker_t **w,
const char *name, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (NULL != name && NULL != w) {
status_worker_t *private_data =
(status_worker_t *) calloc(1, sizeof(status_worker_t));
jk_open_pool(&private_data->p,
private_data->buf,
sizeof(jk_pool_atom_t) * TINY_POOL_SIZE);
private_data->name = name;
private_data->worker.worker_private = private_data;
private_data->worker.validate = validate;
private_data->worker.init = init;
private_data->worker.get_endpoint = get_endpoint;
private_data->worker.destroy = destroy;
private_data->worker.retries = 1;
*w = &private_data->worker;
JK_TRACE_EXIT(l);
return JK_STATUS_WORKER_TYPE;
}
else {
JK_LOG_NULL_PARAMS(l);
}
JK_TRACE_EXIT(l);
return 0;
}