Code Coverage: vinyl-cache/vmod/vmod_directors.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2013-2015 Varnish Software AS
2
 * Copyright 2019 UPLEX - Nils Goroll Systemoptimierung
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@FreeBSD.org>
6
 * Author: Nils Goroll <nils.goroll@uplex.de>
7
 *
8
 * SPDX-License-Identifier: BSD-2-Clause
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions
12
 * are met:
13
 * 1. Redistributions of source code must retain the above copyright
14
 *    notice, this list of conditions and the following disclaimer.
15
 * 2. Redistributions in binary form must reproduce the above copyright
16
 *    notice, this list of conditions and the following disclaimer in the
17
 *    documentation and/or other materials provided with the distribution.
18
 *
19
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29
 * SUCH DAMAGE.
30
 */
31
32
#include "config.h"
33
34
#include <stdlib.h>
35
#include <stdio.h>
36
37
#include "cache/cache.h"
38
39
#include "vbm.h"
40
#include "vcl.h"
41
#include "vsb.h"
42
43
#include "vcc_directors_if.h"
44
45
#include "vmod_directors.h"
46
47
VCL_BACKEND
48
VPFX(lookup)(VRT_CTX, VCL_STRING name)
49 1
{
50 1
        AN(ctx->method & VCL_MET_TASK_H);
51 1
        return (VRT_LookupDirector(ctx, name));
52 1
}
53
54
static void
55
vdir_expand(struct vdir *vd, unsigned n)
56 33
{
57 33
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
58
59 33
        vd->backend = realloc(vd->backend, n * sizeof *vd->backend);
60 33
        AN(vd->backend);
61 33
        vd->weight = realloc(vd->weight, n * sizeof *vd->weight);
62 33
        AN(vd->weight);
63 33
        if (n > vd->healthy->nbits)
64 0
                vbit_expand(vd->healthy, n);
65 33
        AN(vd->healthy);
66 33
        vd->l_backend = n;
67 33
}
68
69
void
70
vdir_new(VRT_CTX, struct vdir **vdp, const char *vcl_name,
71
    const struct vdi_methods *m, void *priv)
72 36
{
73 36
        struct vdir *vd;
74
75 36
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
76 36
        CHECK_OBJ_NOTNULL(m, VDI_METHODS_MAGIC);
77 36
        AN(vcl_name);
78 36
        AN(vdp);
79 36
        AZ(*vdp);
80 36
        ALLOC_OBJ(vd, VDIR_MAGIC);
81 36
        AN(vd);
82 36
        *vdp = vd;
83 36
        PTOK(pthread_rwlock_init(&vd->mtx, NULL));
84 36
        vd->dir = VRT_AddDirector(ctx, m, priv, "%s", vcl_name);
85 36
        vd->healthy = vbit_new(8);
86 36
        AN(vd->healthy);
87 36
}
88
89
void
90
vdir_release(struct vdir *vd)
91 8
{
92 8
        unsigned u;
93
94 8
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
95
96 8
        vdir_wrlock(vd);
97 20
        for (u = 0; u < vd->n_backend; u++)
98 12
                VRT_Assign_Backend(&vd->backend[u], NULL);
99 8
        vd->n_backend = 0;
100 8
        vdir_unlock(vd);
101 8
}
102
103
void
104
vdir_delete(struct vdir **vdp)
105 8
{
106 8
        struct vdir *vd;
107
108 8
        TAKE_OBJ_NOTNULL(vd, vdp, VDIR_MAGIC);
109
110 8
        AZ(vd->dir);
111 8
        AZ(vd->n_backend);
112 8
        free(vd->backend);
113 8
        free(vd->weight);
114 8
        PTOK(pthread_rwlock_destroy(&vd->mtx));
115 8
        vbit_destroy(vd->healthy);
116 8
        FREE_OBJ(vd);
117 8
}
118
119
void
120
vdir_rdlock(struct vdir *vd)
121 157
{
122 157
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
123 157
        PTOK(pthread_rwlock_rdlock(&vd->mtx));
124 157
}
125
126
void
127
vdir_wrlock(struct vdir *vd)
128 181
{
129 181
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
130 181
        PTOK(pthread_rwlock_wrlock(&vd->mtx));
131 181
}
132
133
void
134
vdir_unlock(struct vdir *vd)
135 338
{
136 338
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
137 338
        PTOK(pthread_rwlock_unlock(&vd->mtx));
138 338
}
139
140
141
void
142
vdir_add_backend(VRT_CTX, struct vdir *vd, VCL_BACKEND be, double weight)
143 90
{
144 90
        unsigned u;
145
146 90
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
147 90
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
148 90
        if (be == NULL) {
149 3
                VRT_fail(ctx, "%s: None backend cannot be added",
150 3
                    VRT_BACKEND_string(vd->dir));
151 3
                return;
152 3
        }
153 87
        AN(be);
154 87
        vdir_wrlock(vd);
155 87
        if (vd->n_backend >= vd->l_backend)
156 33
                vdir_expand(vd, vd->l_backend + 16);
157 87
        assert(vd->n_backend < vd->l_backend);
158 87
        u = vd->n_backend++;
159 87
        vd->backend[u] = NULL;
160 87
        VRT_Assign_Backend(&vd->backend[u], be);
161 87
        vd->weight[u] = weight;
162 87
        vdir_unlock(vd);
163 87
}
164
165
void
166
vdir_remove_backend(VRT_CTX, struct vdir *vd, VCL_BACKEND be, unsigned *cur)
167 12
{
168 12
        unsigned u, n;
169
170 12
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
171 12
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
172 12
        if (be == NULL) {
173 0
                VRT_fail(ctx, "%s: None backend cannot be removed",
174 0
                    VRT_BACKEND_string(vd->dir));
175 0
                return;
176 0
        }
177 12
        CHECK_OBJ(be, DIRECTOR_MAGIC);
178 12
        vdir_wrlock(vd);
179 17
        for (u = 0; u < vd->n_backend; u++)
180 17
                if (vd->backend[u] == be)
181 12
                        break;
182 12
        if (u == vd->n_backend) {
183 0
                vdir_unlock(vd);
184 0
                return;
185 0
        }
186 12
        VRT_Assign_Backend(&vd->backend[u], NULL);
187 12
        n = (vd->n_backend - u) - 1;
188 12
        vmemmove(&vd->backend[u], &vd->backend[u + 1],
189 12
                 n * sizeof(vd->backend[0]));
190 12
        vmemmove(&vd->weight[u], &vd->weight[u + 1],
191 12
                 n * sizeof(vd->weight[0]));
192 12
        vd->n_backend--;
193
194 12
        if (cur) {
195 4
                assert(*cur <= vd->n_backend);
196 4
                if (u < *cur)
197 1
                        (*cur)--;
198 3
                else if (*cur == vd->n_backend)
199 1
                        *cur = 0;
200 4
        }
201 12
        vdir_unlock(vd);
202 12
}
203
204
VCL_BOOL
205
vdir_any_healthy(VRT_CTX, struct vdir *vd, VCL_TIME *changed)
206 49
{
207 49
        unsigned retval = 0;
208 49
        VCL_BACKEND be;
209 49
        unsigned u;
210 49
        vtim_real c;
211
212 49
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
213 49
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
214 49
        vdir_rdlock(vd);
215 49
        if (changed != NULL)
216 10
                *changed = 0;
217 70
        for (u = 0; u < vd->n_backend; u++) {
218 63
                be = vd->backend[u];
219 63
                CHECK_OBJ_NOTNULL(be, DIRECTOR_MAGIC);
220 63
                retval = VRT_Healthy(ctx, be, &c);
221 63
                if (changed != NULL && c > *changed)
222 13
                        *changed = c;
223 63
                if (retval)
224 42
                        break;
225 63
        }
226 49
        vdir_unlock(vd);
227 49
        return (retval);
228 49
}
229
230
void
231
vdir_list(VRT_CTX, struct vdir *vd, struct vsb *vsb, int pflag, int jflag,
232
    int weight)
233 52
{
234 52
        VCL_BACKEND be;
235 52
        VCL_BOOL h;
236 52
        unsigned u, nh;
237 52
        double w;
238
239 52
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
240 52
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
241
242 52
        if (pflag) {
243 8
                if (jflag) {
244 4
                        VSB_cat(vsb, "{\n");
245 4
                        VSB_indent(vsb, 2);
246 4
                        if (weight)
247 1
                                VSB_printf(vsb, "\"total_weight\": %f,\n",
248 1
                                    vd->total_weight);
249 4
                        VSB_cat(vsb, "\"backends\": {\n");
250 4
                        VSB_indent(vsb, 2);
251 4
                } else {
252 4
                        VSB_cat(vsb, "\n\n\tBackend\tWeight\tHealth\n");
253 4
                }
254 8
        }
255
256 52
        vdir_rdlock(vd);
257 52
        vdir_update_health(ctx, vd);
258 74
        for (u = 0; pflag && u < vd->n_backend; u++) {
259 22
                be = vd->backend[u];
260 22
                CHECK_OBJ_NOTNULL(be, DIRECTOR_MAGIC);
261
262 22
                h = vbit_test(vd->healthy, u);
263
264 22
                w = h ? vd->weight[u] : 0.0;
265
266 22
                if (jflag) {
267 11
                        if (u)
268 7
                                VSB_cat(vsb, ",\n");
269 11
                        VSB_printf(vsb, "\"%s\": {\n", be->vcl_name);
270 11
                        VSB_indent(vsb, 2);
271
272 11
                        if (weight)
273 4
                                VSB_printf(vsb, "\"weight\": %f,\n", w);
274
275 11
                        if (h)
276 8
                                VSB_cat(vsb, "\"health\": \"healthy\"\n");
277 3
                        else
278 3
                                VSB_cat(vsb, "\"health\": \"sick\"\n");
279
280 11
                        VSB_indent(vsb, -2);
281 11
                        VSB_cat(vsb, "}");
282 11
                } else {
283 11
                        VSB_cat(vsb, "\t");
284 11
                        VSB_cat(vsb, be->vcl_name);
285 11
                        if (weight)
286 4
                                VSB_printf(vsb, "\t%6.2f%%\t",
287 4
                                    100 * w / vd->total_weight);
288 7
                        else
289 7
                                VSB_cat(vsb, "\t-\t");
290 11
                        VSB_cat(vsb, h ? "healthy" : "sick");
291 11
                        VSB_cat(vsb, "\n");
292 11
                }
293 22
        }
294 52
        nh = vd->n_healthy;
295 52
        u = vd->n_backend;
296 52
        vdir_unlock(vd);
297
298 52
        if (jflag && (pflag)) {
299 4
                VSB_cat(vsb, "\n");
300 4
                VSB_indent(vsb, -2);
301 4
                VSB_cat(vsb, "}\n");
302 4
                VSB_indent(vsb, -2);
303 4
                VSB_cat(vsb, "},\n");
304 4
        }
305
306 52
        if (pflag)
307 8
                return;
308
309 44
        if (jflag)
310 10
                VSB_printf(vsb, "[%u, %u, \"%s\"]", nh, u,
311 10
                    nh ? "healthy" : "sick");
312 34
        else
313 34
                VSB_printf(vsb, "%u/%u\t%s", nh, u, nh ? "healthy" : "sick");
314 44
}
315
316
/*
317
 * iterate backends and update
318
 * - healthy bitmap
319
 * - number of healthy backends
320
 * - total_weight
321
 * - last change time of the VCL_BACKEND
322
 *
323
 * must be called under the vdir lock (read or write).
324
 *
325
 * A write lock is required if consistency between the individual attributes is
326
 * a must, e.g. when total_weight is required to be the exact sum of the weights
327
 *
328
 * The read lock is safe because add_backend expands the healthy bitmap and all
329
 * other members are atomic and may be used if consistency is not required.
330
 */
331
void
332
vdir_update_health(VRT_CTX, struct vdir *vd)
333 112
{
334 112
        VCL_TIME c, changed = 0;
335 112
        VCL_BOOL h;
336 112
        VCL_BACKEND be;
337 112
        unsigned u, nh = 0;
338 112
        double tw = 0.0;
339 112
        struct vbitmap *healthy;
340
341 112
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
342 112
        healthy = vd->healthy;
343 374
        for (u = 0; u < vd->n_backend; u++) {
344 262
                be = vd->backend[u];
345 262
                CHECK_OBJ_NOTNULL(be, DIRECTOR_MAGIC);
346 262
                c = 0;
347 262
                h = VRT_Healthy(ctx, be, &c);
348 262
                if (h) {
349 203
                        nh++;
350 203
                        tw += vd->weight[u];
351 203
                }
352 262
                if (c > changed)
353 252
                        changed = c;
354 262
                if (h != vbit_test(healthy, u)) {
355 134
                        if (h)
356 132
                                vbit_set(healthy, u);
357 2
                        else
358 2
                                vbit_clr(healthy, u);
359 134
                }
360 262
        }
361 112
        VRT_SetChanged(vd->dir, changed);
362 112
        vd->total_weight = tw;
363 112
        vd->n_healthy = nh;
364 112
}
365
366
static unsigned
367
vdir_pick_by_weight(const struct vdir *vd, double w)
368 46
{
369 46
        const struct vbitmap *healthy = vd->healthy;
370 46
        double a = 0.0;
371 46
        unsigned u;
372
373 46
        AN(healthy);
374 70
        for (u = 0; u < vd->n_backend; u++) {
375 70
                if (! vbit_test(healthy, u))
376 4
                        continue;
377 66
                a += vd->weight[u];
378 66
                if (w < a)
379 46
                        return (u);
380 66
        }
381 0
        WRONG("");
382 0
}
383
384
VCL_BACKEND
385
vdir_pick_be(VRT_CTX, struct vdir *vd, double w)
386 47
{
387 47
        unsigned u;
388 47
        VCL_BACKEND be = NULL;
389
390 47
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
391 47
        CHECK_OBJ_NOTNULL(vd, VDIR_MAGIC);
392 47
        vdir_wrlock(vd);
393 47
        vdir_update_health(ctx, vd);
394 47
        if (vd->total_weight > 0.0) {
395 46
                u = vdir_pick_by_weight(vd, w * vd->total_weight);
396 46
                assert(u < vd->n_backend);
397 46
                be = vd->backend[u];
398 46
                CHECK_OBJ_NOTNULL(be, DIRECTOR_MAGIC);
399 46
        }
400 47
        vdir_unlock(vd);
401 47
        return (be);
402 47
}