cache_req

From fgsch at lodoss.net Fri Mar 1 11:35:09 2019 From: fgsch at lodoss.net (Federico G. Schwindt) Date: Fri, 1 Mar 2019 11:35:09 +0000 (UTC) Subject: [master] f06c02c93 Trailing grave accents and whitespace Message-ID: <20190301113509.2C345116F46@lists.varnish-cache.org> commit f06c02c93b8deffed6b214d1893bcb84351a4374 Author: Federico G. Schwindt Date: Fri Mar 1 11:29:47 2019 +0000 Trailing grave accents and whitespace diff --git a/.gitignore b/.gitignore index 6a6eb8f57..d24c7b41c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ -# Matches ALL Makefile and Makefile.in occurrences +# Matches ALL Makefile and Makefile.in occurrences Makefile Makefile.in diff --git a/doc/changes.rst b/doc/changes.rst index 7173b6316..8d7d253e6 100644 --- a/doc/changes.rst +++ b/doc/changes.rst @@ -260,7 +260,7 @@ Fixed bugs .. _2820: https://github.com/varnishcache/varnish-cache/issues/2820 .. _2823: https://github.com/varnishcache/varnish-cache/issues/2823 .. _2831: https://github.com/varnishcache/varnish-cache/issues/2831 -.. _2837: https://github.com/varnishcache/varnish-cache/pull/2837 +.. _2837: https://github.com/varnishcache/varnish-cache/pull/2837 .. _2840: https://github.com/varnishcache/varnish-cache/issues/2840 .. _VIP16: https://github.com/varnishcache/varnish-cache/wiki/VIP16%3A-Retire-parameters-aliases diff --git a/doc/sphinx/reference/vtla.rst b/doc/sphinx/reference/vtla.rst index ba80b8958..1fdfb4abf 100644 --- a/doc/sphinx/reference/vtla.rst +++ b/doc/sphinx/reference/vtla.rst @@ -14,107 +14,107 @@ This page tells you what we use them for, if & when we remember to add them... VAV - Varnish Arg Vector -- Argv parsing. + Varnish Arg Vector -- Argv parsing. VBE Varnish Back End -- Code for contacting backends - (bin/varnishd/cache_backend.c) + (bin/varnishd/cache_backend.c) VBP Varnish Backend Polling -- Health checks of backends - (bin/varnishd/cache_backend_poll.c) + (bin/varnishd/cache_backend_poll.c) VCA Varnish Connection Acceptor -- The code that receives/accepts the - TCP connections (bin/varnishd/cache_acceptor.c) + TCP connections (bin/varnishd/cache_acceptor.c) VCC - VCL to C Compiler -- The code that compiles VCL to C code. (lib/libvcl) + VCL to C Compiler -- The code that compiles VCL to C code. (lib/libvcl) VCL Varnish Configuration Language -- The domain-specific programming - language used for configuring a varnishd. + language used for configuring a varnishd. VCT - Varnish CType(3) -- Character classification for RFC2616 and XML parsing. + Varnish CType(3) -- Character classification for RFC2616 and XML parsing. VDD Varnish (Core) Developer Day -- Quarterly invite-only meeting strictly - for Varnish core (C) developers, packagers and VMOD hackers. + for Varnish core (C) developers, packagers and VMOD hackers. VEV - Varnish EVent -- library functions to implement a simple event-dispatcher. + Varnish EVent -- library functions to implement a simple event-dispatcher. VGB Varnish Governing Board -- May or may not exist. - If you need to ask, you are not on it. + If you need to ask, you are not on it. VGC - Varnish Generated Code -- Code generated by VCC from VCL. + Varnish Generated Code -- Code generated by VCC from VCL. VIN - Varnish Instance Naming -- Resolution of -n arguments. + Varnish Instance Naming -- Resolution of -n arguments. VLU Varnish Line Up -- library functions to collect stream of bytes - into lines for processing. (lib/libvarnish/vlu.c) + into lines for processing. (lib/libvarnish/vlu.c) VRE Varnish Regular Expression -- library functions for regular expression - based matching and substring replacement. (lib/libvarnish/vre.c) + based matching and substring replacement. (lib/libvarnish/vre.c) VRT Varnish Run Time -- functions called from compiled code. - (bin/varnishd/cache_vrt.c) + (bin/varnishd/cache_vrt.c) VRY VaRY -- Related to processing of Vary: HTTP headers. - (bin/varnishd/cache_vary.c) + (bin/varnishd/cache_vary.c) VSL Varnish Shared memory Log -- The log written into the shared - memory segment for varnish{log,ncsa,top,hist} to see. + memory segment for varnish{log,ncsa,top,hist} to see. VSB Varnish string Buffer -- a copy of the FreeBSD "sbuf" library, - for safe string handling. + for safe string handling. VSC Varnish Statistics Counter -- counters for various stats, - exposed via varnishapi. + exposed via varnishapi. VSS Varnish Session Stuff -- library functions to wrap DNS/TCP. - (lib/libvarnish/vss.c) + (lib/libvarnish/vss.c) VTC - Varnish Test Code -- a test-specification for the varnishtest program. + Varnish Test Code -- a test-specification for the varnishtest program. VTE Varnish Turbo Encabulator VTLA - Varnish Three Letter Acronym -- No rule without an exception. + Varnish Three Letter Acronym -- No rule without an exception. VUG Varnish User Group meeting -- Half-yearly event where the users and developers of Varnish Cache gather to share experiences and plan - future development. + future development. VWx - Varnish Waiter 'x' -- A code module to monitor idle sessions. + Varnish Waiter 'x' -- A code module to monitor idle sessions. VWE - Varnish Waiter Epoll -- epoll(2) (linux) based waiter module. + Varnish Waiter Epoll -- epoll(2) (linux) based waiter module. VWK - Varnish Waiter Kqueue -- kqueue(2) (freebsd) based waiter module. + Varnish Waiter Kqueue -- kqueue(2) (freebsd) based waiter module. VWP - Varnish Waiter Poll -- poll(2) based waiter module. + Varnish Waiter Poll -- poll(2) based waiter module. VWS - Varnish Waiter Solaris -- Solaris ports(2) based waiter module. + Varnish Waiter Solaris -- Solaris ports(2) based waiter module. diff --git a/lib/libvarnishapi/Makefile.am b/lib/libvarnishapi/Makefile.am index a94efee04..59ac166b0 100644 --- a/lib/libvarnishapi/Makefile.am +++ b/lib/libvarnishapi/Makefile.am @@ -99,7 +99,7 @@ vxp_test_CFLAGS = \ vxp_test_LDADD = @PCRE_LIBS@ \ ${RT_LIBS} ${LIBM} ${PTHREAD_LIBS} -TESTS = vsl_glob_test +TESTS = vsl_glob_test noinst_PROGRAMS += vsl_glob_test diff --git a/lib/libvmod_std/vmod.vcc b/lib/libvmod_std/vmod.vcc index a8468cfcf..b3d994618 100644 --- a/lib/libvmod_std/vmod.vcc +++ b/lib/libvmod_std/vmod.vcc @@ -141,7 +141,7 @@ Example:: if (std.file_exists("/etc/return_503")) { return (synth(503, "Varnish is in maintenance")); - }`` + } $Function VOID collect(HEADER hdr, STRING sep=", ") From geoff at uplex.de Sun Mar 3 16:31:06 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 16:31:06 +0000 (UTC) Subject: [master] 259d36f27 Start filling out the "Chnages" doc for the March 2019 release. Message-ID: <20190303163106.5187510955A@lists.varnish-cache.org> commit 259d36f27dffeea90ccb9daabcd8993bf13ccadf Author: Geoff Simmons Date: Sun Mar 3 17:30:14 2019 +0100 Start filling out the "Chnages" doc for the March 2019 release. diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index 7bac84756..d3bf72a6e 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -20,21 +20,46 @@ merged, may be found in the `change log`_. varnishd ======== +Cache lookups have undergone a number of optimizations, among them to +reduce lock contention, and to shorten and simplify the critical +section of lookup code. + +We have added a "watchdog" for thread pools that will panic the worker +process, causing it to restart, if scheduling tasks onto worker +threads appears to be deadlocking. The length of time until the panic +is set by the :ref:`ref_param_thread_pool_watchdog` parameter. If this +happens, it probably means that thread pools are too small, and you +should consider increasing the parameters +:ref:`ref_param_thread_pool_min`, :ref:`ref_param_thread_pool_max` +and/or :ref:`ref_param_thread_pools`. + Parameters ~~~~~~~~~~ -**XXX changes in -p parameters** +Some parameters that have been long deprecated are now retired. Now +you must use these parameters: + +* :ref:`ref_param_vsl_reclen` (in place of ``shm_reclen``) + +* :ref:`ref_param_vcl_path` (in place of ``vcl_dir``) + +* :ref:`ref_param_vmod_path` (in place of ``vmod_dir``) + +Added :ref:`ref_param_thread_pool_watchdog`, see above. Other changes in varnishd ~~~~~~~~~~~~~~~~~~~~~~~~~ +The VCL syntax version is now displayed in a panic message, as 41 for +VCL 4.1 and 40 for VCL 4.0. + Changes to VCL ============== VCL variables ~~~~~~~~~~~~~ -**XXX new, deprecated or removed variables, or changed semantics** +Added ``req.is_hitmiss`` and ``req.is_hitpass``, see :ref:`vcl(7)`. Other changes to VCL ~~~~~~~~~~~~~~~~~~~~ @@ -42,17 +67,18 @@ Other changes to VCL VMODs ===== -**XXX changes in the bundled VMODs** +Added the function :ref:`vmod_directors.lookup`, only for use in +``vcl_init`` or ``vcl_fini``. -varnishlog -========== +varnishlog(1) and vsl(7) +======================== -**XXX changes concerning varnishlog(1) and/or vsl(7)** +Timing information is now uniformly reported with microsecond +precision. This affects the tags ``ExpKill`` and ``ExpRearm`` +(previously with nanosecond precision). -varnishadm -========== - -**XXX changes concerning varnishadm(1) and/or varnish-cli(7)** +varnishadm(1) and varnish-cli(7) +================================ JSON responses, requested with the ``-j`` option, are now possible for the following commands (see :ref:`varnish-cli(7)`): @@ -64,6 +90,62 @@ the following commands (see :ref:`varnish-cli(7)`): * ``storage.list -j`` * ``panic.show -j`` +For automated parsing of CLI responses (``varnishadm`` output), we +recommend the use of JSON format. + +The "probe message" field in the output of ``backend.list`` (in the +``probe_message`` field of JSON format, or the ``Probe`` column of +non-JSON output) has been changed to display ``X/Y state``, where: + +* Integer ``X`` is the number of good probes in the most recent + window; or if the backend in question is a director, the number of + healthy backends accessed via the director. + +* Integer ``Y`` is the window in which the threshold for overall + health of the backend is defined (from the ``.window`` field of a + probe, see :ref:`vcl(7)`); or in the case of a director, the total + number of backends accessed via the director. + +* ``state`` is one of the strings ``"good"`` or ``"bad"``, for the + overall health of the backend or director. + +In the ``probe_message`` field of ``backend.list -j`` output, this +appears as the array ``[X, Y, state]``. + +The non-JSON output of ``vcl.list`` has been changed: + +* The ``state`` and ``temperature`` fields appear in separate columns + (previously combined in one column). + +* The optional column showing the relationships between labels and VCL + configurations (when labels are in use) has been separated into two + columns. + +See :ref:`varnish-cli(7)` for details. In the JSON output for +``vcl.list -j``, this information appears in separate fields. + +The width of columns in ``backend.list`` and ``vcl.list`` output +(non-JSON) is now dynamic, to fit the width of the terminal window. + +Bans may now be defined with respect to ``obj.ttl``, ``obj.age``, +``obj.grace`` and ``obj.keep``, referring to the expiration and age +properties of the cached object. A ban expression may also be defined +with one of the comparison operators ``<``, ``<=``, ``>`` and ``>=``; +these may only be used with one of the new duration variables for +bans. Duration constants (such as ``5m`` for five minutes of ``3h`` +for three hours) may be used in the ```` position against which +these objects are compared in a ban expression. + +``obj.ttl`` and ``obj.age`` are evaluated with respect to the time at +which the ban was defined, while ``obj.grace`` and ``obj.keep`` are +evaluated as the grace or keep time assigned to the object. So to issue +a ban for objects whose TTL expires more than 5 hours from now and +whose keep parameter is greater than 3 hours, use this expression:: + + obj.ttl > 5h && obj.keep > 3h + +See :ref:`vcl(7)` and :ref:`users-guide-purging` for details. + varnishstat =========== @@ -77,7 +159,7 @@ varnishtest Changes for developers and VMOD authors ======================================= -**XXX changes concerning VRT, the public APIs, source code organization, -builds etc.** +Python tools that generate code now prefer python 3 over python 2, +when availabale. *eof* From geoff at uplex.de Sun Mar 3 17:27:05 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 17:27:05 +0000 (UTC) Subject: [master] 93e21e094 Document param.reset in "Changes", and add some subsection headers. Message-ID: <20190303172705.72F3710A514@lists.varnish-cache.org> commit 93e21e094e1a90b63ff41033afa4fadf48e8a0a1 Author: Geoff Simmons Date: Sun Mar 3 18:25:43 2019 +0100 Document param.reset in "Changes", and add some subsection headers. diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index d3bf72a6e..dc385ec67 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -80,6 +80,9 @@ precision. This affects the tags ``ExpKill`` and ``ExpRearm`` varnishadm(1) and varnish-cli(7) ================================ +JSON output +~~~~~~~~~~~ + JSON responses, requested with the ``-j`` option, are now possible for the following commands (see :ref:`varnish-cli(7)`): @@ -93,6 +96,15 @@ the following commands (see :ref:`varnish-cli(7)`): For automated parsing of CLI responses (``varnishadm`` output), we recommend the use of JSON format. +``param.reset `` +~~~~~~~~~~~~~~~~~~~~~~~ + +Added the command ``param.reset`` to reset a parameter's value to its +default, see :ref:`varnish-cli(7)`. + +Listing backends and VCLs +~~~~~~~~~~~~~~~~~~~~~~~~~ + The "probe message" field in the output of ``backend.list`` (in the ``probe_message`` field of JSON format, or the ``Probe`` column of non-JSON output) has been changed to display ``X/Y state``, where: @@ -127,6 +139,9 @@ See :ref:`varnish-cli(7)` for details. In the JSON output for The width of columns in ``backend.list`` and ``vcl.list`` output (non-JSON) is now dynamic, to fit the width of the terminal window. +Banning by expiration parameters +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + Bans may now be defined with respect to ``obj.ttl``, ``obj.age``, ``obj.grace`` and ``obj.keep``, referring to the expiration and age properties of the cached object. A ban expression may also be defined From geoff at uplex.de Sun Mar 3 17:48:06 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 17:48:06 +0000 (UTC) Subject: [master] c556a9426 Update "Changes" concerning VSL/VUT. Message-ID: <20190303174806.7F97F10AE58@lists.varnish-cache.org> commit c556a9426deb7fe830ca53172ce8a639967828b7 Author: Geoff Simmons Date: Sun Mar 3 18:47:15 2019 +0100 Update "Changes" concerning VSL/VUT. diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index dc385ec67..834456722 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -70,12 +70,25 @@ VMODs Added the function :ref:`vmod_directors.lookup`, only for use in ``vcl_init`` or ``vcl_fini``. -varnishlog(1) and vsl(7) -======================== - -Timing information is now uniformly reported with microsecond -precision. This affects the tags ``ExpKill`` and ``ExpRearm`` -(previously with nanosecond precision). +varnishlog(1), varnishncsa(1) and vsl(7) +======================================== + +The performance of bundled log readers, including ``varnishlog`` and +``varnishncsa`` (and any tool using the internal VUT interface for +Varnish utilities) has been improved. They continue reading log +contents in bulk as long as more contents are known to be available, +not stopping as frequently (and unnecessarily) to check the status of +the shared memory mapping. + +``varnishlog`` and ``varnishncsa`` now have the ``-R`` command-line +option for rate-limiting, to limit the number of log transactions read +per unit time. This can make it less likely for log reads to fall +behind and fail with overrun errors under heavy loads. See +:ref:`varnishlog(1)` and :ref:`varnishncsa(1)` for details. + +Timing information is now uniformly reported in the log with +microsecond precision. This affects the tags ``ExpKill`` and +``ExpRearm`` (previously with nanosecond precision). varnishadm(1) and varnish-cli(7) ================================ From geoff at uplex.de Sun Mar 3 17:56:06 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 17:56:06 +0000 (UTC) Subject: [master] 7b2fe3270 Mention relaxed restrictions on UDS backend paths in "Changes". Message-ID: <20190303175606.7474E10C271@lists.varnish-cache.org> commit 7b2fe3270413f7e12c51ae1986f7723ea3b2b612 Author: Geoff Simmons Date: Sun Mar 3 18:54:35 2019 +0100 Mention relaxed restrictions on UDS backend paths in "Changes". diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index 834456722..00678f117 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -64,6 +64,15 @@ Added ``req.is_hitmiss`` and ``req.is_hitpass``, see :ref:`vcl(7)`. Other changes to VCL ~~~~~~~~~~~~~~~~~~~~ +When the ``.path`` field of a backend declaration is used to define a +Unix domain socket as the backend address, and the socket file does +not exist or is not accessible at VCL load time, then a warning is +issued, but the VCL load is allowed to continue. Previously, the load +would fail in that case. This makes it easier to start the peer +component listening at the socket, or set the socket's permissions, +after starting Varnish or loading VCL. If the socket still cannot be +accessed when a fetch is attempted, then the fetch fails. + VMODs ===== From geoff at uplex.de Sun Mar 3 18:30:10 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 18:30:10 +0000 (UTC) Subject: [master] ee0322f81 In "Changes", clarify that CLI JSON support has been extended. Message-ID: <20190303183010.5063710CC44@lists.varnish-cache.org> commit ee0322f81fad3f3e0c755c54420ffab2864ec712 Author: Geoff Simmons Date: Sun Mar 3 19:28:10 2019 +0100 In "Changes", clarify that CLI JSON support has been extended. It may have sounded like it's been added for the first time. diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index 00678f117..db6f963a1 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -115,6 +115,9 @@ the following commands (see :ref:`varnish-cli(7)`): * ``storage.list -j`` * ``panic.show -j`` +The ``-j`` option was already available for ``backend.list``, ``ping`` +and ``help`` in previous versions. + For automated parsing of CLI responses (``varnishadm`` output), we recommend the use of JSON format. From geoff at uplex.de Sun Mar 3 18:30:10 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 18:30:10 +0000 (UTC) Subject: [master] b309be935 Mention new VSC counters in "Changes". Message-ID: <20190303183010.71A2210CC47@lists.varnish-cache.org> commit b309be93524744ad1b90aa854270bd2025275785 Author: Geoff Simmons Date: Sun Mar 3 19:29:19 2019 +0100 Mention new VSC counters in "Changes". diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index db6f963a1..d2d28d8c9 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -186,10 +186,11 @@ whose keep parameter is greater than 3 hours, use this expression:: See :ref:`vcl(7)` and :ref:`users-guide-purging` for details. -varnishstat -=========== +varnishstat(1) and varnish-counters(7) +====================================== -**XXX changes concerning varnishstat(1) and/or varnish-counters(7)** +Added the ``ws_*_overflow`` and ``client_resp_500`` counters to better +diagnose workspace overflow issues, see :ref:`varnish-counters(7)`. varnishtest =========== From geoff at uplex.de Sun Mar 3 19:25:07 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 19:25:07 +0000 (UTC) Subject: [master] 7e913e545 Document debug:+vcl_keep and its use for varnishtest in "Changes". Message-ID: <20190303192507.19C3D10DD07@lists.varnish-cache.org> commit 7e913e545fe7b0a42ad57802a9ce77a04f646f2e Author: Geoff Simmons Date: Sun Mar 3 20:24:03 2019 +0100 Document debug:+vcl_keep and its use for varnishtest in "Changes". diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index d2d28d8c9..ec61ffc26 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -47,6 +47,11 @@ you must use these parameters: Added :ref:`ref_param_thread_pool_watchdog`, see above. +The :ref:`ref_param_debug` parameter now has a flag ``vcl_keep``. When +the flag is turned on, C sources and shared object libraries that were +generated from VCL sources are retained in the Varnish working +directory (see the notes about ``varnishtest`` below). + Other changes in varnishd ~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -195,7 +200,12 @@ diagnose workspace overflow issues, see :ref:`varnish-counters(7)`. varnishtest =========== -**XXX changes concerning varnishtest(1) and/or vtc(7)** +When :ref:`varnishtest(1)` is invoked with either of the ``-L`` or +``-l`` options to retain the temporary directory after tests, the +``vcl_keep`` flag for the :ref:`ref_param_debug` is switched on (see +`Parameters`_ above). This means that C sources and shared objects +generated from VCL can also be inspected after a test. By default, the +temporary directory is deleted after each test. Changes for developers and VMOD authors ======================================= From geoff at uplex.de Sun Mar 3 19:40:08 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 19:40:08 +0000 (UTC) Subject: [master] 0cbf691f2 Mention the change of varnishstat curses refresh in "Changes". Message-ID: <20190303194008.0A87E10E217@lists.varnish-cache.org> commit 0cbf691f21af3984c68522e3f1278d7e1d7bd91a Author: Geoff Simmons Date: Sun Mar 3 20:37:47 2019 +0100 Mention the change of varnishstat curses refresh in "Changes". diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index ec61ffc26..a94324cc8 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -197,6 +197,10 @@ varnishstat(1) and varnish-counters(7) Added the ``ws_*_overflow`` and ``client_resp_500`` counters to better diagnose workspace overflow issues, see :ref:`varnish-counters(7)`. +In curses mode, :ref:`varnishstat(1)` now allows use of the ``+`` and +``-`` keys to increase or decrease the refresh rate of the curses +window. + varnishtest =========== From geoff at uplex.de Sun Mar 3 20:20:07 2019 From: geoff at uplex.de (Geoff Simmons) Date: Sun, 3 Mar 2019 20:20:07 +0000 (UTC) Subject: [master] ea9d3f6a9 Start filling in the "Upgrading" socument for the March 2019 release. Message-ID: <20190303202007.47BCA10EE04@lists.varnish-cache.org> commit ea9d3f6a95cae8646faac9fd7f8772d148af79b7 Author: Geoff Simmons Date: Sun Mar 3 21:19:16 2019 +0100 Start filling in the "Upgrading" socument for the March 2019 release. diff --git a/doc/sphinx/whats-new/changes-trunk.rst b/doc/sphinx/whats-new/changes-trunk.rst index a94324cc8..04dc342a8 100644 --- a/doc/sphinx/whats-new/changes-trunk.rst +++ b/doc/sphinx/whats-new/changes-trunk.rst @@ -107,6 +107,8 @@ microsecond precision. This affects the tags ``ExpKill`` and varnishadm(1) and varnish-cli(7) ================================ +.. _whatsnew_changes_cli_json: + JSON output ~~~~~~~~~~~ @@ -132,6 +134,8 @@ recommend the use of JSON format. Added the command ``param.reset`` to reset a parameter's value to its default, see :ref:`varnish-cli(7)`. +.. _whatsnew_changes_vcl_list_backend_list: + Listing backends and VCLs ~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/doc/sphinx/whats-new/upgrading-trunk.rst b/doc/sphinx/whats-new/upgrading-trunk.rst index 6143fde99..e46362048 100644 --- a/doc/sphinx/whats-new/upgrading-trunk.rst +++ b/doc/sphinx/whats-new/upgrading-trunk.rst @@ -30,4 +30,45 @@ to:** * Changes in public APIs that may require changes in VMODs or VAPI/VUT clients. +VCL +=== + +VCL programs for Varnish 6.1 can be expected to run without changes in +the new version. + +A VCL load will now issue a warning, but does not fail as previously, +if a backend declaration uses the ``.path`` field to specify a Unix +domain socket, but the socket file does not exist or is not accessible +at VCL load time. This makes it possible to start the peer component +listening at the socket, or set its permissions, after Varnish starts +or the VCL is loaded. Backend fetches fail if the socket is not +accessible by the time the fetch is attempted. + +Runtime parameters +================== + +Some varnishd ``-p`` parameters that have been deprecated for some +time have been removed. If you haven't changed them yet, you have to +now. These are: + +* ``shm_reclen`` -- use :ref:`ref_param_vsl_reclen` instead + +* ``vcl_dir`` -- use :ref:`ref_param_vcl_path` instead + +* ``vmod_dir`` -- use :ref:`ref_param_vmod_path` instead + +varnishadm and the CLI +====================== + +The output formats of the ``vcl.list`` and ``backend.list`` commands +have changed, see :ref:`whatsnew_changes_vcl_list_backend_list` and +:ref:`varnish-cli(7)` for details. In non-JSON mode, the width of +columns in ``backend.list`` and ``vcl.list`` output is now dynamic, to +fit the width of the terminal window. + +The ``-j`` option for JSON output has been added to a number of +commands, see :ref:`whatsnew_changes_cli_json` and +:ref:`varnish-cli(7)`. We recommend the use of JSON format for +automated parsing of CLI responses (:ref:`varnishadm(1)` output). + *eof* From phk at FreeBSD.org Mon Mar 4 09:40:08 2019 From: phk at FreeBSD.org (Poul-Henning Kamp) Date: Mon, 4 Mar 2019 09:40:08 +0000 (UTC) Subject: [master] 141ea56a4 Add the VCF - aka "The CatFlap" Message-ID: <20190304094008.B40DC7F9B@lists.varnish-cache.org> commit 141ea56a43459d2c1b29d2a299ff9b67356228c6 Author: Poul-Henning Kamp Date: Mon Mar 4 09:37:24 2019 +0000 Add the VCF - aka "The CatFlap" I have reimplemented this based on Nils's #2858, because I found it too complex and intrusive. (In particular we try to avoid unions in Varnish). Testcase m00051 by: Nils Goroll Closes: #2858 diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h index 2018c9bce..163c52948 100644 --- a/bin/varnishd/cache/cache.h +++ b/bin/varnishd/cache/cache.h @@ -101,6 +101,7 @@ struct sess; struct transport; struct worker; struct listen_sock; +struct vcf; #define DIGEST_LEN 32 @@ -530,6 +531,8 @@ struct req { struct acct_req acct; struct vrt_privs privs[1]; + + struct vcf *vcf; }; #define IS_TOPREQ(req) ((req)->topreq == (req)) diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c index e9b8466d9..a778bf535 100644 --- a/bin/varnishd/cache/cache_hash.c +++ b/bin/varnishd/cache/cache_hash.c @@ -81,6 +81,15 @@ static int hsh_deref_objhead_unlock(struct worker *wrk, struct objhead **poh); /*---------------------------------------------------------------------*/ +#define VCF_RETURN(x) const struct vcf_return VCF_##x[1] = { \ + { .name = #x, } \ +}; + +VCF_RETURNS() +#undef VCF_RETURN + +/*---------------------------------------------------------------------*/ + static struct objhead * hsh_newobjhead(void) { @@ -344,6 +353,7 @@ HSH_Lookup(struct req *req, struct objcore **ocp, struct objcore **bocp) struct objhead *oh; struct objcore *oc; struct objcore *exp_oc; + const struct vcf_return *vr; vtim_real exp_t_origin; int busy_found; const uint8_t *vary; @@ -359,6 +369,7 @@ HSH_Lookup(struct req *req, struct objcore **ocp, struct objcore **bocp) wrk = req->wrk; CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); CHECK_OBJ_NOTNULL(req->http, HTTP_MAGIC); + CHECK_OBJ_ORNULL(req->vcf, VCF_MAGIC); AN(hash); hsh_prealloc(wrk); @@ -436,6 +447,19 @@ HSH_Lookup(struct req *req, struct objcore **ocp, struct objcore **bocp) continue; } + if (req->vcf != NULL) { + vr = req->vcf->func(req, &oc, &exp_oc, 0); + if (vr == VCF_CONTINUE) + continue; + if (vr == VCF_MISS) { + oc = NULL; + break; + } + if (vr == VCF_HIT) + break; + assert(vr == VCF_DEFAULT); + } + if (EXP_Ttl(req, oc) > req->t_req) { assert(oh->refcnt > 1); assert(oc->objhead == oh); @@ -452,6 +476,9 @@ HSH_Lookup(struct req *req, struct objcore **ocp, struct objcore **bocp) } } + if (req->vcf != NULL) + (void)req->vcf->func(req, &oc, &exp_oc, 1); + if (oc != NULL && oc->flags & OC_F_HFP) { xid = ObjGetXID(wrk, oc); dttl = EXP_Dttl(req, oc); diff --git a/bin/varnishd/cache/cache_req_fsm.c b/bin/varnishd/cache/cache_req_fsm.c index 1768efee1..1bd7911ee 100644 --- a/bin/varnishd/cache/cache_req_fsm.c +++ b/bin/varnishd/cache/cache_req_fsm.c @@ -490,6 +490,11 @@ cnt_lookup(struct worker *wrk, struct req *req) if (had_objhead) VSLb_ts_req(req, "Waitinglist", W_TIM_real(wrk)); + if (req->vcf != NULL) { + (void)req->vcf->func(req, NULL, NULL, 2); + req->vcf = NULL; + } + if (busy == NULL) { VRY_Finish(req, DISCARD); } else { diff --git a/bin/varnishd/cache/cache_varnishd.h b/bin/varnishd/cache/cache_varnishd.h index 2aab94ab7..a117d8b8d 100644 --- a/bin/varnishd/cache/cache_varnishd.h +++ b/bin/varnishd/cache/cache_varnishd.h @@ -85,6 +85,37 @@ typedef enum htc_status_e htc_complete_f(struct http_conn *); extern volatile struct params * cache_param; +/* ------------------------------------------------------------------- + * The VCF facility is deliberately undocumented, use at your peril. + */ + +struct vcf_return { + const char *name; +}; + +#define VCF_RETURNS() \ + VCF_RETURN(CONTINUE) \ + VCF_RETURN(DEFAULT) \ + VCF_RETURN(MISS) \ + VCF_RETURN(HIT) + +#define VCF_RETURN(x) extern const struct vcf_return VCF_##x[1]; +VCF_RETURNS() +#undef VCF_RETURN + +typedef const struct vcf_return *vcf_func_f( + struct req *req, + struct objcore **oc, + struct objcore **oc_exp, + int state); + +struct vcf { + unsigned magic; +#define VCF_MAGIC 0x183285d1 + vcf_func_f *func; + void *priv; +}; + /* Prototypes etc ----------------------------------------------------*/ /* cache_acceptor.c */ diff --git a/bin/varnishd/flint.lnt b/bin/varnishd/flint.lnt index 42a40290f..5a1942528 100644 --- a/bin/varnishd/flint.lnt +++ b/bin/varnishd/flint.lnt @@ -39,6 +39,7 @@ -esym(765, vrt_magic_string_end) -esym(759, vrt_magic_string_end) -esym(768, vrt_ref::*) +-esym(768, vcf_return::name) -esym(768, VCL_conf::*) // FLINT Bug20090910_838 diff --git a/bin/varnishtest/tests/m00051.vtc b/bin/varnishtest/tests/m00051.vtc new file mode 100644 index 000000000..a5231894a --- /dev/null +++ b/bin/varnishtest/tests/m00051.vtc @@ -0,0 +1,54 @@ +varnishtest "catflap" + +varnish v1 -vcl { + import debug; + + backend dummy { .host = "${bad_backend}"; } + + sub vcl_recv { + if (req.http.id) { + debug.catflap(miss); + } else if (req.http.get == "first") { + debug.catflap(first); + } else if (req.http.get == "last") { + debug.catflap(last); + } else { + return (fail); + } + return (hash); + } + + sub vcl_backend_error { + if (! bereq.http.id) { + return (deliver); + } + set beresp.status = 200; + set beresp.ttl = 1s; + set beresp.grace = 1m; + set beresp.http.id = bereq.http.id; + } +} -start + +client c1 { + txreq -hdr "id: 1" + rxresp + expect resp.status == 200 + txreq -hdr "id: 2" + rxresp + expect resp.status == 200 + txreq -hdr "id: 3" + rxresp + expect resp.status == 200 + + # the first object is the one which went into cache last + + txreq -hdr "get: first" + rxresp + expect resp.status == 200 + expect resp.http.id == "3" + + txreq -hdr "get: last" + rxresp + expect resp.status == 200 + expect resp.http.id == "1" +} -run diff --git a/doc/sphinx/reference/vtla.rst b/doc/sphinx/reference/vtla.rst index 1fdfb4abf..76dccd068 100644 --- a/doc/sphinx/reference/vtla.rst +++ b/doc/sphinx/reference/vtla.rst @@ -31,6 +31,9 @@ VCA VCC VCL to C Compiler -- The code that compiles VCL to C code. (lib/libvcl) +VCF + Varnish CatFlap + VCL Varnish Configuration Language -- The domain-specific programming language used for configuring a varnishd. diff --git a/lib/libvmod_debug/vmod.vcc b/lib/libvmod_debug/vmod.vcc index 2ff1d0220..4c5f652eb 100644 --- a/lib/libvmod_debug/vmod.vcc +++ b/lib/libvmod_debug/vmod.vcc @@ -230,3 +230,7 @@ $Method STRING .meth_opt(PRIV_CALL, PRIV_VCL, PRIV_TASK, Test object method with all the fancy stuff. $Function STRANDS return_strands(STRANDS strand) + +$Function VOID catflap(ENUM {miss, first, last} type) + +Test the HSH_Lookup catflap diff --git a/lib/libvmod_debug/vmod_debug.c b/lib/libvmod_debug/vmod_debug.c index fa05142b6..7161596ae 100644 --- a/lib/libvmod_debug/vmod_debug.c +++ b/lib/libvmod_debug/vmod_debug.c @@ -630,3 +630,72 @@ xyzzy_return_strands(VRT_CTX, VCL_STRANDS strand) CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); return (strand); } + +/*---------------------------------------------------------------------*/ + +static const struct vcf_return * v_matchproto_(vcf_func_f) +xyzzy_catflap_simple(struct req *req, struct objcore **oc, + struct objcore **oc_exp, int state) +{ + + CHECK_OBJ_NOTNULL(req, REQ_MAGIC); + CHECK_OBJ_NOTNULL(req->vcf, VCF_MAGIC); + assert(req->vcf->func == xyzzy_catflap_simple); + + (void)oc; + (void)oc_exp; + if (state == 0) { + if (req->vcf->priv == VENUM(first)) + return (VCF_HIT); + if (req->vcf->priv == VENUM(miss)) + return (VCF_MISS); + WRONG("Shouldn't get here"); + } + return (VCF_DEFAULT); +} + +static const struct vcf_return * v_matchproto_(vcf_func_f) +xyzzy_catflap_last(struct req *req, struct objcore **oc, + struct objcore **oc_exp, int state) +{ + + CHECK_OBJ_NOTNULL(req, REQ_MAGIC); + CHECK_OBJ_NOTNULL(req->vcf, VCF_MAGIC); + assert(req->vcf->func == xyzzy_catflap_last); + + (void)oc_exp; + if (state == 0) { + AN(oc); + CHECK_OBJ_NOTNULL(*oc, OBJCORE_MAGIC); + req->vcf->priv = *oc; + return (VCF_CONTINUE); + } + if (state == 1) { + AN(oc); + if (req->vcf->priv != NULL) + CAST_OBJ_NOTNULL(*oc, req->vcf->priv, OBJCORE_MAGIC); + return (VCF_CONTINUE); + } + return (VCF_DEFAULT); +} + +VCL_VOID +xyzzy_catflap(VRT_CTX, VCL_ENUM type) +{ + struct req *req; + + CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); + req = ctx->req; + CHECK_OBJ_NOTNULL(req, REQ_MAGIC); + XXXAZ(req->vcf); + req->vcf = WS_Alloc(req->ws, sizeof *req->vcf); + INIT_OBJ(req->vcf, VCF_MAGIC); + if (type == VENUM(first) || type == VENUM(miss)) { + req->vcf->func = xyzzy_catflap_simple; + req->vcf->priv = TRUST_ME(type); + } else if (type == VENUM(last)) { + req->vcf->func = xyzzy_catflap_last; + } else { + WRONG("Wrong VENUM"); + } +} From nils.goroll at uplex.de Mon Mar 4 13:01:08 2019 From: nils.goroll at uplex.de (Nils Goroll) Date: Mon, 4 Mar 2019 13:01:08 +0000 (UTC) Subject: [master] 5a1a9b089 make vmod_std conversions more flexible Message-ID: <20190304130108.367B1634F7@lists.varnish-cache.org> commit 5a1a9b0894667b9b1bcf8671b26690ee9a78001f Author: Nils Goroll Date: Wed Feb 27 18:42:28 2019 +0100 make vmod_std conversions more flexible In order to avoid the cross product problem with conversion functions (from x to y types would require x*y functions), we add flexibility regarding the input parameters to conversion functions: Each convertion function named after the destination type now takes all sensible arguments by name. int is named integer because of the reserved symbol name "int" in C. All functions should be fully backwards compatible (existing vtcs continue to work), but compile time checks are now effectively removed. The conversion functions now trigger vcl errors if used incorrectly or if conversion errors occur and no failback is provided. However, if a failback is provided, vcl errors are only raised for usage errors. For consistency, the conversion functions now only ever truncate if necessary. std.round() is added for explicit rounding where required. Existing functions which are now obsolete are marked deprecated. Ref #2899 Ref https://github.com/varnishcache/varnish-cache/wiki/VIP12:-vmod-polymorphism-(for-type-conversions) diff --git a/bin/varnishtest/tests/m00005.vtc b/bin/varnishtest/tests/m00005.vtc index 9ce01bf42..253f49584 100644 --- a/bin/varnishtest/tests/m00005.vtc +++ b/bin/varnishtest/tests/m00005.vtc @@ -9,8 +9,36 @@ varnish v1 -vcl+backend { import std; sub vcl_deliver { - set resp.http.duration = std.duration(req.http.duration, 1s) + 1000000s; - set resp.http.bytes = std.bytes(req.http.bytes, 10K) + 512B; + if (req.http.d-real) { + set resp.http.duration = + std.duration(real=std.real(req.http.d-real)) + + 1000000s; + } else if (req.http.d-int) { + set resp.http.duration = + std.duration(integer=std.integer(req.http.d-int)) + + 1000000s; + } else if (req.http.duration-nf) { + set resp.http.duration = + std.duration(req.http.duration) + 1000000s; + } else { + set resp.http.duration = + std.duration(req.http.duration, 1s) + 1000000s; + } + if (req.http.b-real) { + set resp.http.bytes = + std.bytes(real=std.real(req.http.b-real)) + + 512B; + } else if (req.http.b-int) { + set resp.http.bytes = + std.bytes(integer=std.integer(req.http.b-int)) + + 512B; + } else if (req.http.bytes-nf) { + set resp.http.bytes = std.bytes(req.http.bytes-nf) + + 512B; + } else { + set resp.http.bytes = std.bytes(req.http.bytes, 10K) + + 512B; + } } } -start @@ -82,4 +110,100 @@ client c1 { txreq -hdr "duration: 100" rxresp expect resp.http.duration == 1000001.000 + + # --- + + txreq -hdr "d-real: 0.010" -hdr "b-real: 2048.99999" + rxresp + expect resp.http.duration == 1000000.010 + expect resp.http.bytes == 2560.000 + + txreq -hdr "d-real: 10.1" -hdr "b-real: 3145728.9" + rxresp + expect resp.http.duration == 1000010.100 + expect resp.http.bytes == 3146240.000 + + txreq -hdr "d-real: 600" -hdr "b-real: 4831838208.123" + rxresp + expect resp.http.duration == 1000600.000 + expect resp.http.bytes == 4831838720.000 + + txreq -hdr "d-real: 36000" -hdr "b-real: 131941395333.12" + rxresp + expect resp.http.duration == 1036000.000 + expect resp.http.bytes == 131941395845.000 + + txreq -hdr "d-real: -100" + rxresp + expect resp.http.duration == 999900.000 + + txreq -hdr "d-real: -inf" + rxresp + expect resp.status == 503 +} -run + +client c1 { + txreq -hdr "d-int: 600" -hdr "b-int: 4831838208" + rxresp + expect resp.http.duration == 1000600.000 + expect resp.http.bytes == 4831838720.000 + + txreq -hdr "d-int: 36000" -hdr "b-int: 131941395333" + rxresp + expect resp.http.duration == 1036000.000 + expect resp.http.bytes == 131941395845.000 + + txreq -hdr "d-int: -100" + rxresp + expect resp.http.duration == 999900.000 + + txreq -hdr "d-int: x" + rxresp + expect resp.status == 503 +} -run + +client c1 { + txreq -hdr "duration-nf: s" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "duration-nf: 3wx" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "duration-nf: -inf" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "duration-nf: 2x" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "duration-nf: 2h x" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "duration-nf: 100" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "bytes-nf: x" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "b-real: x" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "b-int: x" + rxresp + expect resp.status == 503 } -run diff --git a/bin/varnishtest/tests/m00007.vtc b/bin/varnishtest/tests/m00007.vtc index b66fc0b98..51840f5dd 100644 --- a/bin/varnishtest/tests/m00007.vtc +++ b/bin/varnishtest/tests/m00007.vtc @@ -13,16 +13,57 @@ varnish v1 -vcl+backend { set resp.http.ltzero = (std.integer(req.http.foo, 0) < 0); set resp.http.iszero = (std.integer(req.http.foo, 0) == 0); set resp.http.converted = std.integer(req.http.foo, 0); + + if (req.http.nofb) { + set resp.http.nofb = std.integer(req.http.foo); + } + + if (req.http.bool) { + set resp.http.bool = + std.integer(bool=req.http.bool != ""); + } + if (req.http.bytes) { + set resp.http.bytes = + std.integer(bytes=std.bytes(req.http.bytes)); + } + if (req.http.duration) { + set resp.http.duration = + std.integer(duration=std.duration(req.http.duration)); + } + if (req.http.real) { + set resp.http.real = + std.integer(real=std.real(req.http.real)); + } + if (req.http.time) { + set resp.http.time = + std.integer(time=std.time(req.http.time)); + } + if (req.http.err1) { + set resp.http.time = std.integer(); + } + if (req.http.err2) { + set resp.http.time = std.integer(real=1.0, bool=true); + } } } -start client c1 { - txreq -hdr "foo: 1" + txreq -hdr "foo: 1" \ + -hdr "bool: whatever" \ + -hdr "bytes: 1b" \ + -hdr "duration: 1s" \ + -hdr "real: 1.9" \ + -hdr "time: Thu, 01 Jan 1970 00:00:01 GMT" rxresp expect resp.http.gtzero == true expect resp.http.ltzero == false expect resp.http.iszero == false expect resp.http.converted == 1 + expect resp.http.bool == 1 + expect resp.http.duration == 1 + expect resp.http.bytes == 1 + expect resp.http.real == 1 + expect resp.http.time == 1 txreq -hdr "foo: -1" rxresp @@ -38,10 +79,71 @@ client c1 { expect resp.http.iszero == true expect resp.http.converted == 0 + # VCL_INT_MAX + txreq -hdr "foo: 9007199254740991" \ + -hdr "bytes: 9007199254740991b" \ + -hdr "duration: 9007199254740991s" \ + -hdr "real: 9007199254740991" \ + -hdr "time: 9007199254740991" + rxresp + expect resp.http.gtzero == true + expect resp.http.ltzero == false + expect resp.http.iszero == false + expect resp.http.converted == 9007199254740991 + expect resp.http.bytes == 9007199254740991 + expect resp.http.duration == 9007199254740991 + expect resp.http.real == 9007199254740991 + expect resp.http.time == 9007199254740991 + + # VCL_INT_MIN + txreq -hdr "foo: -9007199254740991" \ + -hdr "duration: -9007199254740991s" \ + -hdr "real: -9007199254740991" + rxresp + expect resp.http.gtzero == false + expect resp.http.ltzero == true + expect resp.http.iszero == false + expect resp.http.converted == -9007199254740991 + expect resp.http.duration == -9007199254740991 + expect resp.http.real == -9007199254740991 + txreq -hdr "foo: bar" rxresp expect resp.http.gtzero == false expect resp.http.ltzero == false expect resp.http.iszero == true expect resp.http.converted == 0 + + txreq -hdr "foo: 9007199254740992" + rxresp + expect resp.http.converted == 0 + + txreq -hdr "foo: -9007199254740992" + rxresp + expect resp.http.converted == 0 +} -run +client c1 { + txreq -hdr "nofb: 9007199254740992" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "nofb: -9007199254740992" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "nofb: x" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "err1: 1" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "err2: 1" + rxresp + expect resp.status == 503 } -run diff --git a/bin/varnishtest/tests/m00015.vtc b/bin/varnishtest/tests/m00015.vtc index 1845fa7ce..3e7974958 100644 --- a/bin/varnishtest/tests/m00015.vtc +++ b/bin/varnishtest/tests/m00015.vtc @@ -1,4 +1,4 @@ -varnishtest "Test vmod_std.real conversion" +varnishtest "Test std.real() conversion and std.round" server s1 { rxreq @@ -17,6 +17,8 @@ varnish v1 -vcl+backend { set resp.http.t5 = std.real("1.0 ", 0.0); set resp.http.t6 = std.real(" 1.0", 0.0); set resp.http.t7 = std.real(" 1.0 ", 0.0); + set resp.http.t8 = std.round(42.42); + set resp.http.t9 = std.round(-42.42); } } -start @@ -32,4 +34,112 @@ client c1 { expect resp.http.t5 == 1.000 expect resp.http.t6 == 1.000 expect resp.http.t7 == 1.000 + expect resp.http.t8 == 42.000 + expect resp.http.t9 == -42.000 +} -run + +varnish v1 -vcl+backend { + import std; + + sub vcl_deliver { + set resp.http.converted = std.real(req.http.foo, 0); + + if (req.http.nofb) { + set resp.http.nofb = std.real(req.http.foo); + } + + if (req.http.bool) { + set resp.http.bool = + std.real(bool=req.http.bool != ""); + } + if (req.http.bytes) { + set resp.http.bytes = + std.real(bytes=std.bytes(req.http.bytes)); + } + if (req.http.duration) { + set resp.http.duration = + std.real(duration=std.duration(req.http.duration)); + } + if (req.http.integer) { + set resp.http.integer = + std.real(integer=std.integer(req.http.integer)); + } + if (req.http.time) { + set resp.http.time = + std.real(time=std.time(req.http.time)); + } + } +} + +client c1 { + txreq -hdr "foo: 1" \ + -hdr "bool: whatever" \ + -hdr "bytes: 1b" \ + -hdr "duration: 1s" \ + -hdr "integer: 1" \ + -hdr "time: Thu, 01 Jan 1970 00:00:01 GMT" + rxresp + expect resp.http.converted == 1.000 + expect resp.http.bool == 1.000 + expect resp.http.duration == 1.000 + expect resp.http.bytes == 1.000 + expect resp.http.integer == 1.000 + expect resp.http.time == 1.000 + + txreq -hdr "foo: -1" + rxresp + expect resp.http.converted == -1.000 + + txreq -hdr "foo: 0" + rxresp + expect resp.http.converted == 0.000 + + # VCL_INT_MAX + txreq -hdr "foo: 9007199254740991" \ + -hdr "bytes: 9007199254740991b" \ + -hdr "duration: 9007199254740991s" \ + -hdr "integer: 9007199254740991" \ + -hdr "time: 9007199254740991" + rxresp + expect resp.http.converted == 9007199254740991.000 + expect resp.http.bytes == 9007199254740991.000 + expect resp.http.duration == 9007199254740991.000 + expect resp.http.integer == 9007199254740991.000 + expect resp.http.time == 9007199254740991.000 + + # VCL_INT_MIN + txreq -hdr "foo: -9007199254740991" \ + -hdr "duration: -9007199254740991s" \ + -hdr "integer: -9007199254740991" + rxresp + expect resp.http.converted == -9007199254740991.000 + expect resp.http.duration == -9007199254740991.000 + expect resp.http.integer == -9007199254740991.000 + + txreq -hdr "foo: bar" + rxresp + expect resp.http.converted == 0.000 + + txreq -hdr "foo: 9007199254740992" + rxresp + expect resp.http.converted == 9007199254740992.000 + + txreq -hdr "foo: -9007199254740992" + rxresp + expect resp.http.converted == -9007199254740992.000 +} -run +client c1 { + txreq -hdr "nofb: NAN" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "nofb: -INF" + rxresp + expect resp.status == 503 +} -run +client c1 { + txreq -hdr "nofb: x" + rxresp + expect resp.status == 503 } -run diff --git a/bin/varnishtest/tests/m00020.vtc b/bin/varnishtest/tests/m00020.vtc index eb2eb0f5b..fd61e11fb 100644 --- a/bin/varnishtest/tests/m00020.vtc +++ b/bin/varnishtest/tests/m00020.vtc @@ -17,47 +17,74 @@ varnish v1 -vcl+backend { if (std.time(req.http.x-date, now) > now + 1y) { set resp.http.x-future = 1; } + if (req.http.real) { + if (resp.http.x-date != "" + + std.time(real=std.real(req.http.real))) { + return(synth(503)); + } + } + if (req.http.integer) { + if (resp.http.x-date != "" + + std.time(integer=std.integer(req.http.integer))) { + return(synth(503)); + } + } } } -start client c1 { - txreq -hdr "X-Date: Mon, 20 Dec 2010 00:00:00 GMT" + txreq -hdr "X-Date: Mon, 20 Dec 2010 00:00:00 GMT" \ + -hdr "real: 1292803200.0" \ + -hdr "integer: 1292803200" rxresp + expect resp.status == 200 expect resp.http.x-past == 1 expect resp.http.x-date == "Mon, 20 Dec 2010 00:00:00 GMT" - txreq -hdr "X-Date: Monday, 20-Dec-30 00:00:00 GMT" + # invalid date + txreq -hdr "X-Date: Monday, 20-Dec-30 00:00:00 GMT" \ + -hdr "real: 1923955200.0" \ + -hdr "integer: 1923955200" rxresp + expect resp.status == 503 expect resp.http.x-past == expect resp.http.x-future == txreq -hdr "X-Date: Monday, 30-Feb-15 00:00:00 GMT" rxresp + expect resp.status == 200 expect resp.http.x-past == expect resp.http.x-future == - txreq -hdr "X-Date: Friday, 20-Dec-30 00:00:00 GMT" + txreq -hdr "X-Date: Friday, 20-Dec-30 00:00:00 GMT" \ + -hdr "real: 1923955200.0" \ + -hdr "integer: 1923955200" rxresp + expect resp.status == 200 expect resp.http.x-future == 1 expect resp.http.x-date == "Fri, 20 Dec 2030 00:00:00 GMT" txreq -hdr "X-Date: Mon Dec 20 00:00:00 2010" rxresp + expect resp.status == 200 expect resp.http.x-past == 1 expect resp.http.x-date == "Mon, 20 Dec 2010 00:00:00 GMT" txreq -hdr "X-Date: 2030-12-20T00:00:00" rxresp + expect resp.status == 200 expect resp.http.x-future == 1 expect resp.http.x-date == "Fri, 20 Dec 2030 00:00:00 GMT" txreq -hdr "X-Date: 1292803200.00" rxresp + expect resp.status == 200 expect resp.http.x-past == 1 expect resp.http.x-date == "Mon, 20 Dec 2010 00:00:00 GMT" txreq -hdr "X-Date: 1923955200" rxresp + expect resp.status == 200 expect resp.http.x-future == 1 expect resp.http.x-date == "Fri, 20 Dec 2030 00:00:00 GMT" @@ -68,66 +95,79 @@ client c1 { # leapsecond txreq -hdr "X-Date: Mon, 20 Dec 2010 00:00:60 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date == "Mon, 20 Dec 2010 00:00:59 GMT" delay .1 # Range tests txreq -hdr "X-Date: Mon, 20 Dec 2010 00:00:61 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date != "Mon, 20 Dec 2010 00:00:61 GMT" delay .1 txreq -hdr "X-Date: Mon, 20 Dec 2010 00:60:00 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date != "Mon, 20 Dec 2010 00:60:00 GMT" delay .1 txreq -hdr "X-Date: Mon, 20 Dec 2010 24:00:00 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date != "Mon, 20 Dec 2010 24:00:00 GMT" delay .1 txreq -hdr "X-Date: Tue, 20 Dec 2010 00:00:00 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date != "Tue, 20 Dec 2010 00:00:00 GMT" delay .1 txreq -hdr "X-Date: Mon, 29 Feb 2010 00:00:00 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date != "Mon, 29 Feb 2010 00:00:00 GMT" delay .1 txreq -hdr "X-Date: Wed, 29 Feb 2012 00:00:00 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date == "Wed, 29 Feb 2012 00:00:00 GMT" delay .1 txreq -hdr "X-Date: 2010-13-20T00:00:00" rxresp + expect resp.status == 200 delay .1 txreq -hdr "X-Date: Sun 31 Dec 1899 23:59:59 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date != "Sun 31 Dec 1899 23:59:59 GMT" delay .1 # White space etc. txreq -hdr "X-Date: z Wed, 29 Feb 2012 00:00:00 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date == "Wed, 29 Feb 2012 00:00:00 GMT" delay .1 txreq -hdr "X-Date: Wedx 29 Feb 2012 00:00:00 GMT" rxresp + expect resp.status == 200 expect resp.http.x-date != "Wed, 29 Feb 2012 00:00:00 GMT" delay .1 txreq -hdr "X-Date: Wed, 29 Feb 2012 00:00:00 GMT x" rxresp + expect resp.status == 200 expect resp.http.x-date != "Wed, 29 Feb 2012 00:00:00 GMT" delay .1 txreq rxresp + expect resp.status == 200 expect resp.http.x-date != } -run diff --git a/lib/libvmod_std/vmod.vcc b/lib/libvmod_std/vmod.vcc index b3d994618..bf2396c21 100644 --- a/lib/libvmod_std/vmod.vcc +++ b/lib/libvmod_std/vmod.vcc @@ -157,38 +157,96 @@ Examples:: std.collect(req.http.accept); std.collect(req.http.cookie, "; "); -$Function DURATION duration(STRING s, DURATION fallback) +$Function DURATION duration([STRING s], [DURATION fallback], + [REAL real], [INT integer]) -Converts the string *s* to seconds. *s* must be quantified with ``ms`` -(milliseconds), ``s`` (seconds), ``m`` (minutes), ``h`` (hours), ``d`` -(days), ``w`` (weeks) or ``y`` (years) units. If conversion fails, -*fallback* will be returned. +Returns a DURATION from a STRING, REAL or INT argument. -Example:: +For a STRING *s* argument, *s* must be quantified by ``ms`` +(milliseconds), ``s`` (seconds), ``m`` (minutes), ``h`` (hours),``d`` +(days), ``w`` (weeks) or ``y`` (years) units. + +*real* and *integer* arguments are taken as seconds. + +If the conversion of an *s* argument fails, *fallback* will be +returned if provided, or a VCL failure will be triggered. +Conversions from *real* and *integer* arguments never fail. + +Only one of the *s*, *real* or *integer* arguments may be given or a VCL +failure will be triggered. + +Examples:: set beresp.ttl = std.duration("1w", 3600s); + set beresp.ttl = std.duration(real=1.5); + set beresp.ttl = std.duration(integer=10); -$Function BYTES bytes(STRING s, BYTES fallback) +$Function BYTES bytes([STRING s], [BYTES fallback], [REAL real], [INT integer]) -Converts the string *s* to bytes. *s* can be quantified with a -multiplier (``k``, ``m``, ``g``, ``t``, ``p``). If conversion fails, -*fallback* will be returned. +Returns BYTES from a STRING, REAL or INT argument. -Example:: +A STRING *s* argument can be quantified with a multiplier (``k`` +(kilo), ``m`` (mega), ``g`` (giga), ``t`` (tera) or ``p`` (peta)). - std.cache_req_body(std.bytes(something.somewhere, 10K)); +*real* and *integer* arguments are taken as bytes. + +If the conversion of an *s* argument fails, *fallback* will be +returned if provided, or a VCL failure will be triggered. -$Function INT integer(STRING s, INT fallback) +Other conversions may fail if the argument can not be represented, +because it is negative, too small or too large. Again, *fallback* will +be returned if provided, or a VCL failure will be triggered. -Converts the string *s* to an integer. If conversion fails, *fallback* -will be returned. +*real* arguments will be rounded down. + +Only one of the *s*, *real* or *integer* arguments may be given or a VCL +failure will be triggered. Example:: + std.cache_req_body(std.bytes(something.somewhere, 10K)); + std.cache_req_body(std.bytes(integer=10*1024)); + std.cache_req_body(std.bytes(real=10.0*1024)); + +$Function INT integer([STRING s], [INT fallback], + [BOOL bool], [BYTES bytes], [DURATION duration], [REAL real], + [TIME time]) + +Returns an INT from a STRING, BOOL or other quantity. + +If the conversion of an *s* argument fails, *fallback* will be +returned if provided, or a VCL failure will be triggered. + +A *bool* argument will be returned as 0 for ``false`` and 1 for +``true``. This conversion will never fail. + +For a *bytes* argument, the number of bytes will be returned. This +conversion will never fail. + +A *duration* argument will be rounded down to the number of seconds +and returned. + +A *real* argument will be rounded down and returned. + +For a *time* argument, the number of seconds since the UNIX epoch +(1970-01-01 00:00:00 UTC) will be returned. + +*duration*, *real* and *time* conversions may fail if the argument can +not be represented because it is too small or too large. If so, +*fallback* will be returned if provided, or a VCL failure will be +triggered. + +Only one of the *s*, *bool*, *bytes*, *duration*, *real* or *time* +arguments may be given or a VCL failure will be triggered. + +Examples:: if (std.integer(req.http.foo, 0) > 5) { ... } + set resp.http.answer = std.integer(real=126.42/3); + + $Function IP ip(STRING s, IP fallback, BOOL resolve = 1) Converts the string *s* to the first IP number returned by @@ -205,10 +263,31 @@ Example:: ... } -$Function REAL real(STRING s, REAL fallback) +$Function REAL real([STRING s], [REAL fallback], [INT integer], + [BOOL bool], [BYTES bytes], [DURATION duration], + [TIME time]) -Converts the string *s* to a real. If conversion fails, *fallback* -will be returned. +Returns a REAL from a STRING, BOOL or other quantity. + +If the conversion of an *s* argument fails, *fallback* will be +returned if provided, or a VCL failure will be triggered. + +A *bool* argument will be returned as 0.0 for ``false`` and 1.0 for +``true``. + +For a *bytes* argument, the number of bytes will be returned. + +For a *duration* argument, the number of seconds will be returned. + +An *integer* argument will be returned as a REAL. + +For a *time* argument, the number of seconds since the UNIX epoch +(1970-01-01 00:00:00 UTC) will be returned. + +None of these conversions other than *s* will fail. + +Only one of the *s*, *integer*, *bool*, *bytes*, *duration* or *time* +arguments may be given or a VCL failure will be triggered. Example:: @@ -216,8 +295,19 @@ Example:: ... } +$Function REAL round(REAL r) + +Rounds the real *r* to the nearest integer, but round halfway cases +away from zero (see `round(3)`). + $Function INT real2integer(REAL r, INT fallback) +**DEPRECATED**: This function will be removed in a future version of +varnish, use `vmod_std.integer`_ with a *real* argument and the +`vmod_std.round`_ function instead, for example:: + + std.integer(real=std.round(...), fallback=...) + Rounds the real *r* to the nearest integer, but round halfway cases away from zero (see `round(3)`). If conversion fails, *fallback* will be returned. @@ -230,6 +320,12 @@ Examples:: $Function TIME real2time(REAL r, TIME fallback) +**DEPRECATED**: This function will be removed in a future version of +varnish, use `vmod_std.time`_ with a *real* argument and the +`vmod_std.round`_ function instead, for example:: + + std.time(real=std.round(...), fallback=...) + Rounds the real *r* to the nearest integer (see `vmod_std.real2integer`_) and returns the corresponding time when interpreted as a unix epoch. If conversion fails, *fallback* will be @@ -241,6 +337,12 @@ Example:: $Function INT time2integer(TIME t, INT fallback) +**DEPRECATED**: This function will be removed in a future version of +varnish, use `vmod_std.integer`_ with a *time* argument instead, for +example:: + + std.integer(time=..., fallback=...) + Converts the time *t* to a integer. If conversion fails, *fallback* will be returned. @@ -250,6 +352,12 @@ Example:: $Function REAL time2real(TIME t, REAL fallback) +**DEPRECATED**: This function will be removed in a future version of +varnish, use `vmod_std.real`_ with a *time* argument instead, for +example:: + + std.real(time=..., fallback=...) + Converts the time *t* to a real. If conversion fails, *fallback* will be returned. @@ -325,12 +433,11 @@ Example:: This will check if the content of ``req.http.restrict`` occurs anywhere in ``req.url``. -$Function TIME time(STRING s, TIME fallback) +$Function TIME time([STRING s], [TIME fallback], [REAL real], [INT integer]) -Converts the string *s* to a time. If conversion fails, *fallback* -will be returned. +Returns a TIME from a STRING, REAL or INT argument. -Supported formats:: +For a STRING *s* argument, the following formats are supported:: "Sun, 06 Nov 1994 08:49:37 GMT" "Sunday, 06-Nov-94 08:49:37 GMT" @@ -339,12 +446,22 @@ Supported formats:: "784111777.00" "784111777" -Example:: +*real* and *integer* arguments are taken as seconds since the epoch. + +If the conversion of an *s* argument fails or a negative *real* or +*integer* argument is given, *fallback* will be returned if provided, +or a VCL failure will be triggered. + +Examples:: if (std.time(resp.http.last-modified, now) < now - 1w) { ... } + if (std.time(int=2147483647) < now - 1w) { + ... + } + $Function STRING getenv(STRING name) Return environment variable *name* or the empty string. See `getenv(3)`. diff --git a/lib/libvmod_std/vmod_std_conversions.c b/lib/libvmod_std/vmod_std_conversions.c index ed85bed0f..c20402b1c 100644 --- a/lib/libvmod_std/vmod_std_conversions.c +++ b/lib/libvmod_std/vmod_std_conversions.c @@ -44,47 +44,139 @@ #include "vtim.h" #include "vcc_if.h" +static inline int onearg(VRT_CTX, const char *f, int nargs) +{ + if (nargs == 1) + return (1); + VRT_fail(ctx, "std.%s: %s arguments", f, + nargs > 1 ? "too many" : "not enough"); + return (0); +} + +/* + * not handling real arg isfinite() / nan() : caller error + * always trunc, never round + */ + VCL_DURATION v_matchproto_(td_std_duration) -vmod_duration(VRT_CTX, VCL_STRING p, VCL_DURATION d) +vmod_duration(VRT_CTX, struct VARGS(duration) *a) { double r; + int nargs; CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); - r = VNUM_duration(p); - return (isnan(r) ? d : r); + + nargs = a->valid_s + a->valid_real + a->valid_integer; + + if (! onearg(ctx, "duration", nargs)) + return (0); + + if (a->valid_real) + return ((VCL_DURATION)a->real); + if (a->valid_integer) + return ((VCL_DURATION)a->integer); + + assert(a->valid_s); + + r = VNUM_duration(a->s); + + if (! isnan(r)) + return (r); + + if (a->valid_fallback) + return (a->fallback); + + VRT_fail(ctx, "std.duration: conversion failed"); + return (0); } VCL_BYTES v_matchproto_(td_std_bytes) -vmod_bytes(VRT_CTX, VCL_STRING p, VCL_BYTES d) +vmod_bytes(VRT_CTX, struct VARGS(bytes) *a) { uintmax_t r; + VCL_BYTES b; + VCL_REAL rr; + int nargs; CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); - if (VNUM_2bytes(p, &r, 0) != NULL) - return (d); - return (r); + + nargs = a->valid_s + a->valid_real + a->valid_integer; + + if (! onearg(ctx, "bytes", nargs)) + return (0); + + b = -1; + if (a->valid_s) { + if (VNUM_2bytes(a->s, &r, 0) == NULL && + r <= VCL_BYTES_MAX) + b = (VCL_BYTES)r; + } else if (a->valid_real) { + rr = trunc(a->real); + if (rr <= (VCL_REAL)VCL_BYTES_MAX) + b = (VCL_BYTES)rr; + } else if (a->valid_integer) { + b = (VCL_BYTES)a->integer; + } else { + INCOMPL(); + } + + if (b >= 0) + return (b); + + if (a->valid_fallback) + return (a->fallback); + + VRT_fail(ctx, "std.bytes: conversion failed"); + return (0); } VCL_INT v_matchproto_(td_std_integer) -vmod_integer(VRT_CTX, VCL_STRING p, VCL_INT i) +vmod_integer(VRT_CTX, struct VARGS(integer) *a) { const char *e; double r; + int nargs; CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); - if (p == NULL) - return (i); + nargs = a->valid_s + a->valid_bool + a->valid_bytes + + a->valid_duration + a->valid_real + a->valid_time; + + if (! onearg(ctx, "integer", nargs)) + return (0); + + r = NAN; + if (a->valid_bool) { + return (!! a->bool); + } else if (a->valid_bytes) { + return (a->bytes); + } else if (a->valid_s) { + if (a->s) { + r = VNUMpfx(a->s, &e); + if (e != NULL) + r = NAN; + } + } else if (a->valid_duration) { + r = a->duration; + } else if (a->valid_real) { + r = a->real; + } else if (a->valid_time) { + r = a->time; + } else { + INCOMPL(); + } - r = VNUMpfx(p, &e); - if (isnan(r) || e != NULL) - return (i); + if (! isnan(r)) { + r = trunc(r); + if (r >= VCL_INT_MIN && r <= VCL_INT_MAX) + return ((VCL_INT)r); + } - r = trunc(r); - if (r > VCL_INT_MAX || r < VCL_INT_MIN) - return (i); + if (a->valid_fallback) + return (a->fallback); - return ((VCL_INT)r); + VRT_fail(ctx, "std.integer: conversion failed"); + return (0); } VCL_IP @@ -133,23 +225,54 @@ vmod_ip(VRT_CTX, VCL_STRING s, VCL_IP d, VCL_BOOL n) } VCL_REAL v_matchproto_(td_std_real) -vmod_real(VRT_CTX, VCL_STRING p, VCL_REAL d) +vmod_real(VRT_CTX, struct VARGS(real) *a) { - double r; + VCL_REAL r; + int nargs; CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); - if (p == NULL) - return (d); + nargs = a->valid_s + a->valid_integer + a->valid_bool + a->valid_bytes + + a->valid_duration + a->valid_time; - r = VNUM(p); + if (! onearg(ctx, "real", nargs)) + return (0); - if (isnan(r)) - return (d); + if (a->valid_integer) + return ((VCL_REAL)a->integer); + else if (a->valid_bool) + return ((VCL_REAL)(!! a->bool)); + else if (a->valid_bytes) + return ((VCL_REAL)a->bytes); + else if (a->valid_duration) + return ((VCL_REAL)a->duration); + else if (a->valid_time) + return ((VCL_REAL)a->time); - return (r); + assert(a->valid_s); + + r = NAN; + if (a->s != NULL) + r = VNUM(a->s); + + if (!isnan(r)) + return (r); + + if (a->valid_fallback) + return (a->fallback); + + VRT_fail(ctx, "std.real: conversion failed"); + return (0); +} + +VCL_REAL v_matchproto_(td_std_round) +vmod_round(VRT_CTX, VCL_REAL r) +{ + (void) ctx; + return (round(r)); } + VCL_INT v_matchproto_(td_std_real2integer) vmod_real2integer(VRT_CTX, VCL_REAL r, VCL_INT i) { @@ -199,14 +322,39 @@ vmod_time2real(VRT_CTX, VCL_TIME t, VCL_REAL r) } VCL_TIME v_matchproto_(td_std_time) -vmod_time(VRT_CTX, VCL_STRING p, VCL_TIME d) +vmod_time(VRT_CTX, struct VARGS(time)* a) { double r; + int nargs; CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); - r = VTIM_parse(p); - if (r) - return (r); - return (vmod_real(ctx, p, d)); + nargs = a->valid_s + a->valid_real + a->valid_integer; + + if (! onearg(ctx, "time", nargs)) + return (0); + + if (a->valid_integer) + return ((VCL_REAL)a->integer); + else if (a->valid_real) + return ((VCL_REAL)a->real); + + assert(a->valid_s); + + if (a->s) { + r = VTIM_parse(a->s); + if (r) + return (r); + + r = VNUM(a->s); + + if (!isnan(r) && r > 0) + return (r); + } + + if (a->valid_fallback) + return (a->fallback); + + VRT_fail(ctx, "std.time: conversion failed"); + return (0); } From nils.goroll at uplex.de Mon Mar 4 13:02:06 2019 From: nils.goroll at uplex.de (Nils Goroll) Date: Mon, 4 Mar 2019 13:02:06 +0000 (UTC) Subject: [master] 3ad34e875 Retire return(miss) from vcl_hit {} Message-ID: <20190304130207.062CD6376D@lists.varnish-cache.org> commit 3ad34e8755c0c46a7b94fbc34ae4837e8c9a1ad5 Author: Nils Goroll Date: Wed Dec 5 16:16:54 2018 +0100 Retire return(miss) from vcl_hit {} Ref #1799 diff --git a/bin/varnishd/builtin.vcl b/bin/varnishd/builtin.vcl index 4835a231c..ce4a5c445 100644 --- a/bin/varnishd/builtin.vcl +++ b/bin/varnishd/builtin.vcl @@ -96,17 +96,7 @@ sub vcl_purge { } sub vcl_hit { - if (obj.ttl >= 0s) { - // A pure unadulterated hit, deliver it - return (deliver); - } - if (obj.ttl + obj.grace > 0s) { - // Object is in grace, deliver it - // Automatically triggers a background fetch - return (deliver); - } - // fetch & deliver once we get the result - return (miss); + return (deliver); } sub vcl_miss { diff --git a/bin/varnishd/cache/cache_req_fsm.c b/bin/varnishd/cache/cache_req_fsm.c index 1bd7911ee..2cbedfdf6 100644 --- a/bin/varnishd/cache/cache_req_fsm.c +++ b/bin/varnishd/cache/cache_req_fsm.c @@ -552,24 +552,6 @@ cnt_lookup(struct worker *wrk, struct req *req) wrk->stats->cache_hit_grace++; req->req_step = R_STP_DELIVER; return (REQ_FSM_MORE); - case VCL_RET_MISS: - if (busy != NULL) { - req->objcore = busy; - req->stale_oc = oc; - req->req_step = R_STP_MISS; - } else { - (void)HSH_DerefObjCore(wrk, &req->objcore, - HSH_RUSH_POLICY); - /* - * We don't have a busy object, so treat this - * like a pass - */ - VSLb(req->vsl, SLT_VCL_Error, - "vcl_hit{} returns miss without busy object." - " Doing pass."); - req->req_step = R_STP_PASS; - } - return (REQ_FSM_MORE); case VCL_RET_RESTART: req->req_step = R_STP_RESTART; break; diff --git a/bin/varnishtest/tests/r01335.vtc b/bin/varnishtest/tests/r01335.vtc deleted file mode 100644 index 1488c9822..000000000 --- a/bin/varnishtest/tests/r01335.vtc +++ /dev/null @@ -1,25 +0,0 @@ -varnishtest "#1335 fetch without busy object" - -server s1 { - rxreq - txresp -bodylen 5 - rxreq - txresp -bodylen 6 -} -start - -varnish v1 -vcl+backend { - sub vcl_hit { - if (req.http.two == "2") { - return (miss); // also #1603 - } - } -} -start - -client c1 { - txreq - rxresp -} -run -client c1 { - txreq -hdr "two: 2" - rxresp -} -run diff --git a/doc/graphviz/cache_req_fsm.dot b/doc/graphviz/cache_req_fsm.dot index 629072dc5..bf777fdcd 100644 --- a/doc/graphviz/cache_req_fsm.dot +++ b/doc/graphviz/cache_req_fsm.dot @@ -133,7 +133,6 @@ digraph cache_req_fsm { lookup:h:s -> lookup2 [style=bold,color=green] lookup2:deliver:s -> deliver:n [style=bold,color=green] - lookup2:miss:s -> miss [color=blue,label=" #1799 \n EOL"] lookup2:pass:s -> pass [style=bold,color=red] /* cnt_miss */ diff --git a/lib/libvcc/generate.py b/lib/libvcc/generate.py index 5f7191f11..991c29ae6 100755 --- a/lib/libvcc/generate.py +++ b/lib/libvcc/generate.py @@ -115,7 +115,7 @@ returns = ( ), ('hit', "C", - ('fail', 'synth', 'restart', 'pass', 'miss', 'deliver',) + ('fail', 'synth', 'restart', 'pass', 'deliver',) ), ('deliver', "C", From nils.goroll at uplex.de Mon Mar 4 13:03:06 2019 From: nils.goroll at uplex.de (Nils Goroll) Date: Mon, 4 Mar 2019 13:03:06 +0000 (UTC) Subject: [master] b10f2a6f2 Update FSM svg Message-ID: <20190304130306.6033F63927@lists.varnish-cache.org> commit b10f2a6f26f171e039743e4e068068a1f0a48417 Author: Nils Goroll Date: Mon Mar 4 14:02:21 2019 +0100 Update FSM svg Ref #2859 diff --git a/doc/graphviz/cache_req_fsm.svg b/doc/graphviz/cache_req_fsm.svg index eeb0a75c8..97da4c954 100644 --- a/doc/graphviz/cache_req_fsm.svg +++ b/doc/graphviz/cache_req_fsm.svg @@ -4,509 +4,502 @@ -