1VCL-VARIABLES(7) VCL-VARIABLES(7)
2
6 VCL-Variables - The complete album
7
9 This is a list of all variables in the VCL language.
10 Variable names take the form scope.variable[.index], for instance:
12 req.url
14 beresp.http.date
15 client.ip
16 Which operations are possible on each variable is described below, of‐
18 ten with the shorthand "backend" which covers the vcl_backend_* {} sub‐
19 routines and "client" which covers the rest, except vcl_init {} and
20 vcl_fini {}.
21 local, server, remote and client
23 These variables describe the network connection between the client and
24 varnishd.
25 Without PROXY protocol:
27 client server
29 remote local
30 v v
31 CLIENT ------------ VARNISHD
32 With PROXY protocol:
34 client server remote local
36 v v v v
37 CLIENT ------------ PROXY ------------ VARNISHD
38 local.ip
40 Type: IP
41 Readable from: client, backend
43 The IP address (and port number) of the local end of the TCP connec‐
45 tion, for instance 192.168.1.1:81
46 If the connection is a UNIX domain socket, the value will be
48 0.0.0.0:0
49 local.endpoint VCL >= 4.1
51 Type: STRING
52 Readable from: client, backend
54 The address of the '-a' socket the session was accepted on.
56 If the argument was -a foo=:81 this would be ":81"
58 local.socket VCL >= 4.1
60 Type: STRING
61 Readable from: client, backend
63 The name of the '-a' socket the session was accepted on.
65 If the argument was -a foo=:81 this would be "foo".
67 Note that all '-a' gets a default name on the form a%d if no name is
69 provided.
70 remote.ip
72 Type: IP
73 Readable from: client, backend
75 The IP address of the other end of the TCP connection. This can ei‐
77 ther be the clients IP, or the outgoing IP of a proxy server.
78 If the connection is a UNIX domain socket, the value will be
80 0.0.0.0:0
81 client.ip
83 Type: IP
84 Readable from: client, backend
86 The client's IP address, either the same as remote.ip or what the
88 PROXY protocol told us.
89 client.identity
91 Type: STRING
92 Readable from: client, backend
94 Writable from: client
96 Identification of the client, used to load balance in the client di‐
98 rector. Defaults to client.ip
99 This variable can be overwritten with more precise information, for
101 instance extracted from a Cookie: header.
102 server.ip
104 Type: IP
105 Readable from: client, backend
107 The IP address of the socket on which the client connection was re‐
109 ceived, either the same as server.ip or what the PROXY protocol told
110 us.
111 server.hostname
113 Type: STRING
114 Readable from: all
116 The host name of the server, as returned by the gethostname(3) sys‐
118 tem function.
119 server.identity
121 Type: STRING
122 Readable from: all
124 The identity of the server, as set by the -i parameter.
126 If an -i parameter is not passed to varnishd, the return value from
128 gethostname(3) system function will be used.
129 req and req_top
131 These variables describe the present request, and when ESI:include re‐
132 quests are being processed, req_top points to the request received from
133 the client.
134 req
136 Type: HTTP
137 Readable from: client
139 The entire request HTTP data structure. Mostly useful for passing
141 to VMODs.
142 req.method
144 Type: STRING
145 Readable from: client
147 Writable from: client
149 The request method (e.g. "GET", "HEAD", ...)
151 req.hash
153 Type: BLOB
154 Readable from: vcl_hit, vcl_miss, vcl_pass, vcl_purge, vcl_deliver
156 The hash key of this request. Mostly useful for passing to VMODs,
158 but can also be useful for debugging hit/miss status.
159 req.url
161 Type: STRING
162 Readable from: client
164 Writable from: client
166 The requested URL, for instance "/robots.txt".
168 req.proto VCL <= 4.0
170 Type: STRING
171 Readable from: client
173 Writable from: client
175 The HTTP protocol version used by the client, usually "HTTP/1.1" or
177 "HTTP/2.0".
178 req.proto VCL >= 4.1
180 Type: STRING
181 Readable from: client
183 The HTTP protocol version used by the client, usually "HTTP/1.1" or
185 "HTTP/2.0".
186 req.http.*
188 Type: HEADER
189 Readable from: client
191 Writable from: client
193 Unsetable from: client
195 The headers of request, things like req.http.date.
197 The RFCs allow multiple headers with the same name, and both set and
199 unset will remove all headers with the name given.
200 The header name * is a VCL symbol and as such cannot, for example,
202 start with a numeral. Custom VMODs exist for handling of such header
203 names.
204 req.restarts
206 Type: INT
207 Readable from: client
209 A count of how many times this request has been restarted.
211 req.storage
213 Type: STEVEDORE
214 Readable from: client
216 Writable from: client
218 The storage backend to use to save this request body.
220 req.esi_level
222 Type: INT
223 Readable from: client
225 A count of how many levels of ESI requests we're currently at.
227 req.ttl
229 Type: DURATION
230 Readable from: client
232 Writable from: client
234 Upper limit on the object age for cache lookups to return hit.
236 req.grace
238 Type: DURATION
239 Readable from: client
241 Writable from: client
243 Upper limit on the object grace.
245 During lookup the minimum of req.grace and the object's stored grace
247 value will be used as the object's grace.
248 req.xid
250 Type: STRING
251 Readable from: client
253 Unique ID of this request.
255 req.esi VCL <= 4.0
257 Type: BOOL
258 Readable from: client
260 Writable from: client
262 Set to false to disable ESI processing regardless of any value in
264 beresp.do_esi. Defaults to true. This variable is replaced by
265 resp.do_esi in VCL 4.1.
266 req.can_gzip
268 Type: BOOL
269 Readable from: client
271 True if the client provided gzip or x-gzip in the Accept-Encoding
273 header.
274 req.backend_hint
276 Type: BACKEND
277 Readable from: client
279 Writable from: client
281 Set bereq.backend to this if we attempt to fetch. When set to a di‐
283 rector, reading this variable returns an actual backend if the di‐
284 rector has resolved immediately, or the director otherwise. When
285 used in string context, returns the name of the director or backend,
286 respectively.
287 req.hash_ignore_busy
289 Type: BOOL
290 Readable from: client
292 Writable from: client
294 Default: false.
296 Ignore any busy object during cache lookup.
298 You only want to do this when you have two server looking up content
300 sideways from each other to avoid deadlocks.
301 req.hash_always_miss
303 Type: BOOL
304 Readable from: client
306 Writable from: client
308 Default: false.
310 Force a cache miss for this request, even if perfectly good matching
312 objects are in the cache.
313 This is useful to force-update the cache without invalidating exist‐
315 ing entries in case the fetch fails.
316 req.is_hitmiss
318 Type: BOOL
319 Readable from: client
321 If this request resulted in a hitmiss
323 req.is_hitpass
325 Type: BOOL
326 Readable from: client
328 If this request resulted in a hitpass
330 req_top.method
332 Type: STRING
333 Readable from: client
335 The request method of the top-level request in a tree of ESI re‐
337 quests. (e.g. "GET", "HEAD"). Identical to req.method in non-ESI
338 requests.
339 req_top.url
341 Type: STRING
342 Readable from: client
344 The requested URL of the top-level request in a tree of ESI re‐
346 quests. Identical to req.url in non-ESI requests.
347 req_top.http.*
349 Type: HEADER
350 Readable from: client
352 HTTP headers of the top-level request in a tree of ESI requests.
354 Identical to req.http. in non-ESI requests.
355 See req.http.* for general notes.
357 req_top.proto
359 Type: STRING
360 Readable from: client
362 HTTP protocol version of the top-level request in a tree of ESI re‐
364 quests. Identical to req.proto in non-ESI requests.
365 bereq
367 This is the request we send to the backend, it is built from the
368 clients req.* fields by filtering out "per-hop" fields which should not
369 be passed along (Connection:, Range: and similar).
370 Slightly more fields are allowed through for pass` fetches than for
372 `miss` fetches, for instance ``Range.
373 bereq
375 Type: HTTP
376 Readable from: backend
378 The entire backend request HTTP data structure. Mostly useful as
380 argument to VMODs.
381 bereq.xid
383 Type: STRING
384 Readable from: vcl_pipe, backend
386 Unique ID of this request.
388 bereq.retries
390 Type: INT
391 Readable from: backend
393 A count of how many times this request has been retried.
395 bereq.backend
397 Type: BACKEND
398 Readable from: vcl_pipe, backend
400 Writable from: vcl_pipe, backend
402 This is the backend or director we attempt to fetch from. When set
404 to a director, reading this variable returns an actual backend if
405 the director has resolved immediately, or the director otherwise.
406 When used in string context, returns the name of the director or
407 backend, respectively.
408 bereq.body
410 Type: BODY
411 Unsetable from: vcl_backend_fetch
413 The request body.
415 Unset will also remove bereq.http.Content-Length.
417 bereq.hash
419 Type: BLOB
420 Readable from: vcl_pipe, backend
422 The hash key of this request, a copy of req.hash.
424 bereq.method
426 Type: STRING
427 Readable from: vcl_pipe, backend
429 Writable from: vcl_pipe, backend
431 The request type (e.g. "GET", "HEAD").
433 Regular (non-pipe, non-pass) fetches are always "GET"
435 bereq.url
437 Type: STRING
438 Readable from: vcl_pipe, backend
440 Writable from: vcl_pipe, backend
442 The requested URL, copied from req.url
444 bereq.proto VCL <= 4.0
446 Type: STRING
447 Readable from: vcl_pipe, backend
449 Writable from: vcl_pipe, backend
451 The HTTP protocol version, "HTTP/1.1" unless a pass or pipe request
453 has "HTTP/1.0" in req.proto
454 bereq.proto VCL >= 4.1
456 Type: STRING
457 Readable from: vcl_pipe, backend
459 The HTTP protocol version, "HTTP/1.1" unless a pass or pipe request
461 has "HTTP/1.0" in req.proto
462 bereq.http.*
464 Type: HEADER
465 Readable from: vcl_pipe, backend
467 Writable from: vcl_pipe, backend
469 Unsetable from: vcl_pipe, backend
471 The headers to be sent to the backend.
473 See req.http.* for general notes.
475 bereq.uncacheable
477 Type: BOOL
478 Readable from: backend
480 Indicates whether this request is uncacheable due to a pass in the
482 client side or a hit on an hit-for-pass object.
483 bereq.connect_timeout
485 Type: DURATION
486 Readable from: vcl_pipe, backend
488 Writable from: vcl_pipe, backend
490 Default: .connect_timeout attribute from the backend_definition,
492 which defaults to the connect_timeout parameter, see varnishd(1).
493 The time in seconds to wait for a backend connection to be estab‐
495 lished.
496 bereq.first_byte_timeout
498 Type: DURATION
499 Readable from: backend
501 Writable from: backend
503 Default: .first_byte_timeout attribute from the backend_definition,
505 which defaults to the first_byte_timeout parameter, see varnishd(1).
506 The time in seconds to wait getting the first byte back from the
508 backend. Not available in pipe mode.
509 bereq.between_bytes_timeout
511 Type: DURATION
512 Readable from: backend
514 Writable from: backend
516 Default: .between_bytes_timeout attribute from the backend_defini‐
518 tion, which defaults to the between_bytes_timeout parameter, see
519 varnishd(1).
520 The time in seconds to wait between each received byte from the
522 backend. Not available in pipe mode.
523 bereq.is_bgfetch
525 Type: BOOL
526 Readable from: backend
528 True for fetches where the client got a hit on an object in grace,
530 and this fetch was kicked of in the background to get a fresh copy.
531 bereq.is_hitmiss
533 Type: BOOL
534 Readable from: backend
536 If this backend request was caused by a hitmiss.
538 bereq.is_hitpass
540 Type: BOOL
541 Readable from: backend
543 If this backend request was caused by a hitpass.
545 beresp
547 The response received from the backend, one cache misses, the store ob‐
548 ject is built from beresp.
549 beresp
551 Type: HTTP
552 Readable from: vcl_backend_response, vcl_backend_error
554 The entire backend response HTTP data structure, useful as argument
556 to VMOD functions.
557 beresp.body
559 Type: BODY
560 Writable from: vcl_backend_error
562 For producing a synthetic body.
564 beresp.proto VCL <= 4.0
566 Type: STRING
567 Readable from: vcl_backend_response, vcl_backend_error
569 Writable from: vcl_backend_response, vcl_backend_error
571 The HTTP protocol version the backend replied with.
573 beresp.proto VCL >= 4.1
575 Type: STRING
576 Readable from: vcl_backend_response, vcl_backend_error
578 The HTTP protocol version the backend replied with.
580 beresp.status
582 Type: INT
583 Readable from: vcl_backend_response, vcl_backend_error
585 Writable from: vcl_backend_response, vcl_backend_error
587 The HTTP status code returned by the server.
589 More information in the HTTP response status section.
591 beresp.reason
593 Type: STRING
594 Readable from: vcl_backend_response, vcl_backend_error
596 Writable from: vcl_backend_response, vcl_backend_error
598 The HTTP status message returned by the server.
600 beresp.http.*
602 Type: HEADER
603 Readable from: vcl_backend_response, vcl_backend_error
605 Writable from: vcl_backend_response, vcl_backend_error
607 Unsetable from: vcl_backend_response, vcl_backend_error
609 The HTTP headers returned from the server.
611 See req.http.* for general notes.
613 beresp.do_esi
615 Type: BOOL
616 Readable from: vcl_backend_response, vcl_backend_error
618 Writable from: vcl_backend_response, vcl_backend_error
620 Default: false.
622 Set it to true to parse the object for ESI directives. Will only be
624 honored if req.esi is true.
625 It is a VCL error to use beresp.do_esi after setting beresp.filters.
627 beresp.do_stream
629 Type: BOOL
630 Readable from: vcl_backend_response, vcl_backend_error
632 Writable from: vcl_backend_response, vcl_backend_error
634 Default: true.
636 Deliver the object to the client while fetching the whole object
638 into varnish.
639 For uncacheable objects, storage for parts of the body which have
641 been sent to the client may get freed early, depending on the stor‐
642 age engine used.
643 This variable has no effect if do_esi is true or when the response
645 body is empty.
646 beresp.do_gzip
648 Type: BOOL
649 Readable from: vcl_backend_response, vcl_backend_error
651 Writable from: vcl_backend_response, vcl_backend_error
653 Default: false.
655 Set to true to gzip the object while storing it.
657 If http_gzip_support is disabled, setting this variable has no ef‐
659 fect.
660 It is a VCL error to use beresp.do_gzip after setting beresp.fil‐
662 ters.
663 beresp.do_gunzip
665 Type: BOOL
666 Readable from: vcl_backend_response, vcl_backend_error
668 Writable from: vcl_backend_response, vcl_backend_error
670 Default: false.
672 Set to true to gunzip the object while storing it in the cache.
674 If http_gzip_support is disabled, setting this variable has no ef‐
676 fect.
677 It is a VCL error to use beresp.do_gunzip after setting beresp.fil‐
679 ters.
680 beresp.was_304
682 Type: BOOL
683 Readable from: vcl_backend_response, vcl_backend_error
685 When true this indicates that we got a 304 response to our condi‐
687 tional fetch from the backend and turned that into beresp.status =
688 200
689 beresp.uncacheable
691 Type: BOOL
692 Readable from: vcl_backend_response, vcl_backend_error
694 Writable from: vcl_backend_response, vcl_backend_error
696 Inherited from bereq.uncacheable, see there.
698 Setting this variable makes the object uncacheable.
700 This may may produce a hit-for-miss object in the cache.
702 Clearing the variable has no effect and will log the warning "Ignor‐
704 ing attempt to reset beresp.uncacheable".
705 beresp.ttl
707 Type: DURATION
708 Readable from: vcl_backend_response, vcl_backend_error
710 Writable from: vcl_backend_response, vcl_backend_error
712 Default: Cache-Control s-maxage or max-age directives, or a value
714 computed from the Expires header's deadline, or the default_ttl pa‐
715 rameter.
716 The object's remaining time to live, in seconds.
718 beresp.age
720 Type: DURATION
721 Readable from: vcl_backend_response, vcl_backend_error
723 Default: Age header, or zero.
725 The age of the object.
727 beresp.grace
729 Type: DURATION
730 Readable from: vcl_backend_response, vcl_backend_error
732 Writable from: vcl_backend_response, vcl_backend_error
734 Default: Cache-Control stale-while-revalidate directive, or de‐
736 fault_grace parameter.
737 Set to a period to enable grace.
739 beresp.keep
741 Type: DURATION
742 Readable from: vcl_backend_response, vcl_backend_error
744 Writable from: vcl_backend_response, vcl_backend_error
746 Default: default_keep parameter.
748 Set to a period to enable conditional backend requests.
750 The keep time is cache lifetime in addition to the ttl.
752 Objects with ttl expired but with keep time left may be used to is‐
754 sue conditional (If-Modified-Since / If-None-Match) requests to the
755 backend to refresh them.
756 beresp.backend
758 Type: BACKEND
759 Readable from: vcl_backend_response, vcl_backend_error
761 This is the backend we fetched from. If bereq.backend was set to a
763 director, this will be the backend selected by the director. When
764 used in string context, returns its name.
765 beresp.backend.name
767 Type: STRING
768 Readable from: vcl_backend_response, vcl_backend_error
770 Name of the backend this response was fetched from. Same as
772 beresp.backend.
773 beresp.backend.ip VCL <= 4.0
775 Type: IP
776 Readable from: vcl_backend_response
778 IP of the backend this response was fetched from.
780 beresp.storage
782 Type: STEVEDORE
783 Readable from: vcl_backend_response, vcl_backend_error
785 Writable from: vcl_backend_response, vcl_backend_error
787 The storage backend to use to save this object.
789 beresp.storage_hint VCL <= 4.0
791 Type: STRING
792 Readable from: vcl_backend_response, vcl_backend_error
794 Writable from: vcl_backend_response, vcl_backend_error
796 Deprecated since varnish 5.1 and discontinued since VCL 4.1 (varnish
798 6.0). Use beresp.storage instead.
799 Hint to Varnish that you want to save this object to a particular
801 storage backend.
802 beresp.filters
804 Type: STRING
805 Readable from: vcl_backend_response
807 Writable from: vcl_backend_response
809 List of Varnish Fetch Processor (VFP) filters the beresp.body will
811 be pulled through. The order left to right signifies processing from
812 backend to cache, iow the leftmost filter is run first on the body
813 as received from the backend after decoding of any transfer encod‐
814 ings.
815 VFP Filters change the body before going into the cache and/or being
817 handed to the client side, where it may get processed again by
818 resp.filters.
819 The following VFP filters exist in varnish-cache:
821 • gzip: compress a body using gzip
823 • testgunzip: Test if a body is valid gzip and refuse it otherwise
825 • gunzip: Uncompress gzip content
827 • esi: ESI-process plain text content
829 • esi_gzip: Save gzipped snippets for efficient ESI-processing
831 This filter enables stitching together ESI from individually
833 gzipped fragments, saving processing power for re-compression on
834 the client side at the expense of some compression efficiency.
835 Additional VFP filters are available from VMODs.
837 By default, beresp.filters is constructed as follows:
839 • gunzip gets added for gzipped content if beresp.do_gunzip or
841 beresp.do_esi are true.
842 • esi_gzip gets added if beresp.do_esi is true together with
844 beresp.do_gzip or content is already compressed.
845 • esi gets added if beresp.do_esi is true
847 • gzip gets added for uncompressed content if beresp.do_gzip is true
849 • testgunzip gets added for compressed content if beresp.do_gunzip
851 is false.
852 After beresp.filters is set, using any of the beforementioned
854 beresp.do_* switches is a VCL error.
855 obj
857 This is the object we found in cache. It cannot be modified.
858 obj.proto
860 Type: STRING
861 Readable from: vcl_hit
863 The HTTP protocol version stored in the object.
865 obj.status
867 Type: INT
868 Readable from: vcl_hit
870 The HTTP status code stored in the object.
872 More information in the HTTP response status section.
874 obj.reason
876 Type: STRING
877 Readable from: vcl_hit
879 The HTTP reason phrase stored in the object.
881 obj.hits
883 Type: INT
884 Readable from: vcl_hit, vcl_deliver
886 The count of cache-hits on this object.
888 In vcl_deliver a value of 0 indicates a cache miss.
890 obj.http.*
892 Type: HEADER
893 Readable from: vcl_hit
895 The HTTP headers stored in the object.
897 See req.http.* for general notes.
899 obj.ttl
901 Type: DURATION
902 Readable from: vcl_hit, vcl_deliver
904 The object's remaining time to live, in seconds.
906 obj.age
908 Type: DURATION
909 Readable from: vcl_hit, vcl_deliver
911 The age of the object.
913 obj.grace
915 Type: DURATION
916 Readable from: vcl_hit, vcl_deliver
918 The object's grace period in seconds.
920 obj.keep
922 Type: DURATION
923 Readable from: vcl_hit, vcl_deliver
925 The object's keep period in seconds.
927 obj.uncacheable
929 Type: BOOL
930 Readable from: vcl_deliver
932 Whether the object is uncacheable (pass, hit-for-pass or
934 hit-for-miss).
935 obj.storage
937 Type: STEVEDORE
938 Readable from: vcl_hit, vcl_deliver
940 The storage backend where this object is stored.
942 obj.can_esi
944 Type: BOOL
945 Readable from: vcl_hit, vcl_deliver
947 If the object can be ESI processed, that is if setting resp.do_esi
949 or adding esi to resp.filters in vcl_deliver {} would cause the re‐
950 sponse body to be ESI processed.
951 resp
953 This is the response we send to the client, it is built from either
954 beresp (pass/miss), obj (hits) or created from whole cloth (synth).
955 With the exception of resp.body all resp.* variables available in both
957 vcl_deliver{} and vcl_synth{} as a matter of symmetry.
958 resp
960 Type: HTTP
961 Readable from: vcl_deliver, vcl_synth
963 The entire response HTTP data structure, useful as argument to
965 VMODs.
966 resp.body
968 Type: BODY
969 Writable from: vcl_synth
971 To produce a synthetic response body, for instance for errors.
973 resp.proto VCL <= 4.0
975 Type: STRING
976 Readable from: vcl_deliver, vcl_synth
978 Writable from: vcl_deliver, vcl_synth
980 The HTTP protocol version to use for the response.
982 resp.proto VCL >= 4.1
984 Type: STRING
985 Readable from: vcl_deliver, vcl_synth
987 The HTTP protocol version to use for the response.
989 resp.status
991 Type: INT
992 Readable from: vcl_deliver, vcl_synth
994 Writable from: vcl_deliver, vcl_synth
996 The HTTP status code that will be returned.
998 More information in the HTTP response status section.
1000 resp.status 200 will get changed into 304 by core code after a re‐
1002 turn(deliver) from vcl_deliver for conditional requests to cached
1003 content if validation succeeds.
1004 For the validation, first req.http.If-None-Match is compared against
1006 resp.http.Etag. If they compare equal according to the rules for
1007 weak validation (see RFC7232), a 304 is sent.
1008 Secondly, req.http.If-Modified-Since is compared against
1010 resp.http.Last-Modified or, if it is unset, against the point in
1011 time when the object was last modified based on the Date and Age
1012 headers received with the backend response which created the object.
1013 If the object has not been modified based on that comparison, a 304
1014 is sent.
1015 resp.reason
1017 Type: STRING
1018 Readable from: vcl_deliver, vcl_synth
1020 Writable from: vcl_deliver, vcl_synth
1022 The HTTP status message that will be returned.
1024 resp.http.*
1026 Type: HEADER
1027 Readable from: vcl_deliver, vcl_synth
1029 Writable from: vcl_deliver, vcl_synth
1031 Unsetable from: vcl_deliver, vcl_synth
1033 The HTTP headers that will be returned.
1035 See req.http.* for general notes.
1037 resp.do_esi VCL >= 4.1
1039 Type: BOOL
1040 Readable from: vcl_deliver, vcl_synth
1042 Writable from: vcl_deliver, vcl_synth
1044 Default: obj.can_esi
1046 This can be used to selectively disable ESI processing, even though
1048 ESI parsing happened during fetch. This is useful when Varnish
1049 caches peer with each other.
1050 It is a VCL error to use resp.do_esi after setting resp.filters.
1052 resp.is_streaming
1054 Type: BOOL
1055 Readable from: vcl_deliver, vcl_synth
1057 Returns true when the response will be streamed while being fetched
1059 from the backend.
1060 resp.filters
1062 Type: STRING
1063 Readable from: vcl_deliver, vcl_synth
1065 Writable from: vcl_deliver, vcl_synth
1067 List of VDP filters the resp.body will be pushed through.
1069 Before resp.filters is set, the value read will be the default fil‐
1071 ter list as determined by varnish based on resp.do_esi and request
1072 headers.
1073 After resp.filters is set, changing any of the conditions which oth‐
1075 erwise determine the filter selection will have no effiect. Using
1076 resp.do_esi is an error once resp.filters is set.
1077 Special variables
1079 now
1080 Type: TIME
1081 Readable from: all
1083 The current time, in seconds since the UNIX epoch.
1085 When converted to STRING in expressions it returns a formatted time‐
1087 stamp like Tue, 20 Feb 2018 09:30:31 GMT
1088 sess
1090 A session corresponds to the "conversation" that Varnish has with a
1091 single client connection, over which one or more request/response
1092 transactions may take place. It may comprise the traffic over an HTTP/1
1093 keep-alive connection, or the multiplexed traffic over an HTTP/2 con‐
1094 nection.
1095 sess.xid VCL >= 4.1
1097 Type: STRING
1098 Readable from: client, backend
1100 Unique ID of this session.
1102 sess.timeout_idle
1104 Type: DURATION
1105 Readable from: client
1107 Writable from: client
1109 Idle timeout for this session, defaults to the timeout_idle parame‐
1111 ter, see varnishd(1)
1112 sess.timeout_linger
1114 Type: DURATION
1115 Readable from: client
1117 Writable from: client
1119 Linger timeout for this session, defaults to the timeout_linger pa‐
1121 rameter, see varnishd(1)
1122 sess.send_timeout
1124 Type: DURATION
1125 Readable from: client
1127 Writable from: client
1129 Total timeout for ordinary HTTP1 responses, defaults to the
1131 send_timeout parameter, see varnishd(1)
1132 sess.idle_send_timeout
1134 Type: DURATION
1135 Readable from: client
1137 Writable from: client
1139 Send timeout for individual pieces of data on client connections,
1141 defaults to the idle_send_timeout parameter, see varnishd(1)
1142 storage
1144 storage.<name>.free_space
1145 Type: BYTES
1146 Readable from: client, backend
1148 Free space available in the named stevedore. Only available for the
1150 malloc stevedore.
1151 storage.<name>.used_space
1153 Type: BYTES
1154 Readable from: client, backend
1156 Used space in the named stevedore. Only available for the malloc
1158 stevedore.
1159 storage.<name>.happy
1161 Type: BOOL
1162 Readable from: client, backend
1164 Health status for the named stevedore. Not available in any of the
1166 current stevedores.
1167 HTTP response status
1169 A HTTP status code has 3 digits XYZ where X must be between 1 and 5 in‐
1170 cluded. Since it is not uncommon to see HTTP clients or servers rely‐
1171 ing on non-standard or even invalid status codes, Varnish can work with
1172 any status between 100 and 999.
1173 Within VCL code it is even possible to use status codes in the form
1175 VWXYZ as long as the overall value is lower than 65536, but only the
1176 XYZ part will be sent to the client, by which time the X must also have
1177 become non-zero.
1178 The VWXYZ form of status codes can be communicate extra information in
1180 resp.status and beresp.status to return(synth(...)) and return(er‐
1181 ror(...)), to indicate which synthetic content to produce:
1182 sub vcl_recv {
1184 if ([...]) {
1185 return synth(12404);
1186 }
1187 }
1188 sub vcl_synth {
1190 if (resp.status == 12404) {
1191 [...] // this specific 404
1192 } else if (resp.status % 1000 == 404) {
1193 [...] // all other 404's
1194 }
1195 }
1196 The obj.status variable will inherit the VWXYZ form, but in a ban ex‐
1198 presion only the XYZ part will be available. The VWXYZ form is strictly
1199 limited to VCL execution.
1200 Assigning an HTTP standardized code to resp.status or beresp.status
1202 will also set resp.reason or beresp.reason to the corresponding status
1203 message.
1204
1206 • varnishd(1)
1207 • vcl(7)
1209
1211 VCL was developed by Poul-Henning Kamp in cooperation with Verdens Gang
1212 AS, Redpill Linpro and Varnish Software. This manual page is written
1213 by Per Buer, Poul-Henning Kamp, Martin Blix Grydeland, Kristian Lyn‐
1214 gstøl, Lasse Karstensen and others.
1215
1217 This document is licensed under the same license as Varnish itself. See
1218 LICENSE for details.
1219 • Copyright (c) 2006 Verdens Gang AS
1221 • Copyright (c) 2006-2021 Varnish Software AS
1223 VCL-VARIABLES(7)