Code Coverage: vinyl-cache/bin/vinyld/cache/cache_director.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 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
 * Abstract director API
31
 *
32
 * The abstract director API does not know how we talk to the backend or
33
 * if there even is one in the usual meaning of the word.
34
 *
35
 */
36
37
#include "config.h"
38
39
#include "cache_int.h"
40
#include "cache_director.h"
41
42
#include "vcli_serve.h"
43
#include "vte.h"
44
#include "vtim.h"
45
46
/* -------------------------------------------------------------------*/
47
48
struct vdi_ahealth {
49
        const char              *name;
50
        int                     health;
51
};
52
53
#define VBE_AHEALTH(l,u,h)                                              \
54
        static const struct vdi_ahealth vdi_ah_##l[1] = {{#l,h}};       \
55
        const struct vdi_ahealth * const VDI_AH_##u = vdi_ah_##l;
56
VBE_AHEALTH_LIST
57
#undef VBE_AHEALTH
58
59
static const struct vdi_ahealth *
60
vdi_str2ahealth(const char *t)
61 42
{
62 88
#define VBE_AHEALTH(l,u,h) if (!strcasecmp(t, #l)) return (VDI_AH_##u);
63 42
VBE_AHEALTH_LIST
64 4
#undef VBE_AHEALTH
65 4
        return (NULL);
66 46
}
67
68
static const char *
69
VDI_Ahealth(const struct director *d)
70 1348
{
71
72 1348
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
73 1348
        AN(d->vdir->admin_health);
74 1348
        if (d->vdir->admin_health != VDI_AH_AUTO)
75 35
                return (d->vdir->admin_health->name);
76 1313
        if (d->vdir->methods->healthy != NULL)
77 137
                return ("probe");
78 1176
        return ("healthy");
79 1313
}
80
81
/* Resolve director --------------------------------------------------*/
82
83
VCL_BACKEND
84
VRT_DirectorResolve(VRT_CTX, VCL_BACKEND d)
85 2946
{
86 2946
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
87
88 3068
        while (d != NULL) {
89 3066
                CHECK_OBJ(d, DIRECTOR_MAGIC);
90 3066
                AN(d->vdir);
91 3066
                if (d->vdir->methods->resolve == NULL)
92 2944
                        break;
93 122
                d = d->vdir->methods->resolve(ctx, d);
94 122
        }
95 2946
        if (d == NULL)
96 2
                return (NULL);
97
98 2944
        CHECK_OBJ(d, DIRECTOR_MAGIC);
99 2944
        AN(d->vdir);
100 2944
        return (d);
101 2944
}
102
103
static VCL_BACKEND
104
VDI_Resolve(VRT_CTX)
105 3010
{
106 3010
        VCL_BACKEND d;
107 3010
        struct busyobj *bo;
108
109 3010
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
110 3010
        bo = ctx->bo;
111 3010
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
112
113 3010
        if (bo->director_req == NULL) {
114 79
                VSLb(bo->vsl, SLT_FetchError, "No backend");
115 79
                return (NULL);
116 79
        }
117
118 2931
        CHECK_OBJ(bo->director_req, DIRECTOR_MAGIC);
119 2931
        d = VRT_DirectorResolve(ctx, bo->director_req);
120 2931
        if (d != NULL)
121 2929
                return (d);
122
123 2
        VSLb(bo->vsl, SLT_FetchError,
124 2
            "Director %s returned no backend", bo->director_req->vcl_name);
125 2
        return (NULL);
126 2931
}
127
128
/* Get a set of response headers -------------------------------------*/
129
130
int
131
VDI_GetHdr(struct busyobj *bo)
132 2985
{
133 2985
        const struct director *d;
134 2985
        struct vrt_ctx ctx[1];
135 2985
        int i = -1;
136
137 2985
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
138 2985
        INIT_OBJ(ctx, VRT_CTX_MAGIC);
139 2985
        VCL_Bo2Ctx(ctx, bo);
140
141 2985
        d = VDI_Resolve(ctx);
142 2985
        if (d != NULL) {
143 2904
                VRT_Assign_Backend(&bo->director_resp, d);
144 2904
                AN(d->vdir->methods->gethdrs);
145 2904
                bo->director_state = DIR_S_HDRS;
146 2904
                i = d->vdir->methods->gethdrs(ctx, d);
147 2904
        }
148 2985
        if (i)
149 274
                bo->director_state = DIR_S_NULL;
150 2985
        return (i);
151 2985
}
152
153
/* Get IP number (if any ) -------------------------------------------*/
154
155
VCL_IP
156
VDI_GetIP(struct busyobj *bo)
157 1
{
158 1
        const struct director *d;
159 1
        struct vrt_ctx ctx[1];
160
161 1
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
162 1
        INIT_OBJ(ctx, VRT_CTX_MAGIC);
163 1
        VCL_Bo2Ctx(ctx, bo);
164
165 1
        d = bo->director_resp;
166 1
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
167 1
        assert(bo->director_state == DIR_S_HDRS ||
168 1
           bo->director_state == DIR_S_BODY);
169 1
        AZ(d->vdir->methods->resolve);
170 1
        if (d->vdir->methods->getip == NULL)
171 0
                return (NULL);
172 1
        return (d->vdir->methods->getip(ctx, d));
173 1
}
174
175
/* Finish fetch ------------------------------------------------------*/
176
177
void
178
VDI_Finish(struct busyobj *bo)
179 2710
{
180 2710
        const struct director *d;
181 2710
        struct vrt_ctx ctx[1];
182
183 2710
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
184 2710
        INIT_OBJ(ctx, VRT_CTX_MAGIC);
185 2710
        VCL_Bo2Ctx(ctx, bo);
186
187 2710
        d = bo->director_resp;
188 2710
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
189
190 2710
        AZ(d->vdir->methods->resolve);
191 2710
        AN(d->vdir->methods->finish);
192
193 2710
        assert(bo->director_state != DIR_S_NULL);
194 2710
        d->vdir->methods->finish(ctx, d);
195 2710
        bo->director_state = DIR_S_NULL;
196 2710
}
197
198
/* Get a connection --------------------------------------------------*/
199
200
stream_close_t
201
VDI_Http1Pipe(struct req *req, struct busyobj *bo)
202 25
{
203 25
        const struct director *d;
204 25
        struct vrt_ctx ctx[1];
205
206 25
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
207 25
        CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
208 25
        INIT_OBJ(ctx, VRT_CTX_MAGIC);
209 25
        VCL_Bo2Ctx(ctx, bo);
210 25
        VCL_Req2Ctx(ctx, req);
211
212 25
        d = VDI_Resolve(ctx);
213 25
        if (d == NULL || d->vdir->methods->http1pipe == NULL) {
214 0
                VSLb(bo->vsl, SLT_VCL_Error, "Backend does not support pipe");
215 0
                return (SC_TX_ERROR);
216 0
        }
217 25
        VRT_Assign_Backend(&bo->director_resp, d);
218 25
        return (d->vdir->methods->http1pipe(ctx, d));
219 25
}
220
221
/* Check health --------------------------------------------------------
222
 *
223
 * If director has no healthy method, we just assume it is healthy.
224
 */
225
226
/*--------------------------------------------------------------------
227
 * Test if backend is healthy and report when that last changed
228
 */
229
230
VCL_BOOL
231
VRT_Healthy(VRT_CTX, VCL_BACKEND d, VCL_TIME *changed)
232 3724
{
233
234 3724
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
235 3724
        if (d == NULL)
236 0
                return (0);
237 3724
        CHECK_OBJ(d, DIRECTOR_MAGIC);
238
239 3724
        if (d->vdir->admin_health->health >= 0) {
240 101
                if (changed != NULL)
241 57
                        *changed = d->vdir->health_changed;
242 101
                return (d->vdir->admin_health->health);
243 101
        }
244
245 3623
        if (d->vdir->methods->healthy == NULL) {
246 3489
                if (changed != NULL)
247 536
                        *changed = d->vdir->health_changed;
248 3489
                return (1);
249 3489
        }
250
251 134
        return (d->vdir->methods->healthy(ctx, d, changed));
252 3623
}
253
254
/*--------------------------------------------------------------------
255
 * Update health_changed.
256
 */
257
VCL_VOID
258
VRT_SetChanged(VCL_BACKEND d, VCL_TIME changed)
259 112
{
260
261 112
        CHECK_OBJ_ORNULL(d, DIRECTOR_MAGIC);
262
263 112
        if (d != NULL && changed > d->vdir->health_changed)
264 8
                d->vdir->health_changed = changed;
265 112
}
266
267
/* Send Event ----------------------------------------------------------
268
 */
269
270
void
271
VDI_Event(const struct director *d, enum vcl_event_e ev)
272 1793
{
273
274 1793
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
275 1793
        if (d->vdir->methods->event != NULL)
276 1619
                d->vdir->methods->event(d, ev);
277 1793
}
278
279
/* Dump panic info -----------------------------------------------------
280
 */
281
282
void
283
VDI_Panic(const struct director *d, struct vsb *vsb, const char *nm)
284 7
{
285 7
        if (d == NULL)
286 1
                return;
287 6
        VSB_printf(vsb, "%s = %p {\n", nm, d);
288 6
        VSB_indent(vsb, 2);
289 6
        VSB_printf(vsb, "cli_name = %s,\n", d->vdir->cli_name);
290 6
        VSB_printf(vsb, "admin_health = %s, changed = %f,\n",
291 6
            VDI_Ahealth(d), d->vdir->health_changed);
292 6
        VSB_printf(vsb, "type = %s {\n", d->vdir->methods->type);
293 6
        VSB_indent(vsb, 2);
294 6
        if (d->vdir->methods->panic != NULL)
295 6
                d->vdir->methods->panic(d, vsb);
296 6
        VSB_indent(vsb, -2);
297 6
        VSB_cat(vsb, "},\n");
298 6
        VSB_indent(vsb, -2);
299 6
        VSB_cat(vsb, "},\n");
300 6
}
301
302
303
/*---------------------------------------------------------------------*/
304
305
struct list_args {
306
        unsigned        magic;
307
#define LIST_ARGS_MAGIC 0x7e7cefeb
308
        int             p;
309
        int             j;
310
        const char      *jsep;
311
        struct vsb      *vsb;
312
        struct vte      *vte;
313
};
314
315
static const char *
316
cli_health(VRT_CTX, const struct director *d)
317 1
{
318 1
        VCL_BOOL healthy = VRT_Healthy(ctx, d, NULL);
319
320 1
        return (healthy ? "healthy" : "sick");
321 1
}
322
323
static int v_matchproto_(vcl_be_func)
324
do_list(struct cli *cli, struct director *d, void *priv)
325 1304
{
326 1304
        char time_str[VTIM_FORMAT_SIZE];
327 1304
        struct list_args *la;
328 1304
        struct vrt_ctx *ctx;
329
330 1304
        AN(cli);
331 1304
        CAST_OBJ_NOTNULL(la, priv, LIST_ARGS_MAGIC);
332 1304
        AN(la->vsb);
333 1304
        AN(la->vte);
334 1304
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
335
336 1304
        if (d->vdir->admin_health == VDI_AH_DELETED)
337 0
                return (0);
338
339 1304
        ctx = VCL_Get_CliCtx(0);
340
341 1304
        VTE_printf(la->vte, "%s\t%s\t", d->vdir->cli_name, VDI_Ahealth(d));
342
343 1304
        if (d->vdir->methods->list != NULL) {
344 1236
                VSB_clear(la->vsb);
345 1236
                d->vdir->methods->list(ctx, d, la->vsb, 0, 0);
346 1236
                AZ(VSB_finish(la->vsb));
347 1236
                VTE_cat(la->vte, VSB_data(la->vsb));
348 1236
        } else if (d->vdir->methods->healthy != NULL)
349 1
                VTE_printf(la->vte, "0/0\t%s", cli_health(ctx, d));
350 67
        else
351 67
                VTE_cat(la->vte, "0/0\thealthy");
352
353 1304
        VTIM_format(d->vdir->health_changed, time_str);
354 1304
        VTE_printf(la->vte, "\t%s", time_str);
355 1304
        if (la->p && d->vdir->methods->list != NULL) {
356 28
                VSB_clear(la->vsb);
357 28
                d->vdir->methods->list(ctx, d, la->vsb, la->p, 0);
358 28
                AZ(VSB_finish(la->vsb));
359 28
                VTE_cat(la->vte, VSB_data(la->vsb));
360 28
        }
361
362 1304
        VTE_cat(la->vte, "\n");
363 1304
        AZ(VCL_Rel_CliCtx(&ctx));
364 1304
        AZ(ctx);
365
366 1304
        return (0);
367 1304
}
368
369
static int v_matchproto_(vcl_be_func)
370
do_list_json(struct cli *cli, struct director *d, void *priv)
371 38
{
372 38
        struct list_args *la;
373 38
        struct vrt_ctx *ctx;
374
375 38
        CAST_OBJ_NOTNULL(la, priv, LIST_ARGS_MAGIC);
376 38
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
377
378 38
        if (d->vdir->admin_health == VDI_AH_DELETED)
379 0
                return (0);
380
381 38
        ctx = VCL_Get_CliCtx(0);
382
383 38
        VCLI_Out(cli, "%s", la->jsep);
384 38
        la->jsep = ",\n";
385 38
        VCLI_JSON_str(cli, d->vdir->cli_name);
386 38
        VCLI_Out(cli, ": {\n");
387 38
        VSB_indent(cli->sb, 2);
388 38
        VCLI_Out(cli, "\"type\": \"%s\",\n", d->vdir->methods->type);
389 38
        VCLI_Out(cli, "\"admin_health\": \"%s\",\n", VDI_Ahealth(d));
390 38
        VCLI_Out(cli, "\"probe_message\": ");
391 38
        if (d->vdir->methods->list != NULL)
392 36
                d->vdir->methods->list(ctx, d, cli->sb, 0, 1);
393 2
        else if (d->vdir->methods->healthy != NULL)
394 0
                VCLI_Out(cli, "[0, 0, \"%s\"]", cli_health(ctx, d));
395 2
        else
396 2
                VCLI_Out(cli, "[0, 0, \"healthy\"]");
397
398 38
        VCLI_Out(cli, ",\n");
399
400 38
        if (la->p && d->vdir->methods->list != NULL) {
401 14
                VCLI_Out(cli, "\"probe_details\": ");
402 14
                d->vdir->methods->list(ctx, d, cli->sb, la->p, 1);
403 14
        }
404 38
        VCLI_Out(cli, "\"last_change\": %.3f\n", d->vdir->health_changed);
405 38
        VSB_indent(cli->sb, -2);
406 38
        VCLI_Out(cli, "}");
407
408 38
        AZ(VCL_Rel_CliCtx(&ctx));
409 38
        AZ(ctx);
410
411 38
        return (0);
412 38
}
413
414
static void v_matchproto_(cli_func_t)
415
cli_backend_list(struct cli *cli, const char * const *av, void *priv)
416 1007
{
417 1007
        const char *p;
418 1007
        struct list_args la[1];
419 1007
        int i;
420
421 1007
        (void)priv;
422 1007
        ASSERT_CLI();
423 1007
        INIT_OBJ(la, LIST_ARGS_MAGIC);
424 1007
        la->jsep = "";
425 1030
        for (i = 2; av[i] != NULL && av[i][0] == '-'; i++) {
426 48
                for(p = av[i] + 1; *p; p++) {
427 25
                        switch(*p) {
428 8
                        case 'j': la->j = 1; break;
429 17
                        case 'p': la->p = !la->p; break;
430 0
                        default:
431 0
                                VCLI_Out(cli, "Invalid flag %c", *p);
432 0
                                VCLI_SetResult(cli, CLIS_PARAM);
433 0
                                return;
434 25
                        }
435 25
                }
436 23
        }
437 1007
        if (av[i] != NULL && av[i+1] != NULL) {
438 0
                VCLI_Out(cli, "Too many arguments");
439 0
                VCLI_SetResult(cli, CLIS_PARAM);
440 0
                return;
441 0
        }
442 1007
        if (la->j) {
443 8
                VCLI_JSON_begin(cli, 3, av);
444 8
                VCLI_Out(cli, ",\n");
445 8
                VCLI_Out(cli, "{\n");
446 8
                VSB_indent(cli->sb, 2);
447 8
                (void)VCL_IterDirector(cli, av[i], do_list_json, la);
448 8
                VSB_indent(cli->sb, -2);
449 8
                VCLI_Out(cli, "\n");
450 8
                VCLI_Out(cli, "}");
451 8
                VCLI_JSON_end(cli);
452 999
        } else {
453 999
                la->vsb = VSB_new_auto();
454 999
                AN(la->vsb);
455 999
                la->vte = VTE_new(5, 80);
456 999
                AN(la->vte);
457 999
                VTE_printf(la->vte, "%s\t%s\t%s\t%s\t%s\n",
458 999
                    "Backend name", "Admin", "Probe", "Health", "Last change");
459 999
                (void)VCL_IterDirector(cli, av[i], do_list, la);
460 999
                AZ(VTE_finish(la->vte));
461 999
                AZ(VTE_format(la->vte, VCLI_VTE_format, cli));
462 999
                VTE_destroy(&la->vte);
463 999
                VSB_destroy(&la->vsb);
464 999
        }
465 1007
}
466
467
/*---------------------------------------------------------------------*/
468
469
struct set_health {
470
        unsigned                        magic;
471
#define SET_HEALTH_MAGIC                0x0c46b9fb
472
        const struct vdi_ahealth        *ah;
473
};
474
475
static int v_matchproto_(vcl_be_func)
476
do_set_health(struct cli *cli, struct director *d, void *priv)
477 35
{
478 35
        struct set_health *sh;
479
480 35
        (void)cli;
481 35
        CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
482 35
        CAST_OBJ_NOTNULL(sh, priv, SET_HEALTH_MAGIC);
483
484 35
        if (d->vdir->admin_health == VDI_AH_DELETED)
485 0
                return (0);
486 35
        if (d->vdir->admin_health != sh->ah) {
487 32
                d->vdir->health_changed = VTIM_real();
488 32
                d->vdir->admin_health = sh->ah;
489 32
                VDI_Event(d, VDI_EVENT_SICK);
490 32
        }
491 35
        return (0);
492 35
}
493
494
static void v_matchproto_()
495
cli_backend_set_health(struct cli *cli, const char * const *av, void *priv)
496 42
{
497 42
        int n;
498 42
        struct set_health sh[1];
499
500 42
        (void)av;
501 42
        (void)priv;
502 42
        ASSERT_CLI();
503 42
        AN(av[2]);
504 42
        AN(av[3]);
505 42
        INIT_OBJ(sh, SET_HEALTH_MAGIC);
506 42
        sh->ah = vdi_str2ahealth(av[3]);
507 42
        if (sh->ah == NULL || sh->ah == VDI_AH_DELETED) {
508 4
                VCLI_Out(cli, "Invalid state %s", av[3]);
509 4
                VCLI_SetResult(cli, CLIS_PARAM);
510 4
                return;
511 4
        }
512 38
        n = VCL_IterDirector(cli, av[2], do_set_health, sh);
513 38
        if (n == 0) {
514 3
                VCLI_Out(cli, "No Backends matches");
515 3
                VCLI_SetResult(cli, CLIS_PARAM);
516 3
        }
517 38
}
518
519
/*---------------------------------------------------------------------*/
520
521
static struct cli_proto backend_cmds[] = {
522
        { CLICMD_BACKEND_LIST,          "",
523
             cli_backend_list, cli_backend_list },
524
        { CLICMD_BACKEND_SET_HEALTH,    "", cli_backend_set_health },
525
        { NULL }
526
};
527
528
/*---------------------------------------------------------------------*/
529
530
void
531
VDI_Init(void)
532 1026
{
533
534 1026
        CLI_AddFuncs(backend_cmds);
535 1026
}