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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use crate::app::{ExponentialBackOff, Listener, RetryStrategy, Shutdown};
use crate::serial::{PortState, SerialSettings};
use crate::util::phys::PhysLayer;
use crate::util::session::{RunError, Session, StopReason};

pub(crate) struct SerialTask {
    path: String,
    serial_settings: SerialSettings,
    back_off: ExponentialBackOff,
    session: Session,
    listener: Box<dyn Listener<PortState>>,
}

impl SerialTask {
    pub(crate) fn new(
        path: &str,
        serial_settings: SerialSettings,
        session: Session,
        retry: RetryStrategy,
        listener: Box<dyn Listener<PortState>>,
    ) -> Self {
        Self {
            path: path.to_string(),
            serial_settings,
            back_off: ExponentialBackOff::new(retry),
            session,
            listener,
        }
    }

    pub(crate) async fn run(&mut self) {
        let _ = self.run_inner().await;
        self.listener.update(PortState::Shutdown).get().await;
    }

    async fn run_inner(&mut self) -> Result<(), Shutdown> {
        loop {
            self.listener.update(PortState::Disabled).get().await;
            self.session.wait_for_enabled().await?;
            if let Err(StopReason::Shutdown) = self.run_enabled().await {
                return Err(Shutdown);
            }
        }
    }

    async fn run_enabled(&mut self) -> Result<(), StopReason> {
        loop {
            match crate::serial::open(self.path.as_str(), self.serial_settings) {
                Err(err) => {
                    let delay = self.back_off.on_failure();
                    tracing::warn!("{} - waiting {} ms to re-open port", err, delay.as_millis());
                    self.listener.update(PortState::Wait(delay)).get().await;
                    self.session.wait_for_retry(delay).await?;
                }
                Ok(serial) => {
                    self.back_off.on_success();
                    tracing::info!("serial port open");
                    let mut io = PhysLayer::Serial(serial);
                    self.listener.update(PortState::Open).get().await;
                    match self.session.run(&mut io).await {
                        RunError::Stop(x) => {
                            return Err(x);
                        }
                        RunError::Link(err) => {
                            let delay = self.back_off.on_failure();
                            // we wait here to prevent any kind of rapid retry scenario if the port opens and then immediately fails
                            tracing::warn!(
                                "{} - waiting {} ms to re-open port",
                                err,
                                delay.as_millis()
                            );
                            self.listener.update(PortState::Wait(delay)).get().await;
                            self.session.wait_for_retry(delay).await?;
                        }
                    }
                }
            }
        }
    }
}