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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::app::format::write::HeaderWriter;
use crate::app::parse::parser::{HeaderCollection, Response};
use crate::app::FunctionCode;
use crate::master::error::{CommandError, CommandResponseError, TaskError};
use crate::master::promise::Promise;
use crate::master::request::*;
use crate::master::tasks::{AppTask, NonReadTask, Task};

enum State {
    Select,
    Operate,
    DirectOperate,
}

pub(crate) struct CommandTask {
    state: State,
    headers: CommandHeaders,
    promise: Promise<Result<(), CommandError>>,
}

impl From<CommandTask> for Task {
    fn from(value: CommandTask) -> Self {
        Task::App(AppTask::NonRead(NonReadTask::Command(value)))
    }
}

impl CommandMode {
    fn to_state(self) -> State {
        match self {
            CommandMode::DirectOperate => State::DirectOperate,
            CommandMode::SelectBeforeOperate => State::Select,
        }
    }
}

impl CommandTask {
    pub(crate) fn from_mode(
        mode: CommandMode,
        headers: CommandHeaders,
        promise: Promise<Result<(), CommandError>>,
    ) -> Self {
        Self {
            state: mode.to_state(),
            headers,
            promise,
        }
    }

    fn new(
        state: State,
        headers: CommandHeaders,
        promise: Promise<Result<(), CommandError>>,
    ) -> Self {
        Self {
            state,
            headers,
            promise,
        }
    }

    fn change_state(self, state: State) -> Self {
        Self::new(state, self.headers, self.promise)
    }

    pub(crate) fn wrap(self) -> NonReadTask {
        NonReadTask::Command(self)
    }

    pub(crate) fn function(&self) -> FunctionCode {
        match self.state {
            State::DirectOperate => FunctionCode::DirectOperate,
            State::Select => FunctionCode::Select,
            State::Operate => FunctionCode::Operate,
        }
    }

    pub(crate) fn write(&self, writer: &mut HeaderWriter) -> Result<(), scursor::WriteError> {
        self.headers.write(writer)
    }

    fn compare(&self, headers: HeaderCollection) -> Result<(), CommandResponseError> {
        self.headers.compare(headers)
    }

    pub(crate) fn on_task_error(self, err: TaskError) {
        self.promise.complete(Err(err.into()))
    }

    pub(crate) fn handle(self, response: Response) -> Result<Option<NonReadTask>, TaskError> {
        let headers = match response.objects {
            Ok(x) => x,
            Err(err) => {
                self.promise
                    .complete(Err(TaskError::MalformedResponse(err).into()));
                return Err(TaskError::MalformedResponse(err));
            }
        };

        if let Err(err) = self.compare(headers) {
            self.promise.complete(Err(err.into()));
            return Err(TaskError::UnexpectedResponseHeaders);
        }

        match self.state {
            State::Select => Ok(Some(self.change_state(State::Operate).wrap())),
            _ => {
                // Complete w/ success
                self.promise.complete(Ok(()));
                Ok(None)
            }
        }
    }
}