jk_status.c

jboss与apache集成的中间件,详情请参看文档说明.

                                  wr->s->is_disabled,
                                  wr->s->in_error_state,
                                  wr->s->in_recovering,
                                  wr->s->is_busy) );
                                      
            jk_printf(s, " lbfactor=\"%d\"", wr->s->lb_factor);
            jk_printf(s, " lbvalue=\"%d\"", wr->s->lb_value);
            jk_printf(s, " elected=\"%u\"", wr->s->elected);
            jk_printf(s, " readed=\"%u\"", wr->s->readed);
            jk_printf(s, " transferred=\"%u\"", wr->s->transferred);
            jk_printf(s, " errors=\"%u\"", wr->s->errors);
            jk_printf(s, " busy=\"%u\"", wr->s->busy);
            if (wr->s->redirect && *wr->s->redirect)
                jk_printf(s, " redirect=\"%s\"", wr->s->redirect);
            if (wr->s->domain && *wr->s->domain)
                jk_printf(s, " domain=\"%s\"", wr->s->domain);
            jk_puts(s, " />\n");
        }
        dump_maps(s, sw, s->uw_map, lb->s->name, l);
        jk_puts(s, "  </jk:balancer>\n");

    }
    if (has_lb)
        jk_puts(s, "  </jk:balancers>\n");

}

static void update_worker(jk_ws_service_t *s, status_worker_t *sw,
                          const char *dworker, jk_logger_t *l)
{
    int i;
    char buf[1024];
    const char *b;
    lb_worker_t *lb;
    jk_worker_t *w = wc_get_worker_for_name(dworker, l);

    if (w && w->type == JK_LB_WORKER_TYPE) {
        lb = (lb_worker_t *)w->worker_private;
        i = status_int("lr", s->query_string, lb->s->retries);
        if (i > 0)
            lb->s->retries = i;
        i = status_int("lt", s->query_string, lb->s->recover_wait_time);
        if (i > 59)
            lb->s->recover_wait_time = i;
        lb->s->sticky_session = status_bool("ls", s->query_string);
        lb->s->sticky_session_force = status_bool("lf", s->query_string);
    }
    else  {
        int n = status_int("lb", s->query_string, -1);
        worker_record_t *wr = NULL;
        ajp_worker_t *a;
        if (n >= 0 && n < (int)sw->we->num_of_workers)
            w = wc_get_worker_for_name(sw->we->worker_list[n], l);
        else {
            if (!(b = status_cmd("l", s->query_string, buf, sizeof(buf))))
                return;
            w = wc_get_worker_for_name(b, l);
        }
        if (!w || w->type != JK_LB_WORKER_TYPE)
            return;
        lb = (lb_worker_t *)w->worker_private;
        i = status_int("id", s->query_string, -1);
        if (i >= 0 && i < (int)lb->num_of_workers)
            wr = &(lb->lb_workers[i]);
        else {
            for (i = 0; i < (int)lb->num_of_workers; i++) {
                if (strcmp(dworker, lb->lb_workers[i].s->name) == 0) {
                    wr = &(lb->lb_workers[i]);
                    break;
                }
            }
        }
        if (!wr)
            return;
        a  = (ajp_worker_t *)wr->w->worker_private;

        if ((b = status_cmd("wr", s->query_string, buf, sizeof(buf))))
            strncpy(wr->s->redirect, b, JK_SHM_STR_SIZ);
        else
            memset(wr->s->redirect, 0, JK_SHM_STR_SIZ);
        if ((b = status_cmd("wc", s->query_string, buf, sizeof(buf))))
            strncpy(wr->s->domain, b, JK_SHM_STR_SIZ);
        else
            memset(wr->s->domain, 0, JK_SHM_STR_SIZ);
        wr->s->is_disabled = status_bool("wd", s->query_string);
        wr->s->is_stopped = status_bool("ws", s->query_string);
        i = status_int("wf", s->query_string, wr->s->lb_factor);
        if (i > 0)
            wr->s->lb_factor = i;
    }
}

static int status_cmd_type(const char *req)
{
    if (!req)
        return 0;
    else if (!strncmp(req, "cmd=list", 8))
        return 0;
    else if (!strncmp(req, "cmd=show", 8))
        return 1;
    else if (!strncmp(req, "cmd=update", 10))
        return 2;
    else
        return 0;
}

static int status_mime_type(const char *req)
{
    int ret = 0 ;
    if (req) {
        char mimetype[32];
        if (status_cmd("mime", req, mimetype, sizeof(mimetype)) != NULL) {
            if (!strcmp(mimetype, "xml"))
                ret = 1;
            else if (!strcmp(mimetype, "txt"))
                ret = 2;
        }
    }
    return ret ;
}

static int JK_METHOD service(jk_endpoint_t *e,
                             jk_ws_service_t *s,
                             jk_logger_t *l, int *is_recoverable_error)
{
    JK_TRACE_ENTER(l);

    if (e && e->endpoint_private && s) {
        char buf[128];
        char *worker = NULL;
        int cmd;
        int mime;
        status_endpoint_t *p = e->endpoint_private;

        *is_recoverable_error = JK_FALSE;

        /* Step 1: Process GET params and update configuration */
        cmd = status_cmd_type(s->query_string);
        mime = status_mime_type(s->query_string);
        if (cmd > 0 && (status_cmd("w", s->query_string, buf, sizeof(buf)) != NULL))
            worker = strdup(buf);
        if ((cmd == 2) && worker) {
            /* lock shared memory */
            jk_shm_lock();
            update_worker(s, p->s_worker, worker, l);
            /* update modification time to reflect the current config */
            jk_shm_set_workers_time(time(NULL));
            /* Since we updated the config no need to reload
             * on the next request
             */
            jk_shm_sync_access_time();
            /* unlock the shared memory */
            jk_shm_unlock();
        }
        if(mime == 0) {
            s->start_response(s, 200, "OK", headers_names, headers_vhtml, 3);
            s->write(s, JK_STATUS_HEAD, sizeof(JK_STATUS_HEAD) - 1);
            if (p->s_worker->css) {
                jk_putv(s, "\n<link rel=\"stylesheet\" type=\"text/css\" href=\"",
                        p->s_worker->css, "\" />\n", NULL);
            }
            s->write(s, JK_STATUS_HEND, sizeof(JK_STATUS_HEND) - 1);
            jk_puts(s, "<h1>JK Status Manager for ");
            jk_puts(s, s->server_name);
            jk_puts(s, "</h1>\n\n");
            jk_putv(s, "<dl><dt>Server Version: ",
                    s->server_software, "</dt>\n", NULL);
            jk_putv(s, "<dt>JK Version: ",
                    JK_VERSTRING, "\n</dt></dl>\n", NULL);
            /* Step 2: Display configuration */
            display_workers(s, p->s_worker, worker, l);


            s->write(s, JK_STATUS_BEND, sizeof(JK_STATUS_BEND) - 1);

        }
        else if (mime == 1) {
            s->start_response(s, 200, "OK", headers_names, headers_vxml, 3);
            s->write(s, JK_STATUS_XMLH, sizeof(JK_STATUS_XMLH) - 1);
            dump_config(s, p->s_worker, l);
            s->write(s, JK_STATUS_XMLE, sizeof(JK_STATUS_XMLE) - 1);
        }
        else {
            s->start_response(s, 200, "OK", headers_names, headers_vtxt, 3);
            s->write(s,  JK_STATUS_TEXTUPDATE_RESPONCE,
                     sizeof(JK_STATUS_TEXTUPDATE_RESPONCE) - 1);
        }
        if (worker)
            free(worker);
        JK_TRACE_EXIT(l);
        return JK_TRUE;
    }

    jk_log(l, JK_LOG_ERROR, "status: end of service with error");
    JK_TRACE_EXIT(l);
    return JK_FALSE;
}

static int JK_METHOD done(jk_endpoint_t **e, jk_logger_t *l)
{
    JK_TRACE_ENTER(l);

    if (e && *e && (*e)->endpoint_private) {
        *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 *log)
{
    JK_TRACE_ENTER(log);
    if (pThis && pThis->worker_private) {
        status_worker_t *p = pThis->worker_private;
        p->we = we;
        if (!jk_get_worker_str_prop(props, p->name, "css", &(p->css)))
            p->css = NULL;
    }
    JK_TRACE_EXIT(log);
    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_worker_t *p = (status_worker_t *)pThis->worker_private;
        *pend = p->ep.e;
        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;

        /* Status worker has single static endpoint. */
        private_data->ep.endpoint.done = done;
        private_data->ep.endpoint.service = service;
        private_data->ep.endpoint.endpoint_private = &private_data->ep;
        private_data->ep.e = &(private_data->ep.endpoint);
        private_data->ep.s_worker = private_data;
        *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;
}