Add an API to temporarily disable an interface (#20)

Author: Nieuwejaar

Cargo.lock

@@ -122,6 +122,12 @@ enum Interface {
     /// List all configured interfaces
     #[structopt(visible_alias = "ls")]
     List,
+    /// Locally disable lldp on the interface.  This refers strictly to
+    /// local interface plumbing, and is independent of the LLDP protocol's
+    /// administrative tx/rx disablement.
+    Disable { iface: String },
+    /// Clear the locally set disable flag.
+    Enable { iface: String },
 }
 
 #[derive(Debug, StructOpt)]
@@ -328,7 +334,15 @@ fn display_neighbor(n: &types::Neighbor) {
 }
 
 fn display_interface(i: &types::Interface) {
-    println!("port: {} interface: {}", i.port, i.iface);
+    println!(
+        "port: {} interface: {}{}",
+        i.port,
+        i.iface,
+        match i.disabled {
+            true => " [Disabled]",
+            false => "",
+        }
+    );
     display_sysinfo(&i.system_info);
 }
 
@@ -465,6 +479,16 @@ async fn main() -> anyhow::Result<()> {
                 .await
                 .map(|r| r.into_inner().iter().for_each(display_interface))
                 .context("failed to remove interface"),
+            Interface::Disable { iface } => client
+                .interface_set_disabled(&iface, true)
+                .await
+                .map(|_| ())
+                .context("failed to set the disabled flag"),
+            Interface::Enable { iface } => client
+                .interface_set_disabled(&iface, false)
+                .await
+                .map(|_| ())
+                .context("failed to clear the disabled flag"),
         },
         Commands::Neighbors => {
             for iface in client

adm/src/main.rs

@@ -16,6 +16,7 @@ serde.workspace = true
 serde_json.workspace = true
 slog.workspace = true
 tokio = { workspace = true, features = [ "full" ] }
+uuid.workspace = true
 
 common.workspace = true
 progenitor.workspace = true

dpd-client/Cargo.toml

@@ -274,6 +274,7 @@ async fn sys_clear_management_addr(
 pub struct Interface {
     pub port: String,
     pub iface: String,
+    pub disabled: bool,
     pub system_info: types::SystemInfo,
 }
 
@@ -364,6 +365,7 @@ async fn interface_get(
                 Interface {
                     port: interface.clone(),
                     iface: i.iface.clone(),
+                    disabled: i.disabled,
                     system_info: (&interfaces::build_lldpdu(&switchinfo, &i))
                         .into(),
                 }
@@ -391,6 +393,7 @@ async fn interface_list(
                 Interface {
                     port: name.clone(),
                     iface: i.iface.clone(),
+                    disabled: i.disabled,
                     system_info: (&interfaces::build_lldpdu(&switchinfo, &i))
                         .into(),
                 }
@@ -399,6 +402,24 @@ async fn interface_list(
     ))
 }
 
+#[endpoint {
+	method = POST,
+	path = "/interface/{iface}/disabled",
+}]
+async fn interface_set_disabled(
+    rqctx: RequestContext<Arc<Global>>,
+    path: Path<InterfacePathParams>,
+    body: TypedBody<bool>,
+) -> Result<HttpResponseUpdatedNoContent, HttpError> {
+    let global: &Global = rqctx.context();
+    let inner = path.into_inner();
+    let val = body.into_inner();
+    interfaces::disabled_set(global, &inner.iface, val)
+        .await
+        .map_err(|e| e.into())
+        .map(|_| HttpResponseUpdatedNoContent())
+}
+
 #[endpoint {
 	method = POST,
 	path = "/interface/{iface}/chassis_id",
@@ -913,6 +934,7 @@ pub fn http_api() -> dropshot::ApiDescription<Arc<Global>> {
     api.register(interface_del).unwrap();
     api.register(interface_list).unwrap();
     api.register(interface_get).unwrap();
+    api.register(interface_set_disabled).unwrap();
     api.register(interface_set_chassis_id).unwrap();
     api.register(interface_del_chassis_id).unwrap();
     api.register(interface_set_port_id).unwrap();

lldpd/src/api_server.rs

@@ -35,6 +35,8 @@ pub enum LldpdError {
     Dlpi(String),
     #[error("Interrupted system call")]
     EIntr,
+    #[error("packet read timed out")]
+    ETimedOut,
     #[error("error: {0}")]
     Other(String),
 }
@@ -91,6 +93,9 @@ impl convert::From<LldpdError> for dropshot::HttpError {
             LldpdError::EIntr => dropshot::HttpError::for_internal_error(
                 "interrupted system call".into(),
             ),
+            LldpdError::ETimedOut => dropshot::HttpError::for_internal_error(
+                "network timeout".into(),
+            ),
             LldpdError::Other(e) => dropshot::HttpError::for_internal_error(e),
         }
     }