GCOV - Varnish Cache


/*-
 * Copyright (c) 2013-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@FreeBSD.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

#include <stdlib.h>
#include <string.h>

#include "cache/cache.h"

#include "vcc_directors_if.h"

#include "vmod_directors.h"

struct vmod_directors_round_robin {
        unsigned                                magic;
#define VMOD_DIRECTORS_ROUND_ROBIN_MAGIC        0xa80970cf
        struct vdir                             *vd;
        unsigned                                nxt;
};

static VCL_BOOL v_matchproto_(vdi_healthy_f)
vmod_rr_healthy(VRT_CTX, VCL_BACKEND dir, VCL_TIME *changed)
{
        struct vmod_directors_round_robin *rr;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
        CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        return (vdir_any_healthy(ctx, rr->vd, changed));
}

static void v_matchproto_(vdi_list_f)
vmod_rr_list(VRT_CTX, VCL_BACKEND dir, struct vsb *vsb, int pflag, int jflag)
{
        struct vmod_directors_round_robin *rr;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
        CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        vdir_list(ctx, rr->vd, vsb, pflag, jflag, 0);
}

static VCL_BACKEND v_matchproto_(vdi_resolve_f)
vmod_rr_resolve(VRT_CTX, VCL_BACKEND dir)
{
        struct vmod_directors_round_robin *rr;
        unsigned u;
        VCL_BACKEND be = NULL;
        unsigned nxt;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
        CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        vdir_rdlock(rr->vd);
        nxt = rr->nxt;
        for (u = 0; u < rr->vd->n_backend; u++) {
                be = rr->vd->backend[nxt];
                nxt++;
                nxt %= rr->vd->n_backend;
                CHECK_OBJ_NOTNULL(be, DIRECTOR_MAGIC);
                if (VRT_Healthy(ctx, be, NULL))
                        break;
        }
        rr->nxt = nxt;
        if (u == rr->vd->n_backend)
                be = NULL;
        vdir_unlock(rr->vd);
        return (be);
}

static void v_matchproto_(vdi_release_f)
vmod_rr_release(VCL_BACKEND dir)
{
        struct vmod_directors_round_robin *rr;

        CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
        CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        vdir_release(rr->vd);
}

static void v_matchproto_(vdi_destroy_f)
vmod_rr_destroy(VCL_BACKEND dir)
{
        struct vmod_directors_round_robin *rr;

        CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
        CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        vdir_delete(&rr->vd);
        FREE_OBJ(rr);
}

static const struct vdi_methods vmod_rr_methods[1] = {{
        .magic =                VDI_METHODS_MAGIC,
        .type =                 "round-robin",
        .healthy =              vmod_rr_healthy,
        .resolve =              vmod_rr_resolve,
        .release =              vmod_rr_release,
        .destroy =              vmod_rr_destroy,
        .list =                 vmod_rr_list
}};

VCL_VOID v_matchproto_()
vmod_round_robin__init(VRT_CTX,
    struct vmod_directors_round_robin **rrp, const char *vcl_name)
{
        struct vmod_directors_round_robin *rr;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(rrp);
        AZ(*rrp);
        ALLOC_OBJ(rr, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        AN(rr);
        *rrp = rr;
        vdir_new(ctx, &rr->vd, vcl_name, vmod_rr_methods, rr);
}

VCL_VOID v_matchproto_()
vmod_round_robin__fini(struct vmod_directors_round_robin **rrp)
{
        struct vmod_directors_round_robin *rr;

        TAKE_OBJ_NOTNULL(rr, rrp, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        VRT_DelDirector(&rr->vd->dir);
}

VCL_VOID v_matchproto_()
vmod_round_robin_add_backend(VRT_CTX,
    struct vmod_directors_round_robin *rr, VCL_BACKEND be)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(rr, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        vdir_add_backend(ctx, rr->vd, be, 0.0);
}

VCL_VOID v_matchproto_()
vmod_round_robin_remove_backend(VRT_CTX,
    struct vmod_directors_round_robin *rr, VCL_BACKEND be)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(rr, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        vdir_remove_backend(ctx, rr->vd, be, NULL);
}

VCL_BACKEND v_matchproto_()
vmod_round_robin_backend(VRT_CTX,
    struct vmod_directors_round_robin *rr)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(rr, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
        return (rr->vd->dir);
}

		varnish-cache/vmod/vmod_directors_round_robin.c
0		/*-
1		* Copyright (c) 2013-2015 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@FreeBSD.org>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*/
29
30		#include "config.h"
31
32		#include <stdlib.h>
33		#include <string.h>
34
35		#include "cache/cache.h"
36
37		#include "vcc_directors_if.h"
38
39		#include "vmod_directors.h"
40
41		struct vmod_directors_round_robin {
42		unsigned magic;
43		#define VMOD_DIRECTORS_ROUND_ROBIN_MAGIC 0xa80970cf
44		struct vdir *vd;
45		unsigned nxt;
46		};
47
48		static VCL_BOOL v_matchproto_(vdi_healthy_f)
49	1075	vmod_rr_healthy(VRT_CTX, VCL_BACKEND dir, VCL_TIME *changed)
50		{
51		struct vmod_directors_round_robin *rr;
52
53	1075	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
54	1075	CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
55	1075	CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
56	1075	return (vdir_any_healthy(ctx, rr->vd, changed));
57		}
58
59		static void v_matchproto_(vdi_list_f)
60	900	vmod_rr_list(VRT_CTX, VCL_BACKEND dir, struct vsb *vsb, int pflag, int jflag)
61		{
62		struct vmod_directors_round_robin *rr;
63
64	900	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
65	900	CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
66	900	CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
67	900	vdir_list(ctx, rr->vd, vsb, pflag, jflag, 0);
68	900	}
69
70		static VCL_BACKEND v_matchproto_(vdi_resolve_f)
71	1075	vmod_rr_resolve(VRT_CTX, VCL_BACKEND dir)
72		{
73		struct vmod_directors_round_robin *rr;
74		unsigned u;
75	1075	VCL_BACKEND be = NULL;
76		unsigned nxt;
77
78	1075	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
79	1075	CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
80	1075	CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
81	1075	vdir_rdlock(rr->vd);
82	1075	nxt = rr->nxt;
83	1125	for (u = 0; u < rr->vd->n_backend; u++) {
84	1125	be = rr->vd->backend[nxt];
85	1125	nxt++;
86	1125	nxt %= rr->vd->n_backend;
87	1125	CHECK_OBJ_NOTNULL(be, DIRECTOR_MAGIC);
88	1125	if (VRT_Healthy(ctx, be, NULL))
89	1075	break;
90	50	}
91	1075	rr->nxt = nxt;
92	1075	if (u == rr->vd->n_backend)
93	0	be = NULL;
94	1075	vdir_unlock(rr->vd);
95	1075	return (be);
96		}
97
98		static void v_matchproto_(vdi_release_f)
99	125	vmod_rr_release(VCL_BACKEND dir)
100		{
101		struct vmod_directors_round_robin *rr;
102
103	125	CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
104	125	CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
105	125	vdir_release(rr->vd);
106	125	}
107
108		static void v_matchproto_(vdi_destroy_f)
109	125	vmod_rr_destroy(VCL_BACKEND dir)
110		{
111		struct vmod_directors_round_robin *rr;
112
113	125	CHECK_OBJ_NOTNULL(dir, DIRECTOR_MAGIC);
114	125	CAST_OBJ_NOTNULL(rr, dir->priv, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
115	125	vdir_delete(&rr->vd);
116	125	FREE_OBJ(rr);
117	125	}
118
119		static const struct vdi_methods vmod_rr_methods[1] = {{
120		.magic = VDI_METHODS_MAGIC,
121		.type = "round-robin",
122		.healthy = vmod_rr_healthy,
123		.resolve = vmod_rr_resolve,
124		.release = vmod_rr_release,
125		.destroy = vmod_rr_destroy,
126		.list = vmod_rr_list
127		}};
128
129		VCL_VOID v_matchproto_()
130	475	vmod_round_robin__init(VRT_CTX,
131		struct vmod_directors_round_robin *rrp, const char vcl_name)
132		{
133		struct vmod_directors_round_robin *rr;
134
135	475	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
136	475	AN(rrp);
137	475	AZ(*rrp);
138	475	ALLOC_OBJ(rr, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
139	475	AN(rr);
140	475	*rrp = rr;
141	475	vdir_new(ctx, &rr->vd, vcl_name, vmod_rr_methods, rr);
142	475	}
143
144		VCL_VOID v_matchproto_()
145	125	vmod_round_robin__fini(struct vmod_directors_round_robin **rrp)
146		{
147		struct vmod_directors_round_robin *rr;
148
149	125	TAKE_OBJ_NOTNULL(rr, rrp, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
150	125	VRT_DelDirector(&rr->vd->dir);
151	125	}
152
153		VCL_VOID v_matchproto_()
154	1025	vmod_round_robin_add_backend(VRT_CTX,
155		struct vmod_directors_round_robin *rr, VCL_BACKEND be)
156		{
157
158	1025	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
159	1025	CHECK_OBJ_NOTNULL(rr, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
160	1025	vdir_add_backend(ctx, rr->vd, be, 0.0);
161	1025	}
162
163		VCL_VOID v_matchproto_()
164	150	vmod_round_robin_remove_backend(VRT_CTX,
165		struct vmod_directors_round_robin *rr, VCL_BACKEND be)
166		{
167	150	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
168	150	CHECK_OBJ_NOTNULL(rr, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
169	150	vdir_remove_backend(ctx, rr->vd, be, NULL);
170	150	}
171
172		VCL_BACKEND v_matchproto_()
173	1175	vmod_round_robin_backend(VRT_CTX,
174		struct vmod_directors_round_robin *rr)
175		{
176
177	1175	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
178	1175	CHECK_OBJ_NOTNULL(rr, VMOD_DIRECTORS_ROUND_ROBIN_MAGIC);
179	1175	return (rr->vd->dir);
180		}