Struct Engine 

pub struct Engine { /* private fields */ }

Parser and policy orchestration engine.

Implementations

impl Engine

pub fn new(policy: Policy) -> Self

Creates an engine with the provided policy.

Examples found in repository

examples/process_file.rs (line 14)

fn main() -> std::io::Result<()> {
    let Some(path) = std::env::args().nth(1) else {
        eprintln!("usage: process_file <packets.aprs>");
        std::process::exit(2);
    };

    let input = read_all_with_limit(File::open(path)?, DEFAULT_TRANSPORT_READ_LIMIT)?;
    let mut engine = Engine::new(Policy::strict());

    for packet_bytes in LineTransport::new(&input).packets() {
        match engine.process(packet_bytes) {
            EngineResult::Accepted { packet } => println!("{}", packet.to_json()),
            EngineResult::Rejected { reason, .. } => eprintln!("rejected: {}", reason.code()),
            EngineResult::ParseError(error) => eprintln!("malformed: {}", error.code()),
        }
    }

    Ok(())
}

examples/service_ingest.rs (line 7)

fn main() -> Result<(), std::io::Error> {
    let input = b"N0CALL>APRS:>service online\nN1CALL>APRS:~opaque\nbad packet\n";
    let mut engine = Engine::new(Policy::strict());

    let packets = LineTransport::new(input).packets_with_limit(MAX_PACKET_LEN)?;

    for packet in packets {
        match engine.process_event(packet) {
            EngineEvent::Accepted(event) => {
                println!(
                    "event={} semantic={}",
                    event.kind().code(),
                    event.packet.summary().semantic
                );
            }
            EngineEvent::Rejected(event) => {
                println!(
                    "event={} code={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.diagnostic.remediation
                );
            }
            EngineEvent::Malformed(event) => {
                println!(
                    "event={} code={} raw_len={} raw_truncated={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.raw.len(),
                    event.raw_truncated,
                    event.diagnostic.remediation
                );
            }
        }
    }

    let counters = engine.counters();
    println!(
        "summary accepted={} rejected={} malformed={}",
        counters.accepted, counters.rejected, counters.malformed
    );

    Ok(())
}

pub fn process(&mut self, input: &[u8]) -> EngineResult

Processes one packet through codec, semantics, and policy.

Examples found in repository

examples/process_file.rs (line 17)

fn main() -> std::io::Result<()> {
    let Some(path) = std::env::args().nth(1) else {
        eprintln!("usage: process_file <packets.aprs>");
        std::process::exit(2);
    };

    let input = read_all_with_limit(File::open(path)?, DEFAULT_TRANSPORT_READ_LIMIT)?;
    let mut engine = Engine::new(Policy::strict());

    for packet_bytes in LineTransport::new(&input).packets() {
        match engine.process(packet_bytes) {
            EngineResult::Accepted { packet } => println!("{}", packet.to_json()),
            EngineResult::Rejected { reason, .. } => eprintln!("rejected: {}", reason.code()),
            EngineResult::ParseError(error) => eprintln!("malformed: {}", error.code()),
        }
    }

    Ok(())
}

pub fn process_event(&mut self, input: &[u8]) -> EngineEvent

Processes one packet and returns a stable observability event.

Examples found in repository

examples/service_ingest.rs (line 12)

fn main() -> Result<(), std::io::Error> {
    let input = b"N0CALL>APRS:>service online\nN1CALL>APRS:~opaque\nbad packet\n";
    let mut engine = Engine::new(Policy::strict());

    let packets = LineTransport::new(input).packets_with_limit(MAX_PACKET_LEN)?;

    for packet in packets {
        match engine.process_event(packet) {
            EngineEvent::Accepted(event) => {
                println!(
                    "event={} semantic={}",
                    event.kind().code(),
                    event.packet.summary().semantic
                );
            }
            EngineEvent::Rejected(event) => {
                println!(
                    "event={} code={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.diagnostic.remediation
                );
            }
            EngineEvent::Malformed(event) => {
                println!(
                    "event={} code={} raw_len={} raw_truncated={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.raw.len(),
                    event.raw_truncated,
                    event.diagnostic.remediation
                );
            }
        }
    }

    let counters = engine.counters();
    println!(
        "summary accepted={} rejected={} malformed={}",
        counters.accepted, counters.rejected, counters.malformed
    );

    Ok(())
}

pub fn process_packets<I, P>(&mut self, packets: I) -> Vec<EngineResult>

where I: IntoIterator<Item = P>, P: AsRef<[u8]>,

Processes a caller-provided packet batch in order.

pub fn process_source<S>( &mut self, source: &mut S, ) -> Result<Vec<EngineResult>, S::Error>

where S: PacketSource,

Reads one bounded batch from a packet source and processes it in order.

pub fn counters(&self) -> Counters

Returns engine counters.

Examples found in repository

examples/service_ingest.rs (line 41)

fn main() -> Result<(), std::io::Error> {
    let input = b"N0CALL>APRS:>service online\nN1CALL>APRS:~opaque\nbad packet\n";
    let mut engine = Engine::new(Policy::strict());

    let packets = LineTransport::new(input).packets_with_limit(MAX_PACKET_LEN)?;

    for packet in packets {
        match engine.process_event(packet) {
            EngineEvent::Accepted(event) => {
                println!(
                    "event={} semantic={}",
                    event.kind().code(),
                    event.packet.summary().semantic
                );
            }
            EngineEvent::Rejected(event) => {
                println!(
                    "event={} code={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.diagnostic.remediation
                );
            }
            EngineEvent::Malformed(event) => {
                println!(
                    "event={} code={} raw_len={} raw_truncated={} remediation={}",
                    event.kind().code(),
                    event.diagnostic.code,
                    event.raw.len(),
                    event.raw_truncated,
                    event.diagnostic.remediation
                );
            }
        }
    }

    let counters = engine.counters();
    println!(
        "summary accepted={} rejected={} malformed={}",
        counters.accepted, counters.rejected, counters.malformed
    );

    Ok(())
}

Trait Implementations

impl Clone for Engine

fn clone(&self) -> Engine

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Engine

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

Formats the value using the given formatter.

impl Default for Engine

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Engine

fn eq(&self, other: &Engine) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Engine

impl StructuralPartialEq for Engine