dnp3 1.6.0

Rust implementation of DNP3 (IEEE 1815) with idiomatic bindings for C, C++, .NET, and Java
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use crate::app::{Shutdown, Timeout};
use crate::udp::layer::UdpFactory;
use crate::util::session::{RunError, Session, StopReason};

pub(crate) struct UdpTask {
    pub(crate) session: Session,
    pub(crate) factory: UdpFactory,
    pub(crate) retry_delay: Timeout,
}

enum Delay {
    Yes,
    No,
}

impl UdpTask {
    pub(crate) async fn run(mut self) -> Result<(), Shutdown> {
        loop {
            self.session.wait_for_enabled().await?;
            if let Delay::Yes = self.run_one().await? {
                if let Err(reason) = self.session.wait_for_retry(self.retry_delay.into()).await {
                    Self::handle_stop(reason)?;
                }
            }
        }
    }

    fn handle_stop(reason: StopReason) -> Result<Delay, Shutdown> {
        match reason {
            StopReason::Disable => Ok(Delay::No),
            StopReason::Shutdown => Err(Shutdown),
        }
    }

    async fn run_one(&mut self) -> Result<Delay, Shutdown> {
        match self.factory.open().await {
            Ok(mut phys) => match self.session.run(&mut phys).await {
                RunError::Stop(r) => Self::handle_stop(r),
                RunError::Link(err) => {
                    tracing::warn!("{err}");
                    Ok(Delay::Yes)
                }
            },
            Err(err) => {
                tracing::error!("{err}");
                Ok(Delay::Yes)
            }
        }
    }
}