use std::{env, io::Read, path::PathBuf};
use rscni_types::{
error::Error,
types::{
CNI_ARGS, CNI_CONTAINERID, CNI_IFNAME, CNI_NETNS, CNI_PATH, Cmd, ContainerId,
InterfaceName, NetConf,
},
};
use crate::util::{Env, Io};
#[derive(Debug, Clone)]
pub struct Args {
pub(crate) container_id: Option<ContainerId>,
pub(crate) netns: Option<PathBuf>,
pub(crate) ifname: Option<InterfaceName>,
#[allow(clippy::struct_field_names)]
pub(crate) args: Option<String>,
pub(crate) path: Vec<PathBuf>,
pub(crate) config: NetConf,
}
impl Args {
pub(crate) fn from_env<E: Env, I: Io>(cmd: Cmd) -> Result<Self, Error> {
let builder = ArgsBuilder::<E, I>::new();
match cmd {
Cmd::Add | Cmd::Del | Cmd::Check => {
builder.container_id()?.netns()?.ifname()?.args()?.path()?
}
Cmd::Status | Cmd::Gc => builder.path()?,
Cmd::Version => builder,
}
.validate(cmd)?
.config()?
.build()
}
#[must_use]
pub const fn container_id(&self) -> Option<&ContainerId> {
self.container_id.as_ref()
}
#[must_use]
pub const fn netns(&self) -> Option<&PathBuf> {
self.netns.as_ref()
}
#[must_use]
pub const fn ifname(&self) -> Option<&InterfaceName> {
self.ifname.as_ref()
}
#[must_use]
pub fn args(&self) -> Option<&str> {
self.args.as_deref()
}
#[must_use]
pub fn path(&self) -> &[PathBuf] {
&self.path
}
#[must_use]
pub const fn config(&self) -> &NetConf {
&self.config
}
}
#[derive(Debug)]
struct ArgsBuilder<E: Env, I: Io> {
container_id: Option<ContainerId>,
netns: Option<PathBuf>,
ifname: Option<InterfaceName>,
args: Option<String>,
path: Vec<PathBuf>,
config: Option<NetConf>,
_phantom_e: std::marker::PhantomData<E>,
_phantom_i: std::marker::PhantomData<I>,
}
impl<E: Env, I: Io> ArgsBuilder<E, I> {
const fn new() -> Self {
Self {
container_id: None,
netns: None,
ifname: None,
args: None,
path: Vec::new(),
config: None,
_phantom_e: std::marker::PhantomData,
_phantom_i: std::marker::PhantomData,
}
}
fn container_id(mut self) -> Result<Self, Error> {
self.container_id = E::get::<String>(CNI_CONTAINERID)?
.map(ContainerId::try_from)
.transpose()?;
Ok(self)
}
fn netns(mut self) -> Result<Self, Error> {
self.netns = E::get::<String>(CNI_NETNS)?.map(PathBuf::from);
Ok(self)
}
fn ifname(mut self) -> Result<Self, Error> {
self.ifname = E::get::<String>(CNI_IFNAME)?
.map(InterfaceName::try_from)
.transpose()?;
Ok(self)
}
fn args(mut self) -> Result<Self, Error> {
self.args = E::get::<String>(CNI_ARGS)?;
Ok(self)
}
fn path(mut self) -> Result<Self, Error> {
self.path = E::get::<String>(CNI_PATH)?
.map(|v| env::split_paths(&v).collect())
.unwrap_or_default();
Ok(self)
}
fn config(mut self) -> Result<Self, Error> {
let mut buf = String::new();
I::io_in()
.read_to_string(&mut buf)
.map_err(|e| Error::IOFailure(e.to_string()))?;
self.config =
serde_json::from_str(&buf).map_err(|e| Error::FailedToDecode(e.to_string()))?;
Ok(self)
}
fn validate(self, cmd: Cmd) -> Result<Self, Error> {
let mut missing = Vec::new();
match cmd {
Cmd::Add | Cmd::Check | Cmd::Del => {
if self.container_id.is_none() {
missing.push(CNI_CONTAINERID);
}
if self.netns.is_none() && !matches!(cmd, Cmd::Del) {
missing.push(CNI_NETNS);
}
if self.ifname.is_none() {
missing.push(CNI_IFNAME);
}
}
Cmd::Gc if self.path.is_empty() => missing.push(CNI_PATH),
_ => {}
}
if missing.is_empty() {
Ok(self)
} else {
Err(Error::missing_env(&missing))
}
}
fn build(self) -> Result<Args, Error> {
let config = self.config.ok_or_else(|| {
Error::InvalidNetworkConfig("network configuration is required on stdin".to_string())
})?;
config.validate_name()?;
Ok(Args {
container_id: self.container_id,
netns: self.netns,
ifname: self.ifname,
args: self.args,
path: self.path,
config,
})
}
}