port_settings_apply.rs

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

use super::{NexusActionContext, NEXUS_DPD_TAG};
use crate::app::sagas::{
    declare_saga_actions, ActionRegistry, NexusSaga, SagaInitError,
};
use crate::context::OpContext;
use crate::{authn, db};
use db::datastore::PortSettingsCombinedResult;
use db::model::{PortSettingsAddressConfig, PortSettingsRouteConfig};
use dendrite_common::network::{Cidr, Ipv4Cidr, Ipv6Cidr};
use dpd_client::types::{Ipv4Entry, Ipv6Entry};
use ipnetwork::IpNetwork;
use omicron_common::api::external::NameOrId;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::sync::Arc;
use steno::ActionError;
use uuid::Uuid;

// port settings apply saga: input parameters

#[derive(Debug, Deserialize, Serialize)]
pub struct Params {
    pub serialized_authn: authn::saga::Serialized,
    pub switchport_id: Uuid,
    pub port_settings_id: Uuid,
    pub port_name: String,
}

// port settings apply: actions

declare_saga_actions! {
    port_settings_apply;
    ASSOCIATE_SWITCHPORT -> "associated_port_settings" {
        + spa_associate_switchport
        - spa_disassociate_switchport
    }
    APPLY_SWITCHPORT_SETTINGS -> "applied_port_settings" {
        + spa_apply_switchport_settings
    }
}

// port settings apply saga: definition

#[derive(Debug)]
pub struct SagaPortSettingsApply;
impl NexusSaga for SagaPortSettingsApply {
    const NAME: &'static str = "port-settings-apply";
    type Params = Params;

    fn register_actions(registry: &mut ActionRegistry) {
        port_settings_apply_register_actions(registry);
    }

    fn make_saga_dag(
        _params: &Self::Params,
        mut builder: steno::DagBuilder,
    ) -> Result<steno::Dag, SagaInitError> {
        builder.append(associate_switchport_action());
        builder.append(apply_switchport_settings_action());

        Ok(builder.build()?)
    }
}

async fn spa_associate_switchport(
    sagactx: NexusActionContext,
) -> Result<Option<Uuid>, ActionError> {
    let osagactx = sagactx.user_data();
    let params = sagactx.saga_params::<Params>()?;
    let nexus = osagactx.nexus();

    let opctx = OpContext::for_saga_action(&sagactx, &params.serialized_authn);

    // first get the current association so we fall back to this on failure
    let port = nexus
        .get_switchport(&opctx, params.switchport_id)
        .await
        .map_err(ActionError::action_failed)?;

    // update the switchport settings association
    nexus
        .set_switchport_settings_id(
            &opctx,
            params.switchport_id,
            Some(params.port_settings_id),
        )
        .await
        .map_err(ActionError::action_failed)?;

    Ok(port.port_settings_id)
}

async fn spa_disassociate_switchport(
    sagactx: NexusActionContext,
) -> Result<(), anyhow::Error> {
    let osagactx = sagactx.user_data();
    let params = sagactx.saga_params::<Params>()?;
    let nexus = osagactx.nexus();

    let opctx = OpContext::for_saga_action(&sagactx, &params.serialized_authn);

    // set the port settings id back to what it was before the saga started
    let orig_port_settings_id =
        sagactx.lookup::<Option<Uuid>>("associated_port_settings")?;

    nexus
        .set_switchport_settings_id(
            &opctx,
            params.switchport_id,
            orig_port_settings_id,
        )
        .await
        .map_err(ActionError::action_failed)?;

    Ok(())
}

async fn spa_apply_switchport_settings(
    sagactx: NexusActionContext,
) -> Result<(), ActionError> {
    let osagactx = sagactx.user_data();
    let params = sagactx.saga_params::<Params>()?;
    let nexus = osagactx.nexus();

    let opctx = OpContext::for_saga_action(&sagactx, &params.serialized_authn);

    let port_settings = nexus
        .port_settings_get(&opctx, &NameOrId::Id(params.port_settings_id))
        .await
        .map_err(ActionError::action_failed)?;

    ensure_port_settings(&sagactx, &port_settings)
        .await
        .map_err(|e| ActionError::action_failed(e.to_string()))?;

    Ok(())
}

async fn ensure_port_settings(
    sagactx: &NexusActionContext,
    settings: &PortSettingsCombinedResult,
) -> Result<(), anyhow::Error> {
    let osagactx = sagactx.user_data();
    let params = sagactx.saga_params::<Params>()?;

    //TODO how do we know this is the right dpd client. There will be at least
    //two and in multirack 2*N where N is the number of racks.
    let dpd_client: Arc<dpd_client::Client> =
        Arc::clone(&osagactx.nexus().dpd_client);

    //TODO breakouts: the following assumes a single link/interface per port.

    //TODO links
    //TODO lldp
    //TODO interfaces
    //TODO vlan interfaces
    ensure_port_addresses(&params.port_name, &dpd_client, &settings.addresses)
        .await?;

    ensure_port_routes(&params.port_name, &dpd_client, &settings.routes)
        .await?;
    //TODO bgp peers

    Ok(())
}

pub(crate) async fn ensure_port_addresses(
    port_name: &str,
    dpd_client: &Arc<dpd_client::Client>,
    addresses: &Vec<PortSettingsAddressConfig>,
) -> Result<(), anyhow::Error> {
    // collect live switch port addresses by family
    let switch_v4_addrs: HashSet<Ipv4Addr> = dpd_client
        .port_ipv4_list(port_name)
        .await?
        .iter()
        .map(|x| x.addr)
        .collect();

    let switch_v6_addrs: HashSet<Ipv6Addr> = dpd_client
        .port_ipv6_list(port_name)
        .await?
        .iter()
        .map(|x| x.addr)
        .collect();

    // collect settings addresses by family
    let mut settings_v4_addrs: HashSet<Ipv4Addr> = HashSet::new();
    let mut settings_v6_addrs: HashSet<Ipv6Addr> = HashSet::new();

    for address_config in addresses {
        match address_config.address.ip() {
            IpAddr::V4(a) => settings_v4_addrs.insert(a),
            IpAddr::V6(a) => settings_v6_addrs.insert(a),
        };
    }

    // determine addresses to be removed as the set difference of the settings
    // addresses from the live addresses

    let v4_to_remove = switch_v4_addrs.difference(&settings_v4_addrs);
    let v6_to_remove = switch_v6_addrs.difference(&settings_v6_addrs);

    // TODO handle partial dpd updates. Maybe we should think about a
    // transactional interface for dpd?
    for a in v4_to_remove {
        dpd_client.port_ipv4_delete(port_name, a).await?;
    }
    for a in v6_to_remove {
        dpd_client.port_ipv6_delete(port_name, a).await?;
    }

    // determine addresses to add as the set difference of the live addresses
    // from the settings addresses

    let v4_to_add = settings_v4_addrs.difference(&switch_v4_addrs);
    let v6_to_add = settings_v6_addrs.difference(&switch_v6_addrs);

    for a in v4_to_add {
        dpd_client
            .port_ipv4_create(
                port_name,
                &Ipv4Entry { addr: *a, tag: NEXUS_DPD_TAG.into() },
            )
            .await?;
    }
    for a in v6_to_add {
        dpd_client
            .port_ipv6_create(
                port_name,
                &Ipv6Entry { addr: *a, tag: NEXUS_DPD_TAG.into() },
            )
            .await?;
    }

    Ok(())
}

pub(crate) async fn ensure_port_routes(
    port_name: &str,
    dpd_client: &Arc<dpd_client::Client>,
    routes: &Vec<PortSettingsRouteConfig>,
) -> Result<(), anyhow::Error> {
    // a common route representation for dendrite and port settings
    #[derive(Eq, Hash, PartialEq)]
    struct Route {
        pub dst: IpAddr,
        pub masklen: u8,
        pub nexthop: Option<IpAddr>,
    }

    // collect live switch routes
    let mut switch_v4_routes: HashSet<Route> = HashSet::new();
    let mut next_page: Option<String> = None;
    loop {
        let page =
            dpd_client.route_ipv4_list(None, next_page.as_deref()).await?;

        for x in &page.items {
            if x.egress_port != port_name {
                continue;
            }
            let cidr = match x.cidr {
                Cidr::V4(c) => c,
                _ => continue,
            };
            switch_v4_routes.insert(Route {
                dst: cidr.prefix.into(),
                masklen: cidr.prefix_len,
                nexthop: x.nexthop,
            });
        }
        if page.next_page.is_none() {
            break;
        }
        next_page = page.next_page.clone();
    }

    let mut switch_v6_routes: HashSet<Route> = HashSet::new();
    let mut next_page: Option<String> = None;
    loop {
        let page =
            dpd_client.route_ipv6_list(None, next_page.as_deref()).await?;

        for x in &page.items {
            if x.egress_port != port_name {
                continue;
            }
            let cidr = match x.cidr {
                Cidr::V6(c) => c,
                _ => continue,
            };
            switch_v6_routes.insert(Route {
                dst: cidr.prefix.into(),
                masklen: cidr.prefix_len,
                nexthop: x.nexthop,
            });
        }
        if page.next_page.is_none() {
            break;
        }
        next_page = page.next_page.clone();
    }

    // collect setting routes
    let mut settings_v4_routes: HashSet<Route> = HashSet::new();
    let mut settings_v6_routes: HashSet<Route> = HashSet::new();

    for r in routes {
        match &r.dst {
            IpNetwork::V4(n) => {
                settings_v4_routes.insert(Route {
                    dst: n.ip().into(),
                    masklen: n.prefix(),
                    nexthop: Some(r.gw.ip()),
                });
            }
            IpNetwork::V6(n) => {
                settings_v6_routes.insert(Route {
                    dst: n.ip().into(),
                    masklen: n.prefix(),
                    nexthop: Some(r.gw.ip()),
                });
            }
        }
    }

    // determine routes to be removed as the set difference of the settings
    // routes from the live routes

    let v4_to_remove = switch_v4_routes.difference(&settings_v4_routes);
    let v6_to_remove = switch_v6_routes.difference(&settings_v6_routes);

    for r in v4_to_remove {
        dpd_client
            .route_ipv4_delete(&Ipv4Cidr {
                prefix: match r.dst {
                    IpAddr::V4(a) => a,
                    _ => continue,
                },
                prefix_len: r.masklen,
            })
            .await?;
    }

    for r in v6_to_remove {
        dpd_client
            .route_ipv6_delete(&Ipv6Cidr {
                prefix: match r.dst {
                    IpAddr::V6(a) => a,
                    _ => continue,
                },
                prefix_len: r.masklen,
            })
            .await?;
    }

    // determine addresses to add as the set difference of the live addresses
    // from the settings addresses

    let v4_to_add = settings_v4_routes.difference(&switch_v4_routes);
    let v6_to_add = settings_v6_routes.difference(&switch_v6_routes);

    for r in v4_to_add {
        dpd_client
            .route_ipv4_create(&dpd_client::types::Route {
                cidr: Cidr::V4(Ipv4Cidr {
                    prefix: match r.dst {
                        IpAddr::V4(a) => a,
                        _ => continue,
                    },
                    prefix_len: r.masklen,
                }),
                egress_port: port_name.into(),
                nexthop: r.nexthop,
                tag: NEXUS_DPD_TAG.into(),
            })
            .await?;
    }

    for r in v6_to_add {
        dpd_client
            .route_ipv6_create(&dpd_client::types::Route {
                cidr: Cidr::V6(Ipv6Cidr {
                    prefix: match r.dst {
                        IpAddr::V6(a) => a,
                        _ => continue,
                    },
                    prefix_len: r.masklen,
                }),
                egress_port: port_name.into(),
                nexthop: r.nexthop,
                tag: NEXUS_DPD_TAG.into(),
            })
            .await?;
    }

    Ok(())
}