use std::path::PathBuf;
use state_machines::state_machine;
state_machine! {
name: JailMachine,
dynamic: true, initial: Stopped,
states: [Stopped, Starting, Running, Stopping, Failed],
events {
start {
transition: { from: Stopped, to: Starting }
}
started {
transition: { from: Starting, to: Running }
}
stop {
transition: { from: Running, to: Stopping }
}
stopped {
transition: { from: Stopping, to: Stopped }
}
fail {
transition: { from: [Starting, Running, Stopping], to: Failed }
}
recover {
transition: { from: Failed, to: Stopped }
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum State {
Stopped,
Starting,
Running,
Stopping,
Failed,
}
impl State {
pub fn from_str(s: &str) -> Self {
match s {
"Stopped" => State::Stopped,
"Starting" => State::Starting,
"Running" => State::Running,
"Stopping" => State::Stopping,
"Failed" => State::Failed,
_ => State::Stopped, }
}
}
#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct JailConfig {
pub name: String,
pub path: PathBuf,
pub hostname: Option<String>,
pub ips: Vec<std::net::IpAddr>,
}
impl JailConfig {
pub fn new(name: impl Into<String>, path: impl Into<PathBuf>) -> Self {
Self {
name: name.into(),
path: path.into(),
hostname: None,
ips: Vec::new(),
}
}
pub fn hostname(mut self, hostname: impl Into<String>) -> Self {
self.hostname = Some(hostname.into());
self
}
pub fn ip(mut self, addr: std::net::IpAddr) -> Self {
self.ips.push(addr);
self
}
}
pub struct JailInstance {
pub machine: DynamicJailMachine<()>,
#[allow(dead_code)]
pub config: JailConfig,
pub jid: Option<i32>,
}
impl JailInstance {
pub fn new(config: JailConfig) -> Self {
let machine = JailMachine::new(()).into_dynamic();
Self {
machine,
config,
jid: None,
}
}
pub fn state(&self) -> State {
State::from_str(self.machine.current_state())
}
#[allow(dead_code)]
pub fn is_running(&self) -> bool {
self.machine.current_state() == "Running"
}
pub fn start(&mut self) -> Result<(), state_machines::DynamicError> {
self.machine.handle(JailMachineEvent::Start)
}
pub fn started(&mut self) -> Result<(), state_machines::DynamicError> {
self.machine.handle(JailMachineEvent::Started)
}
pub fn stop(&mut self) -> Result<(), state_machines::DynamicError> {
self.machine.handle(JailMachineEvent::Stop)
}
pub fn stopped(&mut self) -> Result<(), state_machines::DynamicError> {
self.machine.handle(JailMachineEvent::Stopped)
}
pub fn fail(&mut self) -> Result<(), state_machines::DynamicError> {
self.machine.handle(JailMachineEvent::Fail)
}
pub fn recover(&mut self) -> Result<(), state_machines::DynamicError> {
self.machine.handle(JailMachineEvent::Recover)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_initial_state() {
let machine = JailMachine::new(()).into_dynamic();
assert_eq!(machine.current_state(), "Stopped");
}
#[test]
fn test_start_transition() {
let mut machine = JailMachine::new(()).into_dynamic();
assert!(machine.handle(JailMachineEvent::Start).is_ok());
assert_eq!(machine.current_state(), "Starting");
}
#[test]
fn test_full_lifecycle() {
let mut machine = JailMachine::new(()).into_dynamic();
machine.handle(JailMachineEvent::Start).unwrap();
assert_eq!(machine.current_state(), "Starting");
machine.handle(JailMachineEvent::Started).unwrap();
assert_eq!(machine.current_state(), "Running");
machine.handle(JailMachineEvent::Stop).unwrap();
assert_eq!(machine.current_state(), "Stopping");
machine.handle(JailMachineEvent::Stopped).unwrap();
assert_eq!(machine.current_state(), "Stopped");
}
#[test]
fn test_fail_and_recover() {
let mut machine = JailMachine::new(()).into_dynamic();
machine.handle(JailMachineEvent::Start).unwrap();
machine.handle(JailMachineEvent::Fail).unwrap();
assert_eq!(machine.current_state(), "Failed");
machine.handle(JailMachineEvent::Recover).unwrap();
assert_eq!(machine.current_state(), "Stopped");
}
#[test]
fn test_invalid_transition() {
let mut machine = JailMachine::new(()).into_dynamic();
assert!(machine.handle(JailMachineEvent::Stop).is_err());
}
#[test]
fn test_jail_instance() {
let config = JailConfig::new("test", "/jails/test");
let mut instance = JailInstance::new(config);
assert_eq!(instance.state(), State::Stopped);
instance.start().unwrap();
assert_eq!(instance.state(), State::Starting);
instance.started().unwrap();
assert!(instance.is_running());
}
}