Struct Answer 

pub struct Answer { /* private fields */ }

Answers calls from a closure, for a dry run.

The closure is asked about each call it wraps, and sees the call’s Ctx: its info, its input, resolved with every secret-reading field null, and the primary_output an answer is written through. Some(value) is written with Ctx::emit_default, through the callee’s primary output, and the call returns Outcome::Ok without reaching the layers inside this one or the function. None passes the call on. A callee with no primary output fails the call with a Config error.

use dataflow_rs::datavalue::OwnedDataValue;
use dataflow_rs::function::{CallLayer, layers::Answer};
use dataflow_rs::RunOptions;
use std::sync::Arc;

// Every `http_call` that has somewhere to write answers with the input
// it was given; the rest run.
let dry_run: Vec<Arc<dyn CallLayer>> = vec![Arc::new(Answer::new(|ctx| {
    if ctx.info().function != "http_call" || ctx.primary_output().is_none() {
        return None;
    }
    let input = ctx.input().ok()?;
    Some(OwnedDataValue::Object(vec![
        ("status".into(), "dry run".into()),
        ("request".into(), input),
    ]))
}))];
let opts = RunOptions::default().layers(&dry_run);

Implementations

impl Answer

pub fn new( f: impl Fn(&Ctx<'_>) -> Option<OwnedDataValue> + Send + Sync + 'static, ) -> Self

A layer answering each call f gives a value for.

Trait Implementations

impl CallLayer for Answer

fn call<'a>( &'a self, ctx: &'a mut Ctx<'_>, next: Next<'a>, ) -> BoxFuture<'a, Result<Outcome>>

Wraps one call. next is the rest of the chain.

impl Debug for Answer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Nothing of the closure.