netconf/message/rpc/operation/
delete_config.rs

1use std::io::Write;
2
3use quick_xml::Writer;
4
5use crate::{capabilities::Requirements, message::WriteError, session::Context, Error};
6
7use super::{params::Required, Datastore, EmptyReply, Operation, Url, WriteXml};
8
9#[derive(Debug, Clone)]
10pub struct DeleteConfig {
11    target: Target,
12}
13
14impl Operation for DeleteConfig {
15    const NAME: &'static str = "delete-config";
16    const REQUIRED_CAPABILITIES: Requirements = Requirements::None;
17
18    type Builder<'a> = Builder<'a>;
19    type Reply = EmptyReply;
20}
21
22impl WriteXml for DeleteConfig {
23    fn write_xml<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), WriteError> {
24        writer
25            .create_element(Self::NAME)
26            .write_inner_content(|writer| {
27                writer
28                    .create_element("target")
29                    .write_inner_content(|writer| self.target.write_xml(writer))
30                    .map(|_| ())
31            })
32            .map(|_| ())
33    }
34}
35
36#[derive(Debug, Clone)]
37#[must_use]
38pub struct Builder<'a> {
39    ctx: &'a Context,
40    target: Required<Target>,
41}
42
43impl Builder<'_> {
44    pub fn target(mut self, target: Datastore) -> Result<Self, Error> {
45        if matches!(target, Datastore::Running) {
46            return Err(Error::DeleteRunningConfig);
47        };
48        target.try_as_target(self.ctx).map(|target| {
49            self.target.set(Target::Datastore(target));
50            self
51        })
52    }
53
54    pub fn url<S: AsRef<str>>(mut self, url: S) -> Result<Self, Error> {
55        Url::try_new(url, self.ctx).map(|url| {
56            self.target.set(Target::Url(url));
57            self
58        })
59    }
60}
61
62impl<'a> super::Builder<'a, DeleteConfig> for Builder<'a> {
63    fn new(ctx: &'a Context) -> Self {
64        Self {
65            ctx,
66            target: Required::init(),
67        }
68    }
69
70    fn finish(self) -> Result<DeleteConfig, Error> {
71        Ok(DeleteConfig {
72            target: self.target.require::<DeleteConfig>("target")?,
73        })
74    }
75}
76
77#[derive(Debug, Clone)]
78enum Target {
79    Datastore(Datastore),
80    Url(Url),
81}
82
83impl WriteXml for Target {
84    fn write_xml<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), WriteError> {
85        match self {
86            Self::Datastore(datastore) => datastore.write_xml(writer),
87            Self::Url(url) => url.write_xml(writer),
88        }
89    }
90}
91
92#[cfg(test)]
93mod tests {
94    use super::*;
95    use crate::message::{
96        rpc::{MessageId, Request},
97        ClientMsg,
98    };
99
100    #[test]
101    fn request_to_xml() {
102        let req = Request {
103            message_id: MessageId(101),
104            operation: DeleteConfig {
105                target: Target::Datastore(Datastore::Running),
106            },
107        };
108        let expect = r#"<rpc message-id="101"><delete-config><target><running/></target></delete-config></rpc>]]>]]>"#;
109        assert_eq!(req.to_xml().unwrap(), expect);
110    }
111}