Struct SystemdUnit 

pub struct SystemdUnit(/* private fields */);

The root of a systemd unit file

Implementations

impl SystemdUnit

pub fn sections(&self) -> impl Iterator<Item = Section>

Get all sections in the file

pub fn get_section(&self, name: &str) -> Option<Section>

Get a specific section by name

pub fn add_section(&mut self, name: &str)

Add a new section to the unit file

pub fn syntax(&self) -> &SyntaxNode<Lang>

Get the raw syntax node

pub fn text(&self) -> String

Convert to a string (same as Display::fmt)

pub fn from_file(path: &Path) -> Result<Self, Error>

Load from a file

pub fn write_to_file(&self, path: &Path) -> Result<(), Error>

Write to a file

impl SystemdUnit

pub fn from_file_with_dropins(path: &Path) -> Result<Self, Error>

Load a unit file with drop-in configuration files merged

This loads the main unit file and then merges all .conf files from the drop-in directory (<unit>.d/). Drop-in files are applied in lexicographic order.

Drop-in directories are searched in the same directory as the unit file. For example, if loading /etc/systemd/system/foo.service, this will look for drop-ins in /etc/systemd/system/foo.service.d/*.conf.

Example

// Loads foo.service and merges foo.service.d/*.conf
let unit = SystemdUnit::from_file_with_dropins(
    Path::new("/etc/systemd/system/foo.service")
).unwrap();

pub fn merge_dropin(&mut self, dropin: &SystemdUnit)

Merge a drop-in unit file into this unit

This applies the settings from a drop-in file to the current unit. According to systemd behavior:

• New sections are added
• Existing keys are replaced with values from the drop-in
• Multiple values for the same key (e.g., Wants=) are accumulated for directives that support accumulation

Example

let mut main = SystemdUnit::from_str("[Unit]\nDescription=Main\n").unwrap();
let dropin = SystemdUnit::from_str("[Unit]\nAfter=network.target\n").unwrap();

main.merge_dropin(&dropin);

let section = main.get_section("Unit").unwrap();
assert_eq!(section.get("Description"), Some("Main".to_string()));
assert_eq!(section.get("After"), Some("network.target".to_string()));

Trait Implementations

impl AstNode for SystemdUnit

type Language = Lang

fn can_cast(kind: SyntaxKind) -> bool

fn cast(node: SyntaxNode<Lang>) -> Option<Self>

fn syntax(&self) -> &SyntaxNode<Lang>

fn clone_for_update(&self) -> Self

where Self: Sized,

fn clone_subtree(&self) -> Self

where Self: Sized,

impl Clone for SystemdUnit

fn clone(&self) -> SystemdUnit

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SystemdUnit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for SystemdUnit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for SystemdUnit

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for SystemdUnit

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SystemdUnit

fn eq(&self, other: &SystemdUnit) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for SystemdUnit

impl StructuralPartialEq for SystemdUnit