Struct varnish::vcl::ctx::Ctx

pub struct Ctx<'a> {
    pub raw: &'a mut vrt_ctx,
    pub http_req: Option<HTTP<'a>>,
    pub http_req_top: Option<HTTP<'a>>,
    pub http_resp: Option<HTTP<'a>>,
    pub http_bereq: Option<HTTP<'a>>,
    pub http_beresp: Option<HTTP<'a>>,
    pub ws: WS<'a>,
}

VCL context

A mutable reference to this structure is always passed to vmod functions and provides access to the available HTTP objects, as well as the workspace.

This struct is a pure Rust structure, mirroring some of the C fields, so you should always use the provided methods to interact with them. If they are not enough, the raw field is actually the C original pointer that can be used to directly, and unsafely, act on the structure.

Which http_* are present will depend on which VCL sub routine the function is called from.

use varnish::vcl::ctx::Ctx;

fn foo(ctx: &Ctx) {
    if let Some(ref req) = ctx.http_req {
        for (name, value) in req {
            println!("header {} has value {}", name, value);
        }
    }
}

Fields

raw: &'a mut vrt_ctx

http_req: Option<HTTP<'a>>

http_req_top: Option<HTTP<'a>>

http_resp: Option<HTTP<'a>>

http_bereq: Option<HTTP<'a>>

http_beresp: Option<HTTP<'a>>

ws: WS<'a>

Implementations

impl<'a> Ctx<'a>

pub fn new(raw: *mut vrt_ctx) -> Self

Wrap a raw pointer into an object we can use.

The pointer must be non-null, and the magic must match

pub fn fail(&mut self, msg: &str) -> u8

Log an error message and fail the current VSL task.

Once the control goes back to Varnish, it will see that the transaction was marked as fail and will return a synthetic error to the client.

pub fn log(&mut self, logtag: LogTag, msg: &str)

Log a message, attached to the current context

pub fn cached_req_body(&mut self) -> Result<Vec<&'a [u8]>, Error>