Code Coverage: vinyl-cache/bin/vinyld/cache/cache_backend_probe.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2011 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 *
30
 * Poll backends for collection of health statistics
31
 *
32
 * We co-opt threads from the worker pool for probing the backends,
33
 * but we want to avoid a potentially messy cleanup operation when we
34
 * retire the backend, so the thread owns the health information, which
35
 * the backend references, rather than the other way around.
36
 *
37
 */
38
39
#include "config.h"
40
41
#include <poll.h>
42
#include <stdio.h>
43
#include <stdlib.h>
44
45
#include "cache_int.h"
46
47
#include "vbh.h"
48
#include "vsa.h"
49
#include "vtcp.h"
50
#include "vtim.h"
51
52
#include "cache_backend.h"
53
#include "cache_conn_pool.h"
54
55
#include "VSC_vbe.h"
56
57
struct vbp_state {
58
        const char                      *name;
59
};
60
61
#define VBP_STATE(n) static const struct vbp_state vbp_state_ ## n [1] = {{ .name = #n }}
62
VBP_STATE(scheduled);
63
VBP_STATE(running);
64
VBP_STATE(cold);
65
VBP_STATE(cooling);
66
VBP_STATE(deleted);
67
#undef VBP_STATE
68
69
/* Default averaging rate, we want something pretty responsive */
70 335
#define AVG_RATE                        4
71
72
struct vbp_target {
73
        unsigned                        magic;
74
#define VBP_TARGET_MAGIC                0x6b7cb656
75
76
        VRT_BACKEND_PROBE_FIELDS()
77
78
        struct backend                  *backend;
79
        struct conn_pool                *conn_pool;
80
81
        char                            *req;
82
        int                             req_len;
83
84
        char                            resp_buf[128];
85
        unsigned                        good;
86
87
        /* Collected statistics */
88
#define BITMAP(n, c, t, b)      uintmax_t       n;
89
#include "tbl/backend_poll.h"
90
91
        vtim_dur                        last;
92
        vtim_dur                        avg;
93
        double                          rate;
94
95
        vtim_real                       due;
96
        const struct vbp_state          *state;
97
        int                             heap_idx;
98
        struct pool_task                task[1];
99
};
100
101
static struct lock                      vbp_mtx;
102
static pthread_cond_t                   vbp_cond;
103
static struct vbh                       *vbp_heap;
104
105
static const unsigned char vbp_proxy_local[] = {
106
        0x0d, 0x0a, 0x0d, 0x0a, 0x00, 0x0d, 0x0a, 0x51,
107
        0x55, 0x49, 0x54, 0x0a, 0x20, 0x00, 0x00, 0x00,
108
};
109
110
/*--------------------------------------------------------------------*/
111
112
static void
113
vbp_delete(struct vbp_target *vt)
114 6
{
115 6
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
116
117 6
        assert(vt->heap_idx == VBH_NOIDX);
118
119 6
#define DN(x)   /**/
120 6
        VRT_BACKEND_PROBE_HANDLE();
121 6
#undef DN
122 6
        VCP_Rel(&vt->conn_pool);
123 6
        free(vt->req);
124 6
        FREE_OBJ(vt);
125 6
}
126
127
128
/*--------------------------------------------------------------------
129
 * Record pokings...
130
 */
131
132
static void
133
vbp_start_poke(struct vbp_target *vt)
134 397
{
135 397
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
136
137 397
#define BITMAP(n, c, t, b) \
138 3176
        vt->n <<= 1;
139 397
#include "tbl/backend_poll.h"
140
141 397
        vt->last = 0;
142 397
        vt->resp_buf[0] = '\0';
143 397
}
144
145
static void
146
vbp_has_poked(struct vbp_target *vt)
147 397
{
148 397
        unsigned i, j;
149 397
        uint64_t u;
150
151 397
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
152
153
        /* Calculate exponential average */
154 397
        if (vt->happy & 1) {
155 335
                if (vt->rate < AVG_RATE)
156 185
                        vt->rate += 1.0;
157 335
                vt->avg += (vt->last - vt->avg) / vt->rate;
158 335
        }
159
160 397
        u = vt->happy;
161 3218
        for (i = j = 0; i < vt->window; i++) {
162 2821
                if (u & 1)
163 1483
                        j++;
164 2821
                u >>= 1;
165 2821
        }
166 397
        vt->good = j;
167 397
}
168
169
void
170
VBP_Update_Backend(struct vbp_target *vt)
171 277
{
172 277
        unsigned i = 0, chg;
173 277
        char bits[10];
174
175 277
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
176
177 277
#define BITMAP(n, c, t, b)                      \
178 2216
        bits[i++] = (vt->n & 1) ? c : '-';
179 277
#include "tbl/backend_poll.h"
180 277
        bits[i] = '\0';
181 277
        assert(i < sizeof bits);
182
183 277
        Lck_Lock(&vbp_mtx);
184 277
        if (vt->backend == NULL) {
185 0
                Lck_Unlock(&vbp_mtx);
186 0
                return;
187 0
        }
188
189 277
        i = (vt->good < vt->threshold);
190 277
        chg = (i != vt->backend->sick);
191 277
        vt->backend->sick = i;
192 277
        if (i && chg && vt->backend->director != NULL)
193 50
                VDI_Event(vt->backend->director, VDI_EVENT_SICK);
194
195 277
        AN(vt->backend->vcl_name);
196 277
        VSL(SLT_Backend_health, NO_VXID,
197 277
            "%s %s %s %s %u %u %u %.6f %.6f \"%s\"",
198 277
            vt->backend->vcl_name, chg ? "Went" : "Still",
199 277
            i ? "sick" : "healthy", bits,
200 277
            vt->good, vt->threshold, vt->window,
201 277
            vt->last, vt->avg, vt->resp_buf);
202 277
        vt->backend->vsc->happy = vt->happy;
203 277
        if (chg)
204 72
                vt->backend->changed = VTIM_real();
205 277
        Lck_Unlock(&vbp_mtx);
206 277
}
207
208
static void
209
vbp_reset(struct vbp_target *vt)
210 83
{
211 83
        unsigned u;
212
213 83
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
214 83
        vt->avg = 0.0;
215 83
        vt->rate = 0.0;
216 83
#define BITMAP(n, c, t, b) \
217 664
        vt->n = 0;
218 83
#include "tbl/backend_poll.h"
219
220 286
        for (u = 0; u < vt->initial; u++) {
221 203
                vbp_start_poke(vt);
222 203
                vt->happy |= 1;
223 203
                vbp_has_poked(vt);
224 203
        }
225 83
}
226
227
/*--------------------------------------------------------------------
228
 * Poke one backend, once, but possibly at both IPv4 and IPv6 addresses.
229
 *
230
 * We do deliberately not use the stuff in cache_backend.c, because we
231
 * want to measure the backends response without local distractions.
232
 */
233
234
static int
235
vbp_write(struct vbp_target *vt, int *sock, const void *buf, size_t len)
236 187
{
237 187
        int i;
238
239 187
        i = write(*sock, buf, len);
240 187
        VTCP_Assert(i);
241 187
        if (i != len) {
242 0
                if (i < 0) {
243 0
                        vt->err_xmit |= 1;
244 0
                        bprintf(vt->resp_buf, "Write error %d (%s)",
245 0
                                errno, VAS_errtxt(errno));
246 0
                } else {
247 0
                        bprintf(vt->resp_buf,
248 0
                                "Short write (%d/%zu) error %d (%s)",
249 0
                                i, len, errno, VAS_errtxt(errno));
250 0
                }
251 0
                VTCP_close(sock);
252 0
                return (-1);
253 0
        }
254 187
        return (0);
255 187
}
256
257
static int
258
vbp_write_proxy_v1(struct vbp_target *vt, int *sock)
259 6
{
260 6
        char buf[105]; /* maximum size for a TCP6 PROXY line with null char */
261 6
        char addr[VTCP_ADDRBUFSIZE];
262 6
        char port[VTCP_PORTBUFSIZE];
263 6
        char vsabuf[vsa_suckaddr_len];
264 6
        const struct suckaddr *sua;
265 6
        int proto;
266 6
        struct vsb vsb;
267
268 6
        sua = VSA_getsockname(*sock, vsabuf, sizeof vsabuf);
269 6
        AN(sua);
270 6
        AN(VSB_init(&vsb, buf, sizeof buf));
271
272 6
        proto = VSA_Get_Proto(sua);
273 6
        if (proto == AF_INET || proto == AF_INET6) {
274 3
                VTCP_name(sua, addr, sizeof addr, port, sizeof port);
275 3
                VSB_printf(&vsb, "PROXY %s %s %s %s %s\r\n",
276 3
                    proto == AF_INET ? "TCP4" : "TCP6",
277 3
                    addr, addr, port, port);
278 3
        } else {
279 3
                VSB_cat(&vsb, "PROXY UNKNOWN\r\n");
280 3
        }
281 6
        AZ(VSB_finish(&vsb));
282
283 6
        VSB_fini(&vsb);
284 6
        return (vbp_write(vt, sock, buf, vstrlen(buf)));
285 6
}
286
287
static void
288
vbp_poke(struct vbp_target *vt)
289 194
{
290 194
        int s, i, proxy_header, err;
291 194
        vtim_real t_start, t_now, t_end;
292 194
        vtim_dur tmo;
293 194
        unsigned rlen, resp;
294 194
        char buf[8192], *p;
295 194
        struct pollfd pfda[1], *pfd = pfda;
296 194
        const struct suckaddr *sa;
297
298 194
        t_start = t_now = VTIM_real();
299 194
        t_end = t_start + vt->timeout;
300
301 194
        s = VCP_Open(vt->conn_pool, t_end - t_now, &sa, &err);
302 194
        if (s < 0) {
303 23
                bprintf(vt->resp_buf, "Open error %d (%s)", err, VAS_errtxt(err));
304 23
                Lck_Lock(&vbp_mtx);
305 23
                if (vt->backend)
306 23
                        VBE_Connect_Error(vt->backend->vsc, err);
307 23
                Lck_Unlock(&vbp_mtx);
308 23
                return;
309 23
        }
310
311 171
        i = VSA_Get_Proto(sa);
312 171
        if (VSA_Compare(sa, bogo_ip) == 0)
313 60
                vt->good_unix |= 1;
314 111
        else if (i == AF_INET)
315 111
                vt->good_ipv4 |= 1;
316 0
        else if (i == AF_INET6)
317 0
                vt->good_ipv6 |= 1;
318 0
        else
319 0
                WRONG("Wrong probe protocol family");
320
321 171
        t_now = VTIM_real();
322 171
        tmo = t_end - t_now;
323 171
        if (tmo <= 0) {
324 0
                bprintf(vt->resp_buf,
325 0
                        "Open timeout %.3fs exceeded by %.3fs",
326 0
                        vt->timeout, -tmo);
327 0
                VTCP_close(&s);
328 0
                return;
329 0
        }
330
331 171
        Lck_Lock(&vbp_mtx);
332 171
        if (vt->backend != NULL)
333 171
                proxy_header = vt->backend->proxy_header;
334 0
        else
335 0
                proxy_header = -1;
336 171
        Lck_Unlock(&vbp_mtx);
337
338 171
        if (proxy_header < 0) {
339 0
                bprintf(vt->resp_buf, "%s", "No backend");
340 0
                VTCP_close(&s);
341 0
                return;
342 0
        }
343
344
        /* Send the PROXY header */
345 171
        assert(proxy_header <= 2);
346 171
        if (proxy_header == 1) {
347 6
                if (vbp_write_proxy_v1(vt, &s) != 0)
348 0
                        return;
349 165
        } else if (proxy_header == 2 &&
350 165
            vbp_write(vt, &s, vbp_proxy_local, sizeof vbp_proxy_local) != 0)
351 0
                return;
352
353
        /* Send the request */
354 171
        if (vbp_write(vt, &s, vt->req, vt->req_len) != 0)
355 0
                return;
356
357 171
        vt->good_xmit |= 1;
358
359 171
        pfd->fd = s;
360 171
        rlen = 0;
361 343
        while (1) {
362 343
                pfd->events = POLLIN;
363 343
                pfd->revents = 0;
364 343
                t_now = VTIM_real();
365 343
                tmo = t_end - t_now;
366 343
                if (tmo <= 0) {
367 0
                        bprintf(vt->resp_buf,
368 0
                            "Poll timeout %.3fs exceeded by %.3fs",
369 0
                            vt->timeout, -tmo);
370 0
                        i = -1;
371 0
                        break;
372 0
                }
373 343
                i = poll(pfd, 1, VTIM_poll_tmo(tmo));
374 343
                if (i <= 0) {
375 20
                        if (!i) {
376 20
                                if (!vt->exp_close)
377 4
                                        break;
378 20
                                errno = ETIMEDOUT;
379 16
                        }
380 16
                        bprintf(vt->resp_buf, "Poll error %d (%s)",
381 16
                            errno, VAS_errtxt(errno));
382 16
                        i = -1;
383 16
                        break;
384 16
                }
385 323
                if (rlen < sizeof vt->resp_buf)
386 291
                        i = read(s, vt->resp_buf + rlen,
387 291
                            sizeof vt->resp_buf - rlen);
388 32
                else
389 32
                        i = read(s, buf, sizeof buf);
390 323
                VTCP_Assert(i);
391 323
                if (i <= 0) {
392 151
                        if (i < 0)
393 2
                                bprintf(vt->resp_buf, "Read error %d (%s)",
394 151
                                        errno, VAS_errtxt(errno));
395 151
                        break;
396 151
                }
397 172
                rlen += i;
398 172
        }
399
400 171
        VTCP_close(&s);
401
402 171
        if (i < 0) {
403
                /* errno reported above */
404 18
                vt->err_recv |= 1;
405 18
                return;
406 18
        }
407
408 153
        if (rlen == 0) {
409 6
                bprintf(vt->resp_buf, "%s", "Empty response");
410 6
                return;
411 6
        }
412
413
        /* So we have a good receive ... */
414 147
        t_now = VTIM_real();
415 147
        vt->last = t_now - t_start;
416 147
        vt->good_recv |= 1;
417
418
        /* Now find out if we like the response */
419 147
        vt->resp_buf[sizeof vt->resp_buf - 1] = '\0';
420 147
        p = strchr(vt->resp_buf, '\r');
421 147
        if (p != NULL)
422 146
                *p = '\0';
423 147
        p = strchr(vt->resp_buf, '\n');
424 147
        if (p != NULL)
425 0
                *p = '\0';
426
427 147
        i = sscanf(vt->resp_buf, "HTTP/%*f %u ", &resp);
428
429 147
        if (i == 1 && resp == vt->exp_status)
430 130
                vt->happy |= 1;
431 147
}
432
433
/*--------------------------------------------------------------------
434
 */
435
static void
436
vbp_heap_insert(struct vbp_target *vt)
437 295
{
438
        // Lck_AssertHeld(&vbp_mtx);
439 295
        VBH_insert(vbp_heap, vt);
440 295
        if (VBH_root(vbp_heap) == vt)
441 295
                PTOK(pthread_cond_signal(&vbp_cond));
442 295
}
443
444
/*--------------------------------------------------------------------
445
 */
446
447
/*
448
 * called when a task was successful or could not get scheduled
449
 * returns non-NULL if target is to be deleted (outside mtx)
450
 */
451
static struct vbp_target *
452
vbp_task_complete(struct vbp_target *vt)
453 259
{
454 259
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
455
456 259
        Lck_AssertHeld(&vbp_mtx);
457
458 259
        assert(vt->heap_idx == VBH_NOIDX);
459
460 259
        if (vt->state == vbp_state_running) {
461 257
                vt->state = vbp_state_scheduled;
462 257
                vt->due = VTIM_real() + vt->interval;
463 257
                vbp_heap_insert(vt);
464 257
                vt = NULL;
465 257
        } else if (vt->state == vbp_state_cooling) {
466 2
                vt->state = vbp_state_cold;
467 2
                vt = NULL;
468 2
        } else if (vt->state != vbp_state_deleted) {
469 0
                WRONG(vt->state->name);
470 0
        }
471 259
        return (vt);
472 259
}
473
474
static void v_matchproto_(task_func_t)
475
vbp_task(struct worker *wrk, void *priv)
476 194
{
477 194
        struct vbp_target *vt;
478
479 194
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
480 194
        CAST_OBJ_NOTNULL(vt, priv, VBP_TARGET_MAGIC);
481
482 194
        AN(vt->req);
483 194
        assert(vt->req_len > 0);
484
485 194
        vbp_start_poke(vt);
486 194
        vbp_poke(vt);
487 194
        vbp_has_poked(vt);
488 194
        VBP_Update_Backend(vt);
489
490 194
        Lck_Lock(&vbp_mtx);
491 194
        vt = vbp_task_complete(vt);
492 194
        Lck_Unlock(&vbp_mtx);
493 194
        if (vt == NULL)
494 194
                return;
495 0
        vbp_delete(vt);
496 0
}
497
498
/*--------------------------------------------------------------------
499
 */
500
501
static void * v_matchproto_(bgthread_t)
502
vbp_scheduler(struct worker *wrk, void *priv)
503 1026
{
504 1026
        vtim_real now, nxt;
505 1026
        struct vbp_target *vt;
506 1026
        int r;
507
508 1026
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
509 1026
        AZ(priv);
510 1026
        Lck_Lock(&vbp_mtx);
511 2779
        while (1) {
512 1753
                now = VTIM_real();
513 1753
                vt = VBH_root(vbp_heap);
514 1753
                if (vt == NULL) {
515 1237
                        nxt = 8.192 + now;
516 1237
                        (void)Lck_CondWaitUntil(&vbp_cond, &vbp_mtx, nxt);
517 1237
                } else if (vt->due > now) {
518 257
                        nxt = vt->due;
519 257
                        (void)Lck_CondWaitUntil(&vbp_cond, &vbp_mtx, nxt);
520 259
                } else {
521 259
                        assert(vt->state == vbp_state_scheduled);
522 259
                        VBH_delete(vbp_heap, vt->heap_idx);
523 259
                        vt->state = vbp_state_running;
524 259
                        vt->task->func = vbp_task;
525 259
                        vt->task->priv = vt;
526 259
                        Lck_Unlock(&vbp_mtx);
527
528 259
                        r = Pool_Task_Any(vt->task, TASK_QUEUE_REQ);
529
530 259
                        Lck_Lock(&vbp_mtx);
531 259
                        if (r == 0)
532 194
                                continue;
533 65
                        vt = vbp_task_complete(vt);
534 65
                        if (vt == NULL)
535 65
                                continue;
536 0
                        Lck_Unlock(&vbp_mtx);
537
538 0
                        vbp_delete(vt);
539
540 0
                        Lck_Lock(&vbp_mtx);
541 0
                }
542 1753
        }
543 1026
        NEEDLESS(Lck_Unlock(&vbp_mtx));
544 1026
        NEEDLESS(return (NULL));
545 1026
}
546
547
548
/*--------------------------------------------------------------------
549
 * Cli functions
550
 */
551
552
static void
553
vbp_bitmap(struct vsb *vsb, char c, uint64_t map, const char *lbl)
554 39
{
555 39
        int i;
556 39
        uint64_t u = (1ULL << 63);
557
558 39
        VSB_cat(vsb, "  ");
559 2535
        for (i = 0; i < 64; i++) {
560 2496
                if (map & u)
561 249
                        VSB_putc(vsb, c);
562 2247
                else
563 2247
                        VSB_putc(vsb, '-');
564 2496
                map <<= 1;
565 2496
        }
566 39
        VSB_printf(vsb, " %s\n", lbl);
567 39
}
568
569
/*lint -e{506} constant value boolean */
570
/*lint -e{774} constant value boolean */
571
void
572
VBP_Status(struct vsb *vsb, const struct backend *be, int details, int json)
573 82
{
574 82
        struct vbp_target *vt;
575
576 82
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
577 82
        vt = be->probe;
578 82
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
579
580 82
        if (!details) {
581 68
                if (json)
582 5
                        VSB_printf(vsb, "[%u, %u, \"%s\"]",
583 5
                            vt->good, vt->window,
584 5
                            vt->backend->sick ? "sick" : "healthy");
585 63
                else
586 63
                        VSB_printf(vsb, "%u/%u\t%s", vt->good, vt->window,
587 63
                            vt->backend->sick ? "sick" : "healthy");
588 68
                return;
589 68
        }
590
591 14
        if (json) {
592 3
                VSB_cat(vsb, "{\n");
593 3
                VSB_indent(vsb, 2);
594 3
#define BITMAP(nn, cc, tt, bb)                                  \
595 24
                VSB_printf(vsb, "\"bits_%c\": %ju,\n", cc, vt->nn);
596 3
#include "tbl/backend_poll.h"
597 3
                VSB_printf(vsb, "\"good\": %u,\n", vt->good);
598 3
                VSB_printf(vsb, "\"threshold\": %u,\n", vt->threshold);
599 3
                VSB_printf(vsb, "\"window\": %u", vt->window);
600 3
                VSB_indent(vsb, -2);
601 3
                VSB_cat(vsb, "\n");
602 3
                VSB_cat(vsb, "},\n");
603 3
                return;
604 3
        }
605
606 11
        VSB_printf(vsb,
607 11
            "\n Current states  good: %2u threshold: %2u window: %2u\n",
608 11
            vt->good, vt->threshold, vt->window);
609 11
        VSB_printf(vsb,
610 11
            "  Average response time of good probes: %.6f\n", vt->avg);
611 11
        VSB_cat(vsb,
612 11
            "  Oldest ======================"
613 11
            "============================ Newest\n");
614
615 11
#define BITMAP(n, c, t, b)                                      \
616 88
                if ((vt->n != 0) || (b))                        \
617 88
                        vbp_bitmap(vsb, (c), vt->n, (t));
618 11
#include "tbl/backend_poll.h"
619 11
}
620
621
/*--------------------------------------------------------------------
622
 * Build request from probe spec
623
 */
624
625
static void
626
vbp_build_req(struct vbp_target *vt, const struct vrt_backend_probe *vbp,
627
    const struct backend *be)
628 38
{
629 38
        struct vsb *vsb;
630
631 38
        vsb = VSB_new_auto();
632 38
        AN(vsb);
633 38
        VSB_clear(vsb);
634 38
        if (vbp->request != NULL) {
635 2
                VSB_cat(vsb, vbp->request);
636 36
        } else {
637 36
                AN(be->hosthdr);
638 36
                VSB_printf(vsb,
639 36
                    "GET %s HTTP/1.1\r\n"
640 36
                    "Host: %s\r\n"
641 36
                    "Connection: close\r\n"
642 36
                    "\r\n",
643 36
                    vbp->url != NULL ?  vbp->url : "/",
644 36
                    be->hosthdr);
645 36
        }
646 38
        AZ(VSB_finish(vsb));
647 38
        vt->req = strdup(VSB_data(vsb));
648 38
        AN(vt->req);
649 38
        vt->req_len = VSB_len(vsb);
650 38
        VSB_destroy(&vsb);
651 38
}
652
653
/*--------------------------------------------------------------------
654
 * Sanitize and set defaults
655
 * XXX: we could make these defaults parameters
656
 */
657
658
static void
659
vbp_set_defaults(struct vbp_target *vt, const struct vrt_backend_probe *vp)
660 38
{
661
662 266
#define DN(x)   do { vt->x = vp->x; } while (0)
663 38
        VRT_BACKEND_PROBE_HANDLE();
664 38
#undef DN
665
666 38
        if (vt->timeout == 0.0)
667 28
                vt->timeout = 2.0;
668 38
        if (vt->interval == 0.0)
669 9
                vt->interval = 5.0;
670 38
        if (vt->window == 0)
671 17
                vt->window = 8;
672 38
        if (vt->threshold == 0)
673 17
                vt->threshold = 3;
674 38
        if (vt->exp_status == 0)
675 38
                vt->exp_status = 200;
676
677 38
        if (vt->initial == ~0U)
678 23
                vt->initial = vt->threshold - 1;
679
680 38
        vt->initial = vmin(vt->initial, vt->threshold);
681 38
}
682
683
/*--------------------------------------------------------------------
684
 */
685
686
void
687
VBP_Control(const struct backend *be, int enable)
688 45
{
689 45
        struct vbp_target *vt;
690
691 45
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
692 45
        vt = be->probe;
693 45
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
694
695 45
        vbp_reset(vt);
696 45
        VBP_Update_Backend(vt);
697
698 45
        Lck_Lock(&vbp_mtx);
699 45
        if (enable) {
700 38
                if (vt->state == vbp_state_cooling) {
701 0
                        vt->state = vbp_state_running;
702 38
                } else if (vt->state == vbp_state_cold) {
703 38
                        assert(vt->heap_idx == VBH_NOIDX);
704 38
                        vt->due = VTIM_real();
705 38
                        vbp_heap_insert(vt);
706 38
                        vt->state = vbp_state_scheduled;
707 38
                } else
708 0
                        WRONG(vt->state->name);
709 38
        } else {
710 7
                if (vt->state == vbp_state_running) {
711 2
                        vt->state = vbp_state_cooling;
712 5
                } else if (vt->state == vbp_state_scheduled) {
713 5
                        assert(vt->heap_idx != VBH_NOIDX);
714 5
                        VBH_delete(vbp_heap, vt->heap_idx);
715 5
                        vt->state = vbp_state_cold;
716 5
                } else
717 0
                        WRONG(vt->state->name);
718 7
        }
719 45
        Lck_Unlock(&vbp_mtx);
720 45
}
721
722
/*--------------------------------------------------------------------
723
 * Insert/Remove/Use called from cache_backend.c
724
 */
725
726
void
727
VBP_Insert(struct backend *b, const struct vrt_backend_probe *vp,
728
    struct conn_pool *tp)
729 38
{
730 38
        struct vbp_target *vt;
731
732 38
        CHECK_OBJ_NOTNULL(b, BACKEND_MAGIC);
733 38
        CHECK_OBJ_NOTNULL(vp, VRT_BACKEND_PROBE_MAGIC);
734
735 38
        AZ(b->probe);
736
737 38
        ALLOC_OBJ(vt, VBP_TARGET_MAGIC);
738 38
        XXXAN(vt);
739
740 38
        vt->state = vbp_state_cold;
741 38
        vt->conn_pool = tp;
742 38
        VCP_AddRef(vt->conn_pool);
743 38
        vt->backend = b;
744 38
        b->probe = vt;
745
746 38
        vbp_set_defaults(vt, vp);
747 38
        vbp_build_req(vt, vp, b);
748
749 38
        vbp_reset(vt);
750 38
}
751
752
void
753
VBP_Remove(struct backend *be)
754 6
{
755 6
        struct vbp_target *vt;
756
757 6
        CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);
758 6
        vt = be->probe;
759 6
        CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
760
761 6
        Lck_Lock(&vbp_mtx);
762 6
        be->sick = 1;
763 6
        be->probe = NULL;
764 6
        vt->backend = NULL;
765 6
        if (vt->state == vbp_state_cooling) {
766 0
                vt->state = vbp_state_deleted;
767 0
                vt = NULL;
768 0
        } else
769 6
                assert(vt->state == vbp_state_cold);
770 6
        Lck_Unlock(&vbp_mtx);
771 6
        if (vt != NULL)
772 6
                vbp_delete(vt);
773 6
}
774
775
/*-------------------------------------------------------------------*/
776
777
static int v_matchproto_(vbh_cmp_t)
778
vbp_cmp(void *priv, const void *a, const void *b)
779 31
{
780 31
        const struct vbp_target *aa, *bb;
781
782 31
        AZ(priv);
783 31
        CAST_OBJ_NOTNULL(aa, a, VBP_TARGET_MAGIC);
784 31
        CAST_OBJ_NOTNULL(bb, b, VBP_TARGET_MAGIC);
785
786 31
        return (aa->due < bb->due);
787 31
}
788
789
static void v_matchproto_(vbh_update_t)
790
vbp_update(void *priv, void *p, unsigned u)
791 607
{
792 607
        struct vbp_target *vt;
793
794 607
        AZ(priv);
795 607
        CAST_OBJ_NOTNULL(vt, p, VBP_TARGET_MAGIC);
796 607
        vt->heap_idx = u;
797 607
}
798
799
/*-------------------------------------------------------------------*/
800
801
void
802
VBP_Init(void)
803 1026
{
804 1026
        pthread_t thr;
805
806 1026
        Lck_New(&vbp_mtx, lck_probe);
807 1026
        vbp_heap = VBH_new(NULL, vbp_cmp, vbp_update);
808 1026
        AN(vbp_heap);
809 1026
        PTOK(pthread_cond_init(&vbp_cond, NULL));
810 1026
        WRK_BgThread(&thr, "backend-probe-scheduler", vbp_scheduler, NULL);
811 1026
}