Attachment #16009 for bug #36138

View | Details | Raw Unified | Return to bug 36138
Collapse All | Expand All




    return result;
}

const char *get_method_value(int t)
{
    if (JK_LB_BYREQUESTS == t)
        return "by request";
    else if (JK_LB_BYTRAFFIC == t)
        return "by traffic";
    else if (JK_LB_BYBUSYNESS == t)
        return "by busyness";
    else
        return "Unknown";
}

/* Retrieve session id from the cookie or the parameter                      */
/* (parameter first)                                                         */

    jk_u64_t curmin = 0;

    worker_record_t *candidate = NULL;
    if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
        jk_shm_lock();
    /* First try to see if we have available candidate */
    for (i = 0; i < p->num_of_workers; i++) {
        /* Skip all workers that are not member of domain */

            candidate->s->lb_value -= total_factor;
        candidate->r = &(candidate->s->domain[0]);
    }
    if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
        jk_shm_unlock();

    return candidate;
}

    int total_factor = 0;
    worker_record_t *candidate = NULL;

    if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
        jk_shm_lock();
    /* First try to see if we have available candidate */
    for (i = 0; i < p->num_of_workers; i++) {
        /* If the worker is in error state run


    if (candidate)
        candidate->s->lb_value -= total_factor;
    if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
        jk_shm_unlock();

    return candidate;
}

    jk_u64_t curmin = 0;
    worker_record_t *candidate = NULL;

    if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
        jk_shm_lock();
    /* First try to see if we have available candidate */
    for (i = 0; i < p->num_of_workers; i++) {
        /* If the worker is in error state run

            }
        }
    }
    return candidate;
}

static worker_record_t *find_best_bybusyness(lb_worker_t *p,
                                             jk_logger_t *l)
{
    static unsigned int next_offset = 0;
    unsigned int i;
    unsigned int j;
    unsigned int offset;
    int bfn; /* Numerator of best busy factor */
    int bfd; /* Denominator of best busy factor */
    int curn; /* Numerator of current busy factor */
    int curd; /* Denominator of current busy factor */

    int left; /* left and right are used to compare rational numbers */
    int right;

    /* find the least busy worker */
    worker_record_t *candidate = NULL;

    offset = next_offset;
                                        
    /* First try to see if we have available candidate */
    for (j = 0; j < p->num_of_workers; j++) {
        i = (j + offset) % p->num_of_workers;

        /* If the worker is in error state run
         * retry on that worker. It will be marked as
         * operational if the retry timeout is elapsed.
         * The worker might still be unusable, but we try
         * anyway.
         */
        if (JK_WORKER_IN_ERROR(p->lb_workers[i].s)) {
            retry_worker(&p->lb_workers[i], p->s->recover_wait_time, l);
        }
        /* Take into calculation only the workers that are
         * not in error state, stopped or not disabled.
         */
        if (JK_WORKER_USABLE(p->lb_workers[i].s)) {
            curn = p->lb_workers[i].s->busy;
            curd = p->lb_workers[i].s->lb_factor;

            /* If the server is restarted under load there is a bug that causes
             * busy to be reset to zero before all the outstanding connections
             * finish, they then finally finish.  As a result, the busy value
             * becomes negative, messing up the busyness load balancing.  
             * When this bug is fixed, this section can be removed */
            if (curn < 0) {
               jk_log(l, JK_LOG_WARNING,
                   "busy value is %d for worker %s, resetting it to zero",
                   curn, p->lb_workers[i].s->name);
                p->lb_workers[i].s->busy = 0;
                curn = 0;
            }

            /* compare rational numbers: (a/b) < (c/d) iff a*d < c*b */
            left = curn * bfd;
            right = bfn * curd;

            if (!candidate || (left < right)) {
                candidate = &p->lb_workers[i];
                bfn = curn;
                bfd = curd;
                next_offset = i + 1;
            }
        }
    }
    return candidate;
}


    }
    if (candidate && !uses_domain &&
        p->lbmethod == JK_LB_BYREQUESTS) {
        if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
            jk_shm_lock();

        for (i = 0; i < p->num_of_workers; i++) {
            if (JK_WORKER_USABLE(p->lb_workers[i].s)) {

            }
        }
        candidate->s->lb_value -= total_factor;
        if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
            jk_shm_unlock();
    }
    return candidate;
}

        rc = find_best_byrequests(p, l);
    else if (p->lbmethod == JK_LB_BYTRAFFIC)
        rc = find_best_bytraffic(p, l);
    else if (p->lbmethod == JK_LB_BYBUSYNESS) 
        rc = find_best_bybusyness(p, l);

    /* By default use worker name as session route */
    if (rc)
        rc->r = &(rc->s->name[0]);

                                                 jk_logger_t *l)
{
    worker_record_t *rc = NULL;
    int had_session_id = JK_FALSE;
    char *sessionid = NULL;
    int r;


        JK_TRACE_EXIT(l);
        return NULL;
    }
    if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
        jk_shm_lock();
    if (sessionid) {
        char *session = sessionid;
        had_session_id = JK_TRUE;
        if (JK_IS_DEBUG_LEVEL(l)) {
            jk_log(l, JK_LOG_DEBUG,
                   "total sessionid is %s",

                /* We have a session route. Whow! */
                rc = find_bysession_route(p, session_route, l);
                if (rc) {
                    rc->s->sticky_session_count++;
                    break;
                        jk_log(l, JK_LOG_DEBUG,
                               "found worker %s for route %s and partial sessionid %s",
                               rc->s->name, session_route, sessionid);
                        JK_TRACE_EXIT(l);
                    return rc;
                }
            }
            /* Try next partial sessionid if present */

            rc = NULL;
        }
        if (!rc && p->s->sticky_session_force) {
           JK_LEAVE_CS(&(p->cs), r);
            jk_log(l, JK_LOG_INFO,
                   "all workers are in error state for session %s",
                    session);
            JK_TRACE_EXIT(l);
            return NULL;
        }
    }
    if (!rc && (!had_session_id || !p->s->sticky_session_force)) {
        rc = find_best_worker(p, l);
        if (rc) rc->s->elected++;
    }
    if (rc) {
        /* Increment the number of workers serving request */
        p->s->busy++;
        if (p->s->busy > p->s->max_busy)
            p->s->max_busy = p->s->busy;
        rc->s->busy++;
        if (rc->s->busy > rc->s->max_busy)
            rc->s->max_busy = rc->s->busy;
    }
    if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
        jk_shm_unlock();
    JK_LEAVE_CS(&(p->cs), r);
    if (rc && JK_IS_DEBUG_LEVEL(l)) {
        jk_log(l, JK_LOG_DEBUG,
               "found best worker (%s) using %s method", rc->s->name,
               get_method_value(p->lbmethod));
    }
    JK_TRACE_EXIT(l);
    return rc;

            worker_record_t *rec =
                get_most_suitable_worker(p->worker, s, attempt++, l);
            int rc;
            int r;
            /* Do not reuse previous worker, because
             * that worker already failed.
             */
            if (rec && rec != prec) {
                int is_service_error = JK_HTTP_OK;
                int service_stat = JK_FALSE;
                int no_endpoint = JK_TRUE;
                jk_endpoint_t *end = NULL;

                s->jvm_route = rec->r;

                    jk_log(l, JK_LOG_DEBUG,
                           "service worker=%s jvm_route=%s",
                           rec->s->name, s->jvm_route);
                rec->s->elected++;
                if (rc && end) {
                    no_endpoint = JK_FALSE;

                    /* Reset endpoint read and write sizes for
                     * this request.
                     */
                    end->rd = end->wr = 0;

                    p->worker->s->busy++;
                    if (p->worker->s->busy > p->worker->s->max_busy)
                        p->worker->s->max_busy = p->worker->s->busy;
                    rec->s->busy++;
                    if (rec->s->busy > rec->s->max_busy)
                        rec->s->max_busy = rec->s->busy;
                    service_stat = end->service(end, s, l, &is_service_error);
                    /* Update partial reads and writes if any */
                    rec->s->readed += end->rd;
                    rec->s->transferred += end->wr;
                    end->done(&end, l);

                    /* When returning the endpoint mark the worker as not busy.
                     * We have at least one endpoint free
                     */
                    rec->s->is_busy = JK_FALSE;
                    /* Decrement the busy worker count */
                    rec->s->busy--;
                    p->worker->s->busy--;
                    if (service_stat == JK_TRUE) {
                        rec->s->in_error_state = JK_FALSE;
                        rec->s->in_recovering = JK_FALSE;
                        rec->s->error_time = 0;
                        JK_TRACE_EXIT(l);
                        return JK_TRUE;
                    }
                }

                JK_ENTER_CS(&(p->worker->cs), r);
                if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
                        jk_shm_lock();
                /* Decrement the busy worker count */
                rec->s->busy--;
                p->worker->s->busy--;
                if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
                        jk_shm_unlock();
                JK_LEAVE_CS(&(p->worker->cs), r);

                if (no_endpoint) {
                    /* If we can not get the endpoint
                     * mark the worker as busy rather then
                     * as in error

                    prec = rec;
                    continue;
                }

                if (service_stat == JK_TRUE) {
                    rec->s->in_error_state = JK_FALSE;
                    rec->s->in_recovering = JK_FALSE;
                    rec->s->error_time = 0;
                    JK_TRACE_EXIT(l);
                    return JK_TRUE;
                }
                else if (service_stat == JK_FALSE) {
                    /*
                    * Service failed !!!
                    *

                           "recoverable error... will try to recover on other host");
            }
            else {
                if (rec) {
                    JK_ENTER_CS(&(p->worker->cs), r);
                    if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
                        jk_shm_lock();
                    /* Decrement the busy worker count */
                    rec->s->busy--;
                    p->worker->s->busy--;
                    if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
                        jk_shm_unlock();
                    JK_LEAVE_CS(&(p->worker->cs), r);
                }
                /* NULL record, no more workers left ... */
                jk_log(l, JK_LOG_ERROR,
                       "All tomcat instances failed, no more workers left");

Lines 39-46 Link Here

(-)jk/native/common/jk_lb_worker.h (+2 lines)
39		39
40	#define JK_LB_BYREQUESTS (0)	40	#define JK_LB_BYREQUESTS (0)
41	#define JK_LB_BYTRAFFIC (1)	41	#define JK_LB_BYTRAFFIC (1)
		42	#define JK_LB_BYBUSYNESS (2)
42	#define JK_LB_METHOD_REQUESTS ("Request")	43	#define JK_LB_METHOD_REQUESTS ("Request")
43	#define JK_LB_METHOD_TRAFFIC ("Traffic")	44	#define JK_LB_METHOD_TRAFFIC ("Traffic")
		45	#define JK_LB_METHOD_BUSYNESS ("Busyness")
44	#define JK_LB_LOCK_DEFAULT (0)	46	#define JK_LB_LOCK_DEFAULT (0)
45	#define JK_LB_LOCK_PESSIMISTIC (1)	47	#define JK_LB_LOCK_PESSIMISTIC (1)
46	#define JK_LB_LM_DEFAULT ("Optimistic")	48	#define JK_LB_LM_DEFAULT ("Optimistic")

Lines 86-91 Link Here

(-)jk/native/common/jk_shm.h (+2 lines)
86	volatile jk_u64_t transferred;	86	volatile jk_u64_t transferred;
87	/* Number of times the worker was elected */	87	/* Number of times the worker was elected */
88	volatile size_t elected;	88	volatile size_t elected;
		89	/* Number of times the worker was reused from sticky session */
		90	volatile size_t sticky_session_count;
89	/* Number of non 200 responses */	91	/* Number of non 200 responses */
90	volatile size_t errors;	92	volatile size_t errors;
91	};	93	};

Lines 83-88 Link Here

(-)jk/native/common/jk_status.c (-3 / +20 lines)
83	NULL	83	NULL
84	};	84	};
85		85
		86	static const char *lb_method_type[] = {
		87	JK_LB_METHOD_REQUESTS,
		88	JK_LB_METHOD_TRAFFIC,
		89	JK_LB_METHOD_BUSYNESS,
		90	"unknown",
		91	NULL
		92	};
		93
86	static const char *headers_names[] = {	94	static const char *headers_names[] = {
87	"Content-Type",	95	"Content-Type",
88	"Cache-Control",	96	"Cache-Control",
Lines 200-205 Link Here
200	} while (1);	208	} while (1);
201	}	209	}
202		210
		211	static const char *status_lb_method_type(int t)
		212	{
		213	if (t < 0 \|\| t > 2)
		214	t = 3;
		215	return lb_method_type[t];
		216	}
		217
203	static const char *status_worker_type(int t)	218	static const char *status_worker_type(int t)
204	{	219	{
205	if (t < 0 \|\| t > 6)	220	if (t < 0 \|\| t > 6)
Lines 443-454 Link Here
443	jk_putv(s, "<td>", status_val_bool(lb->s->sticky_session_force),	458	jk_putv(s, "<td>", status_val_bool(lb->s->sticky_session_force),
444	"</td>", NULL);	459	"</td>", NULL);
445	jk_printf(s, "<td>%d</td>", lb->s->retries);	460	jk_printf(s, "<td>%d</td>", lb->s->retries);
446	jk_printf(s, "<td>%s</td>", lb->lbmethod == JK_LB_BYREQUESTS ? JK_LB_METHOD_REQUESTS : JK_LB_METHOD_TRAFFIC);	461	jk_putv(s, "<td>", status_lb_method_type(lb->lbmethod), "</td>", NULL);
447	jk_printf(s, "<td>%s</td>", lb->lblock == JK_LB_LOCK_DEFAULT ? JK_LB_LM_DEFAULT : JK_LB_LM_PESSIMISTIC);	462	jk_printf(s, "<td>%s</td>", lb->lblock == JK_LB_LOCK_DEFAULT ? JK_LB_LM_DEFAULT : JK_LB_LM_PESSIMISTIC);
448	jk_puts(s, "</tr>\n</table>\n<br/>\n");	463	jk_puts(s, "</tr>\n</table>\n<br/>\n");
449	jk_puts(s, "<table><tr>"	464	jk_puts(s, "<table><tr>"
450	"<th>Name</th><th>Type</th><th>Host</th><th>Addr</th>"	465	"<th>Name</th><th>Type</th><th>Host</th><th>Addr</th>"
451	"<th>Stat</th><th>F</th><th>V</th><th>Acc</th><th>Err</th>"	466	"<th>Stat</th><th>F</th><th>V</th><th>Acc</th><th>Ssc</th><th>Err</th>"
452	"<th>Wr</th><th>Rd</th><th>Busy</th><th>Max</th><th>RR</th><th>Cd</th></tr>\n");	467	"<th>Wr</th><th>Rd</th><th>Busy</th><th>Max</th><th>RR</th><th>Cd</th></tr>\n");
453	for (j = 0; j < lb->num_of_workers; j++) {	468	for (j = 0; j < lb->num_of_workers; j++) {
454	worker_record_t *wr = &(lb->lb_workers[j]);	469	worker_record_t *wr = &(lb->lb_workers[j]);
Lines 474-479 Link Here
474	jk_printf(s, "<td>%d</td>", wr->s->lb_factor);	489	jk_printf(s, "<td>%d</td>", wr->s->lb_factor);
475	jk_printf(s, "<td>%d</td>", wr->s->lb_value);	490	jk_printf(s, "<td>%d</td>", wr->s->lb_value);
476	jk_printf(s, "<td>%u</td>", wr->s->elected);	491	jk_printf(s, "<td>%u</td>", wr->s->elected);
		492	jk_printf(s, "<td>%u</td>", wr->s->sticky_session_count);
477	jk_printf(s, "<td>%u</td>", wr->s->errors);	493	jk_printf(s, "<td>%u</td>", wr->s->errors);
478	jk_putv(s, "<td>", status_strfsize(wr->s->transferred, buf),	494	jk_putv(s, "<td>", status_strfsize(wr->s->transferred, buf),
479	"</td>", NULL);	495	"</td>", NULL);
Lines 580-586 Link Here
580	"<tr><th>Stat</th><td>Worker status</td></tr>\n"	596	"<tr><th>Stat</th><td>Worker status</td></tr>\n"
581	"<tr><th>F</th><td>Load Balancer Factor</td></tr>\n"	597	"<tr><th>F</th><td>Load Balancer Factor</td></tr>\n"
582	"<tr><th>V</th><td>Load Balancer Value</td></tr>\n"	598	"<tr><th>V</th><td>Load Balancer Value</td></tr>\n"
583	"<tr><th>Acc</th><td>Number of requests</td></tr>\n"	599	"<tr><th>Acc</th><td>Number of new requests</td></tr>\n"
		600	"<tr><th>Ssc</th><td>Number of sticky session requests</td></tr>\n"
584	"<tr><th>Err</th><td>Number of failed requests</td></tr>\n"	601	"<tr><th>Err</th><td>Number of failed requests</td></tr>\n"
585	"<tr><th>Wr</th><td>Number of bytes transferred</td></tr>\n"	602	"<tr><th>Wr</th><td>Number of bytes transferred</td></tr>\n"
586	"<tr><th>Rd</th><td>Number of bytes read</td></tr>\n"	603	"<tr><th>Rd</th><td>Number of bytes read</td></tr>\n"

Lines 770-775 Link Here

(-)jk/native/common/jk_util.c (+2 lines)
770	return JK_LB_BYTRAFFIC;	770	return JK_LB_BYTRAFFIC;
771	else if (v == 'r' \|\| v == 'R' \|\| *v == '0')	771	else if (v == 'r' \|\| v == 'R' \|\| *v == '0')
772	return JK_LB_BYREQUESTS;	772	return JK_LB_BYREQUESTS;
		773	else if (v == 'b' \|\| v == 'B')
		774	return JK_LB_BYBUSYNESS;
773	else	775	else
774	return JK_LB_BYREQUESTS;	776	return JK_LB_BYREQUESTS;
775	}	777	}

Return to bug 36138

Lines 142-147 Link Here

(-)jk/native/common/jk_lb_worker.c (-48 / +142 lines)
142	return result;	142	return result;
143	}	143	}
144		144
		145	const char *get_method_value(int t)
		146	{
		147	if (JK_LB_BYREQUESTS == t)
		148	return "by request";
		149	else if (JK_LB_BYTRAFFIC == t)
		150	return "by traffic";
		151	else if (JK_LB_BYBUSYNESS == t)
		152	return "by busyness";
		153	else
		154	return "Unknown";
		155	}
145		156
146	/* Retrieve session id from the cookie or the parameter */	157	/* Retrieve session id from the cookie or the parameter */
147	/* (parameter first) */	158	/* (parameter first) */
Lines 229-236 Link Here
229	jk_u64_t curmin = 0;	240	jk_u64_t curmin = 0;
230		241
231	worker_record_t *candidate = NULL;	242	worker_record_t *candidate = NULL;
232	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
233	jk_shm_lock();
234	/* First try to see if we have available candidate */	243	/* First try to see if we have available candidate */
235	for (i = 0; i < p->num_of_workers; i++) {	244	for (i = 0; i < p->num_of_workers; i++) {
236	/* Skip all workers that are not member of domain */	245	/* Skip all workers that are not member of domain */
Lines 263-270 Link Here
263	candidate->s->lb_value -= total_factor;	272	candidate->s->lb_value -= total_factor;
264	candidate->r = &(candidate->s->domain[0]);	273	candidate->r = &(candidate->s->domain[0]);
265	}	274	}
266	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
267	jk_shm_unlock();
268		275
269	return candidate;	276	return candidate;
270	}	277	}
Lines 277-284 Link Here
277	int total_factor = 0;	284	int total_factor = 0;
278	worker_record_t *candidate = NULL;	285	worker_record_t *candidate = NULL;
279		286
280	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
281	jk_shm_lock();
282	/* First try to see if we have available candidate */	287	/* First try to see if we have available candidate */
283	for (i = 0; i < p->num_of_workers; i++) {	288	for (i = 0; i < p->num_of_workers; i++) {
284	/* If the worker is in error state run	289	/* If the worker is in error state run
Lines 303-310 Link Here
303		308
304	if (candidate)	309	if (candidate)
305	candidate->s->lb_value -= total_factor;	310	candidate->s->lb_value -= total_factor;
306	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
307	jk_shm_unlock();
308		311
309	return candidate;	312	return candidate;
310	}	313	}
Lines 317-324 Link Here
317	jk_u64_t curmin = 0;	320	jk_u64_t curmin = 0;
318	worker_record_t *candidate = NULL;	321	worker_record_t *candidate = NULL;
319		322
320	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
321	jk_shm_lock();
322	/* First try to see if we have available candidate */	323	/* First try to see if we have available candidate */
323	for (i = 0; i < p->num_of_workers; i++) {	324	for (i = 0; i < p->num_of_workers; i++) {
324	/* If the worker is in error state run	325	/* If the worker is in error state run
Lines 342-349 Link Here
342	}	343	}
343	}	344	}
344	}	345	}
345	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)	346	return candidate;
346	jk_shm_unlock();	347	}
		348
		349	static worker_record_t find_best_bybusyness(lb_worker_t p,
		350	jk_logger_t *l)
		351	{
		352	static unsigned int next_offset = 0;
		353	unsigned int i;
		354	unsigned int j;
		355	unsigned int offset;
		356	int bfn; /* Numerator of best busy factor */
		357	int bfd; /* Denominator of best busy factor */
		358	int curn; /* Numerator of current busy factor */
		359	int curd; /* Denominator of current busy factor */
		360
		361	int left; /* left and right are used to compare rational numbers */
		362	int right;
		363
		364	/* find the least busy worker */
		365	worker_record_t *candidate = NULL;
		366
		367	offset = next_offset;
		368
		369	/* First try to see if we have available candidate */
		370	for (j = 0; j < p->num_of_workers; j++) {
		371	i = (j + offset) % p->num_of_workers;
		372
		373	/* If the worker is in error state run
		374	* retry on that worker. It will be marked as
		375	* operational if the retry timeout is elapsed.
		376	* The worker might still be unusable, but we try
		377	* anyway.
		378	*/
		379	if (JK_WORKER_IN_ERROR(p->lb_workers[i].s)) {
		380	retry_worker(&p->lb_workers[i], p->s->recover_wait_time, l);
		381	}
		382	/* Take into calculation only the workers that are
		383	* not in error state, stopped or not disabled.
		384	*/
		385	if (JK_WORKER_USABLE(p->lb_workers[i].s)) {
		386	curn = p->lb_workers[i].s->busy;
		387	curd = p->lb_workers[i].s->lb_factor;
		388
		389	/* If the server is restarted under load there is a bug that causes
		390	* busy to be reset to zero before all the outstanding connections
		391	* finish, they then finally finish. As a result, the busy value
		392	* becomes negative, messing up the busyness load balancing.
		393	* When this bug is fixed, this section can be removed */
		394	if (curn < 0) {
		395	jk_log(l, JK_LOG_WARNING,
		396	"busy value is %d for worker %s, resetting it to zero",
		397	curn, p->lb_workers[i].s->name);
		398	p->lb_workers[i].s->busy = 0;
		399	curn = 0;
		400	}
		401
		402	/* compare rational numbers: (a/b) < (c/d) iff ad < cb */
		403	left = curn * bfd;
		404	right = bfn * curd;
		405
		406	if (!candidate \|\| (left < right)) {
		407	candidate = &p->lb_workers[i];
		408	bfn = curn;
		409	bfd = curd;
		410	next_offset = i + 1;
		411	}
412	}
413	}
347	return candidate;	414	return candidate;
348	}	415	}
349		416
Lines 386-393 Link Here
386	}	453	}
387	if (candidate && !uses_domain &&	454	if (candidate && !uses_domain &&
388	p->lbmethod == JK_LB_BYREQUESTS) {	455	p->lbmethod == JK_LB_BYREQUESTS) {
389	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
390	jk_shm_lock();
391		456
392	for (i = 0; i < p->num_of_workers; i++) {	457	for (i = 0; i < p->num_of_workers; i++) {
393	if (JK_WORKER_USABLE(p->lb_workers[i].s)) {	458	if (JK_WORKER_USABLE(p->lb_workers[i].s)) {
Lines 400-407 Link Here
400	}	465	}
401	}	466	}
402	candidate->s->lb_value -= total_factor;	467	candidate->s->lb_value -= total_factor;
403	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
404	jk_shm_unlock();
405	}	468	}
406	return candidate;	469	return candidate;
407	}	470	}
Lines 433-438 Link Here
433	rc = find_best_byrequests(p, l);	496	rc = find_best_byrequests(p, l);
434	else if (p->lbmethod == JK_LB_BYTRAFFIC)	497	else if (p->lbmethod == JK_LB_BYTRAFFIC)
435	rc = find_best_bytraffic(p, l);	498	rc = find_best_bytraffic(p, l);
		499	else if (p->lbmethod == JK_LB_BYBUSYNESS)
		500	rc = find_best_bybusyness(p, l);
		501
436	/* By default use worker name as session route */	502	/* By default use worker name as session route */
437	if (rc)	503	if (rc)
438	rc->r = &(rc->s->name[0]);	504	rc->r = &(rc->s->name[0]);
Lines 447-452 Link Here
447	jk_logger_t *l)	513	jk_logger_t *l)
448	{	514	{
449	worker_record_t *rc = NULL;	515	worker_record_t *rc = NULL;
		516	int had_session_id = JK_FALSE;
450	char *sessionid = NULL;	517	char *sessionid = NULL;
451	int r;	518	int r;
452		519
Lines 483-490 Link Here
483	JK_TRACE_EXIT(l);	550	JK_TRACE_EXIT(l);
484	return NULL;	551	return NULL;
485	}	552	}
		553	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
		554	jk_shm_lock();
486	if (sessionid) {	555	if (sessionid) {
487	char *session = sessionid;	556	char *session = sessionid;
		557	had_session_id = JK_TRUE;
488	if (JK_IS_DEBUG_LEVEL(l)) {	558	if (JK_IS_DEBUG_LEVEL(l)) {
489	jk_log(l, JK_LOG_DEBUG,	559	jk_log(l, JK_LOG_DEBUG,
490	"total sessionid is %s",	560	"total sessionid is %s",
Lines 511-523 Link Here
511	/* We have a session route. Whow! */	581	/* We have a session route. Whow! */
512	rc = find_bysession_route(p, session_route, l);	582	rc = find_bysession_route(p, session_route, l);
513	if (rc) {	583	if (rc) {
514	JK_LEAVE_CS(&(p->cs), r);	584	rc->s->sticky_session_count++;
515	if (JK_IS_DEBUG_LEVEL(l))	585	break;
516	jk_log(l, JK_LOG_DEBUG,
517	"found worker %s for route %s and partial sessionid %s",
518	rc->s->name, session_route, sessionid);
519	JK_TRACE_EXIT(l);
520	return rc;
521	}	586	}
522	}	587	}
523	/* Try next partial sessionid if present */	588	/* Try next partial sessionid if present */
Lines 525-544 Link Here
525	rc = NULL;	590	rc = NULL;
526	}	591	}
527	if (!rc && p->s->sticky_session_force) {	592	if (!rc && p->s->sticky_session_force) {
528	JK_LEAVE_CS(&(p->cs), r);
529	jk_log(l, JK_LOG_INFO,	593	jk_log(l, JK_LOG_INFO,
530	"all workers are in error state for session %s",	594	"all workers are in error state for session %s",
531	session);	595	session);
532	JK_TRACE_EXIT(l);
533	return NULL;
534	}	596	}
535	}	597	}
536	rc = find_best_worker(p, l);	598	if (!rc && (!had_session_id \|\| !p->s->sticky_session_force)) {
		599	rc = find_best_worker(p, l);
		600	if (rc) rc->s->elected++;
		601	}
		602	if (rc) {
		603	/* Increment the number of workers serving request */
		604	p->s->busy++;
		605	if (p->s->busy > p->s->max_busy)
		606	p->s->max_busy = p->s->busy;
		607	rc->s->busy++;
		608	if (rc->s->busy > rc->s->max_busy)
		609	rc->s->max_busy = rc->s->busy;
		610	}
		611	if (p->lblock == JK_LB_LOCK_PESSIMISTIC)
		612	jk_shm_unlock();
537	JK_LEAVE_CS(&(p->cs), r);	613	JK_LEAVE_CS(&(p->cs), r);
538	if (rc && JK_IS_DEBUG_LEVEL(l)) {	614	if (rc && JK_IS_DEBUG_LEVEL(l)) {
539	jk_log(l, JK_LOG_DEBUG,	615	jk_log(l, JK_LOG_DEBUG,
540	"found best worker (%s) using %s method", rc->s->name,	616	"found best worker (%s) using %s method", rc->s->name,
541	p->lbmethod == JK_LB_BYREQUESTS ? "by request" : "by traffic");	617	get_method_value(p->lbmethod));
542	}	618	}
543	JK_TRACE_EXIT(l);	619	JK_TRACE_EXIT(l);
544	return rc;	620	return rc;
Lines 572-583 Link Here
572	worker_record_t *rec =	648	worker_record_t *rec =
573	get_most_suitable_worker(p->worker, s, attempt++, l);	649	get_most_suitable_worker(p->worker, s, attempt++, l);
574	int rc;	650	int rc;
		651	int r;
575	/* Do not reuse previous worker, because	652	/* Do not reuse previous worker, because
576	* that worker already failed.	653	* that worker already failed.
577	*/	654	*/
578	if (rec && rec != prec) {	655	if (rec && rec != prec) {
579	int is_service_error = JK_HTTP_OK;	656	int is_service_error = JK_HTTP_OK;
580	int service_stat = JK_FALSE;	657	int service_stat = JK_FALSE;
		658	int no_endpoint = JK_TRUE;
581	jk_endpoint_t *end = NULL;	659	jk_endpoint_t *end = NULL;
582		660
583	s->jvm_route = rec->r;	661	s->jvm_route = rec->r;
Lines 587-626 Link Here
587	jk_log(l, JK_LOG_DEBUG,	665	jk_log(l, JK_LOG_DEBUG,
588	"service worker=%s jvm_route=%s",	666	"service worker=%s jvm_route=%s",
589	rec->s->name, s->jvm_route);	667	rec->s->name, s->jvm_route);
590	rec->s->elected++;
591	if (rc && end) {	668	if (rc && end) {
		669	no_endpoint = JK_FALSE;
		670
592	/* Reset endpoint read and write sizes for	671	/* Reset endpoint read and write sizes for
593	* this request.	672	* this request.
594	*/	673	*/
595	end->rd = end->wr = 0;	674	end->rd = end->wr = 0;
596	/* Increment the number of workers serving request */	675
597	p->worker->s->busy++;
598	if (p->worker->s->busy > p->worker->s->max_busy)
599	p->worker->s->max_busy = p->worker->s->busy;
600	rec->s->busy++;
601	if (rec->s->busy > rec->s->max_busy)
602	rec->s->max_busy = rec->s->busy;
603	service_stat = end->service(end, s, l, &is_service_error);	676	service_stat = end->service(end, s, l, &is_service_error);
604	/* Update partial reads and writes if any */	677	/* Update partial reads and writes if any */
605	rec->s->readed += end->rd;	678	rec->s->readed += end->rd;
606	rec->s->transferred += end->wr;	679	rec->s->transferred += end->wr;
607	end->done(&end, l);	680	end->done(&end, l);
		681
608	/* When returning the endpoint mark the worker as not busy.	682	/* When returning the endpoint mark the worker as not busy.
609	* We have at least one endpoint free	683	* We have at least one endpoint free
610	*/	684	*/
611	rec->s->is_busy = JK_FALSE;	685	rec->s->is_busy = JK_FALSE;
612	/* Decrement the busy worker count */
613	rec->s->busy--;
614	p->worker->s->busy--;
615	if (service_stat == JK_TRUE) {
616	rec->s->in_error_state = JK_FALSE;
617	rec->s->in_recovering = JK_FALSE;
618	rec->s->error_time = 0;
619	JK_TRACE_EXIT(l);
620	return JK_TRUE;
621	}
622	}	686	}
623	else {	687
		688	JK_ENTER_CS(&(p->worker->cs), r);
		689	if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
		690	jk_shm_lock();
		691	/* Decrement the busy worker count */
		692	rec->s->busy--;
		693	p->worker->s->busy--;
		694	if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
		695	jk_shm_unlock();
		696	JK_LEAVE_CS(&(p->worker->cs), r);
		697
		698	if (no_endpoint) {
624	/* If we can not get the endpoint	699	/* If we can not get the endpoint
625	* mark the worker as busy rather then	700	* mark the worker as busy rather then
626	* as in error	701	* as in error
Lines 634-640 Link Here
634	prec = rec;	709	prec = rec;
635	continue;	710	continue;
636	}	711	}
637	if (service_stat == JK_FALSE) {	712
		713	if (service_stat == JK_TRUE) {
		714	rec->s->in_error_state = JK_FALSE;
		715	rec->s->in_recovering = JK_FALSE;
		716	rec->s->error_time = 0;
		717	JK_TRACE_EXIT(l);
		718	return JK_TRUE;
		719	}
		720	else if (service_stat == JK_FALSE) {
638	/*	721	/*
639	* Service failed !!!	722	* Service failed !!!
640	*	723	*
Lines 699-704 Link Here
699	"recoverable error... will try to recover on other host");	782	"recoverable error... will try to recover on other host");
700	}	783	}
701	else {	784	else {
		785	if (rec) {
		786	JK_ENTER_CS(&(p->worker->cs), r);
		787	if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
		788	jk_shm_lock();
		789	/* Decrement the busy worker count */
		790	rec->s->busy--;
		791	p->worker->s->busy--;
		792	if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
		793	jk_shm_unlock();
		794	JK_LEAVE_CS(&(p->worker->cs), r);
		795	}
702	/* NULL record, no more workers left ... */	796	/* NULL record, no more workers left ... */
703	jk_log(l, JK_LOG_ERROR,	797	jk_log(l, JK_LOG_ERROR,
704	"All tomcat instances failed, no more workers left");	798	"All tomcat instances failed, no more workers left");