Rename OpenOptions to ParseOptions

mmynk · Nov 21, 2023 · 8072176 · 8072176
1 parent 22b1880
commit 8072176
Show file tree

Hide file tree

Showing 5 changed files with 36 additions and 36 deletions.
diff --git a/examples/get.rs b/examples/get.rs
@@ -3,7 +3,7 @@ use netlink_packet_core::{
 };
 use netlink_packet_route::{LinkMessage, RtnlMessage, TcHeader, TcMessage};
 use netlink_sys::{protocols::NETLINK_ROUTE, Socket, SocketAddr};
-use netlink_tc::OpenOptions;
+use netlink_tc::ParseOptions;
 
 fn socket() -> Socket {
     let socket = Socket::new(NETLINK_ROUTE).unwrap();
@@ -76,18 +76,18 @@ fn send_request(socket: &Socket, message: RtnlMessage) {
 
 fn main() {
     let messages = get_qdiscs();
-    let qdiscs = OpenOptions::new().tc(messages).unwrap();
+    let qdiscs = ParseOptions::new().tc(messages).unwrap();
     println!("length: {}, qdiscs: {:#?}", qdiscs.len(), qdiscs);
 
     let messages = get_links();
-    let links = OpenOptions::new().links(messages).unwrap();
+    let links = ParseOptions::new().links(messages).unwrap();
     println!("length: {}, links: {:#?}", links.len(), links);
 
     let mut messages = Vec::new();
     for link in links {
         let classes = get_classes(link.index as i32);
         messages.extend(classes);
     }
-    let classes = OpenOptions::new().tc(messages).unwrap();
+    let classes = ParseOptions::new().tc(messages).unwrap();
     println!("length: {}, classes: {:#?}", classes.len(), classes);
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -9,19 +9,19 @@
 //! ```rust
 //! use netlink_packet_core::NetlinkMessage;
 //! use netlink_packet_route::RtnlMessage;
-//! use netlink_tc::OpenOptions;
+//! use netlink_tc::ParseOptions;
 //!
 //! // Retrieve netlink messages using `netlink-packet-route`.
 //! // See `examples` for more details.
 //! let messages: Vec<NetlinkMessage<RtnlMessage>> = vec![]; // init with netlink messages
 //!
 //! // Get list of tc qdiscs or classes
-//! let qdiscs = OpenOptions::new()
+//! let qdiscs = ParseOptions::new()
 //!     .fail_on_unknown_netlink_message(true)
 //!     .tc(messages.clone()).unwrap();
 //!
 //! // Get list of links
-//! let links = OpenOptions::new()
+//! let links = ParseOptions::new()
 //!     .links(messages.clone()).unwrap();
 //! ```
 use netlink_packet_core::{NetlinkMessage, NetlinkPayload};
@@ -59,13 +59,13 @@ pub enum RtNetlinkMessage {
 /// `OpenOptions` provides options for controlling how `netlink-tc` parses netlink messages.
 /// By default, unknown attributes and options are ignored.
 #[derive(Debug, Default)]
-pub struct OpenOptions {
+pub struct ParseOptions {
     fail_on_unknown_netlink_message: bool,
     fail_on_unknown_attribute: bool,
     fail_on_unknown_option: bool,
 }
 
-impl OpenOptions {
+impl ParseOptions {
     /// Creates a new set of options with all flags set to false.
     pub fn new() -> Self {
         Self::default()
@@ -98,9 +98,9 @@ impl OpenOptions {
     ///
     /// # Example
     /// ```no_run
-    /// use netlink_tc::OpenOptions;
+    /// use netlink_tc::ParseOptions;
     ///
-    /// let queues = OpenOptions::new()
+    /// let queues = ParseOptions::new()
     ///     .fail_on_unknown_netlink_message(true)
     ///     .fail_on_unknown_attribute(true)
     ///     .fail_on_unknown_option(true)
@@ -117,7 +117,7 @@ impl OpenOptions {
     }
 }
 
-fn to_tc(tc_message: NlTcMessage, opts: &OpenOptions) -> Result<TcMsg, TcError> {
+fn to_tc(tc_message: NlTcMessage, opts: &ParseOptions) -> Result<TcMsg, TcError> {
     let NlTcMessage {
         header: tc_header,
         nlas,
@@ -238,7 +238,7 @@ fn to_link(link_message: NlLinkMessage) -> Result<LinkMsg, TcError> {
 
 fn parse(
     messages: Vec<NetlinkMessage<RtnlMessage>>,
-    opts: &OpenOptions,
+    opts: &ParseOptions,
 ) -> Result<Vec<RtNetlinkMessage>, TcError> {
     let mut tc_messages = Vec::new();
     for message in messages {
@@ -265,7 +265,7 @@ fn parse(
 /// Parse `tc` queueing disciplines and classes for the corresponding Netlink messages.
 fn tc_stats(
     messages: Vec<NetlinkMessage<RtnlMessage>>,
-    opts: &OpenOptions,
+    opts: &ParseOptions,
 ) -> Result<Vec<Tc>, TcError> {
     let messages = parse(messages, opts)?;
     tc::tc_stats(messages, opts)
@@ -274,7 +274,7 @@ fn tc_stats(
 /// Parse `link` messages for the corresponding Netlink messages
 fn links(
     messages: Vec<NetlinkMessage<RtnlMessage>>,
-    opts: &OpenOptions,
+    opts: &ParseOptions,
 ) -> Result<Vec<Link>, TcError> {
     let messages = parse(messages, opts)?;
     link::links(messages)

diff --git a/src/tc.rs b/src/tc.rs
@@ -6,9 +6,9 @@ use crate::types::{
     Attribute, Class, QDisc, Stats, Stats2, Tc, TcAttr, TcMessage, TcMsg, TcOption, TcStats2,
     XStats,
 };
-use crate::{OpenOptions, RtNetlinkMessage};
+use crate::{ParseOptions, RtNetlinkMessage};
 
-fn get_qdiscs(message: TcMsg, classful: bool, opts: &OpenOptions) -> Result<Tc, TcError> {
+fn get_qdiscs(message: TcMsg, classful: bool, opts: &ParseOptions) -> Result<Tc, TcError> {
     let tc = TcMessage {
         index: message.header.index as u32,
         handle: message.header.handle,
@@ -50,16 +50,16 @@ fn get_qdiscs(message: TcMsg, classful: bool, opts: &OpenOptions) -> Result<Tc,
 }
 
 /// `qdiscs` returns a list of queuing disciplines by parsing the passed `TcMsg` vector.
-pub fn qdiscs(message: TcMsg, opts: &OpenOptions) -> Result<Tc, TcError> {
+pub fn qdiscs(message: TcMsg, opts: &ParseOptions) -> Result<Tc, TcError> {
     get_qdiscs(message, false, opts)
 }
 
 /// `classes` returns a list of traffic control classes by parsing the passed `TcMsg` vector.
-pub fn classes(message: TcMsg, opts: &OpenOptions) -> Result<Tc, TcError> {
+pub fn classes(message: TcMsg, opts: &ParseOptions) -> Result<Tc, TcError> {
     get_qdiscs(message, true, opts)
 }
 
-pub fn tc_stats(messages: Vec<RtNetlinkMessage>, opts: &OpenOptions) -> Result<Vec<Tc>, TcError> {
+pub fn tc_stats(messages: Vec<RtNetlinkMessage>, opts: &ParseOptions) -> Result<Vec<Tc>, TcError> {
     let mut tcs = Vec::with_capacity(messages.len());
 
     for message in messages {
@@ -109,7 +109,7 @@ fn parse_stats2(stats2: &Vec<TcStats2>) -> Result<Stats2, TcError> {
 fn parse_qdiscs(
     kind: &str,
     tc_opts: Vec<TcOption>,
-    opts: &OpenOptions,
+    opts: &ParseOptions,
 ) -> Result<Option<QDisc>, TcError> {
     let qdisc = match kind {
         FQ_CODEL => Some(QDisc::FqCodel(FqCodel::new(tc_opts))),
@@ -131,7 +131,7 @@ fn parse_qdiscs(
 fn parse_classes(
     kind: &str,
     tc_opts: Vec<TcOption>,
-    opts: &OpenOptions,
+    opts: &ParseOptions,
 ) -> Result<Option<Class>, TcError> {
     let class = match kind {
         HTB => Some(Class::Htb(Htb::new(tc_opts))),
@@ -148,7 +148,7 @@ fn parse_classes(
     Ok(class)
 }
 
-fn parse_xstats(kind: &str, bytes: &[u8], opts: &OpenOptions) -> Result<Option<XStats>, TcError> {
+fn parse_xstats(kind: &str, bytes: &[u8], opts: &ParseOptions) -> Result<Option<XStats>, TcError> {
     let xstats = match kind {
         FQ_CODEL => FqCodelXStats::new(bytes).ok().map(XStats::FqCodel),
         HTB => HtbXstats::new(bytes).ok().map(XStats::Htb),

diff --git a/src/tests.rs b/src/tests.rs
@@ -11,7 +11,7 @@ use super::*;
 #[test]
 fn test_no_queue() {
     let messages = vec![get_qdiscs()[0].clone()];
-    let stats = OpenOptions::new().tc(messages).unwrap();
+    let stats = ParseOptions::new().tc(messages).unwrap();
 
     let tc = stats.get(0).unwrap();
     // message
@@ -33,7 +33,7 @@ fn test_no_queue() {
 #[test]
 fn test_mq() {
     let messages = vec![get_qdiscs()[1].clone()];
-    let stats = OpenOptions::new().tc(messages).unwrap();
+    let stats = ParseOptions::new().tc(messages).unwrap();
 
     let tc = stats.get(0).unwrap();
     // message
@@ -56,7 +56,7 @@ fn test_mq() {
 #[test]
 fn test_fq_codel() {
     let messages = vec![get_qdiscs()[2].clone()];
-    let stats = OpenOptions::new().tc(messages).unwrap();
+    let stats = ParseOptions::new().tc(messages).unwrap();
 
     let tc = stats.get(0).unwrap();
     // message
@@ -114,7 +114,7 @@ fn test_htb() {
     let qdiscs = get_qdiscs();
     let classes = get_classes();
     let messages = vec![qdiscs[3].clone(), classes[0].clone()];
-    let tc_stats = OpenOptions::new().tc(messages).unwrap();
+    let tc_stats = ParseOptions::new().tc(messages).unwrap();
 
     let tc = tc_stats.get(0).unwrap();
     // message
@@ -202,7 +202,7 @@ fn test_htb() {
 
 #[test]
 fn test_links() {
-    let links = OpenOptions::new().links(get_links()).unwrap();
+    let links = ParseOptions::new().links(get_links()).unwrap();
 
     assert_eq!(links[0].index, 1);
     assert_eq!(links[0].name, "eth0");
@@ -214,7 +214,7 @@ fn test_unknown_netlink_msg_fail() {
         NetlinkHeader::default(),
         NetlinkPayload::InnerMessage(RtnlMessage::DelQueueDiscipline(TcMessage::default())),
     )];
-    let stats = OpenOptions::new()
+    let stats = ParseOptions::new()
         .fail_on_unknown_netlink_message(true)
         .tc(messages);
 
@@ -229,7 +229,7 @@ fn test_unknown_attribute_fail() {
         NetlinkHeader::default(),
         NetlinkPayload::InnerMessage(RtnlMessage::NewQueueDiscipline(tc_message)),
     );
-    let stats = OpenOptions::new()
+    let stats = ParseOptions::new()
         .fail_on_unknown_attribute(true)
         .tc(vec![messages]);
 
@@ -256,7 +256,7 @@ fn test_stats_parse_fail() {
         NetlinkHeader::default(),
         NetlinkPayload::InnerMessage(RtnlMessage::NewQueueDiscipline(tc_message)),
     );
-    let tcs = OpenOptions::new().tc(vec![messages]).unwrap();
+    let tcs = ParseOptions::new().tc(vec![messages]).unwrap();
     let tc = tcs.get(0).unwrap();
     assert!(tc.attr.stats2.is_none());
 }
@@ -267,7 +267,7 @@ fn test_unknown_option_fail() {
         NetlinkHeader::default(),
         NetlinkPayload::InnerMessage(RtnlMessage::NewQueueDiscipline(qdisc("unknown"))),
     )];
-    let stats = OpenOptions::new().fail_on_unknown_option(true).tc(messages);
+    let stats = ParseOptions::new().fail_on_unknown_option(true).tc(messages);
 
     assert!(stats.is_err());
 }
diff --git a/tests/integration_test.rs b/tests/integration_test.rs
@@ -3,7 +3,7 @@ use netlink_packet_core::{
 };
 use netlink_packet_route::{LinkMessage, RtnlMessage, TcHeader, TcMessage};
 use netlink_sys::{protocols::NETLINK_ROUTE, Socket, SocketAddr};
-use netlink_tc::OpenOptions;
+use netlink_tc::ParseOptions;
 
 fn socket() -> Socket {
     let socket = Socket::new(NETLINK_ROUTE).unwrap();
@@ -77,7 +77,7 @@ fn send_request(socket: &Socket, message: RtnlMessage) {
 #[test]
 fn test_qdiscs() {
     let messages = get_qdiscs();
-    let tcs = OpenOptions::new().tc(messages).unwrap();
+    let tcs = ParseOptions::new().tc(messages).unwrap();
     for tc in tcs {
         let attr = tc.attr;
         assert!(!attr.kind.is_empty());
@@ -89,13 +89,13 @@ fn test_qdiscs() {
 #[test]
 fn test_link_classes() {
     let messages = get_links();
-    let links = OpenOptions::new().links(messages).unwrap();
+    let links = ParseOptions::new().links(messages).unwrap();
 
     assert!(!links.is_empty());
 
     for link in links {
         let messages = get_classes(link.index);
-        let classes = OpenOptions::new().tc(messages);
+        let classes = ParseOptions::new().tc(messages);
         assert!(classes.is_ok());
     }
 }