sysd_manager_comcontroler/

lib.rs

#![allow(unused_must_use)]
pub mod analyze;
pub mod data;
pub mod enums;
pub mod errors;
mod file;
mod journal;
pub mod journal_data;
#[cfg(not(any(feature = "flatpak", feature = "appimage")))]
pub mod proxy_switcher;
pub mod socket_unit;
pub mod sysdbus;
pub mod time_handling;

use crate::data::ListedLoadedUnit;
use crate::{
    data::UnitPropertySetter,
    enums::{ActiveState, LoadState, StartStopMode, UnitFileStatus},
    file::save_text_to_file,
    journal_data::Boot,
    sysdbus::{
        ListedUnitFile,
        dbus_proxies::{systemd_manager, systemd_manager_async},
    },
    time_handling::TimestampStyle,
};
use base::file::create_drop_in_path_file;
use base::{
    enums::UnitDBusLevel,
    file::{commander_blocking, flatpak_host_file_path, test_flatpak_spawn},
    proxy::{DisEnAbleUnitFiles, DisEnAbleUnitFilesResponse},
};
use data::{UnitInfo, UnitProcess};
use enumflags2::{BitFlag, BitFlags};
use enums::{CleanOption, DependencyType, DisEnableFlags, KillWho, UnitType};
use errors::SystemdErrors;
use flagset::{FlagSet, flags};
use glib::Quark;
use journal_data::{EventRange, JournalEventChunk};
use std::{
    any::Any,
    collections::{BTreeMap, BTreeSet, HashMap},
    fs::File,
    io::Read,
    sync::OnceLock,
    time::{SystemTime, UNIX_EPOCH},
};
use tokio::{runtime::Runtime, sync::mpsc};
use tracing::{error, info, warn};
use zvariant::{OwnedObjectPath, OwnedValue};

#[cfg(not(any(feature = "flatpak", feature = "appimage")))]
use crate::sysdbus::to_proxy;

#[cfg(not(any(feature = "flatpak", feature = "appimage")))]
use base::consts::PROXY_SERVICE;

#[derive(Default, Clone, PartialEq, Debug)]
pub enum BootFilter {
    #[default]
    Current,
    All,
    Id(String),
}

#[derive(Clone, Debug)]
// #[allow(unused)]
pub struct SystemdUnitFile {
    pub full_name: String,
    pub status_code: UnitFileStatus,
    pub level: UnitDBusLevel,
    pub file_path: String,
}

#[derive(Debug, Default)]
pub struct UpdatedUnitInfo {
    pub primary: String,
    // pub object_path: String,
    pub description: Option<String>,
    pub load_state: Option<LoadState>,
    pub sub_state: Option<String>,
    pub active_state: Option<ActiveState>,
    pub unit_file_preset: Option<String>,
    pub valid_unit_name: bool,
    pub fragment_path: Option<String>,
    pub enablement_status: Option<UnitFileStatus>,
    pub level: UnitDBusLevel,
}

impl UpdatedUnitInfo {
    fn new(primary: String, level: UnitDBusLevel) -> Self {
        Self {
            primary,
            level,
            ..Default::default()
        }
    }
}

flags! {
    pub enum UnitPropertiesFlags : u8 {
        EnablementStatus,
        ActiveStatus,
        Description,
        LoadState,
        SubState,
        UnitFilePreset,
        FragmentPath,
    }
}

#[derive(Debug, Clone, Copy)]
pub struct UnitProperties(pub FlagSet<UnitPropertiesFlags>);

impl UnitProperties {
    // fn new(flags: impl Into<FlagSet<UnitPropertiesFlags>>) -> UnitProperties {
    //     UnitProperties(flags.into())
    // }
    //
}

pub struct CompleteUnitPropertiesCallParams {
    pub level: UnitDBusLevel,
    pub unit_name: String,
    pub object_path: String,
    pub status: UnitFileStatus,
}

impl CompleteUnitPropertiesCallParams {
    pub fn new(unit: &UnitInfo) -> Self {
        // println!("Has status {:?} {:?}", unit.enable_status(), unit.primary())

        Self::new_params(
            unit.dbus_level(),
            unit.primary(),
            unit.object_path(),
            unit.enable_status(),
        )
    }

    pub fn new_params(
        level: UnitDBusLevel,
        unit_name: String,
        object_path: String,
        status: UnitFileStatus,
    ) -> Self {
        Self {
            level,
            unit_name,
            object_path,
            status,
        }
    }
}

pub fn runtime() -> &'static Runtime {
    static RUNTIME: OnceLock<Runtime> = OnceLock::new();
    RUNTIME.get_or_init(|| Runtime::new().expect("Setting up tokio runtime needs to succeed."))
}

///Try to Start Proxy
#[cfg(not(any(feature = "flatpak", feature = "appimage")))]
pub async fn init_proxy_async(run_mode: base::RunMode) {
    if let Err(e) = sysdbus::init_proxy_async(run_mode).await {
        error!("Fail starting Proxy. Error {e:?}");
    }
}

#[cfg(not(any(feature = "flatpak", feature = "appimage")))]
pub fn shut_down() {
    sysdbus::shut_down_sysd_proxy();
}

pub fn get_unit_file_state(
    level: UnitDBusLevel,
    primary_name: &str,
) -> Result<UnitFileStatus, SystemdErrors> {
    sysdbus::get_unit_file_state(level, primary_name)
}

pub async fn list_units_description_and_state_async(
    level: UnitDBusLevel,
) -> Result<(Vec<ListedLoadedUnit>, Vec<SystemdUnitFile>), SystemdErrors> {
    sysdbus::list_units_description_and_state_async(level).await
}

#[derive(Debug)]
pub enum ListUnitResponse {
    Loaded(UnitDBusLevel, Vec<ListedLoadedUnit>),
    File(UnitDBusLevel, Vec<ListedUnitFile>),
}

impl ListUnitResponse {
    pub fn r_len(&self) -> (usize, usize) {
        match self {
            ListUnitResponse::Loaded(_, items) => (items.len(), 0),
            ListUnitResponse::File(_, items) => (0, items.len()),
        }
    }

    pub fn t_len(&self) -> usize {
        match self {
            ListUnitResponse::Loaded(_, lunits) => lunits.len(),
            ListUnitResponse::File(_, items) => items.len(),
        }
    }
    pub fn update_flags(&self) -> FlagSet<UnitPropertiesFlags> {
        match self {
            ListUnitResponse::Loaded(_, _) => {
                UnitPropertiesFlags::EnablementStatus
                    | UnitPropertiesFlags::Description
                    | UnitPropertiesFlags::LoadState
                    | UnitPropertiesFlags::SubState
                    | UnitPropertiesFlags::UnitFilePreset
            }

            ListUnitResponse::File(_, _) => {
                UnitPropertiesFlags::ActiveStatus
                    | UnitPropertiesFlags::Description
                    | UnitPropertiesFlags::LoadState
                    | UnitPropertiesFlags::SubState
                    | UnitPropertiesFlags::UnitFilePreset
            }
        }
    }
}

pub async fn list_loaded_units(level: UnitDBusLevel) -> Result<ListUnitResponse, SystemdErrors> {
    let v = systemd_manager_async(level).await?.list_units().await?;
    Ok(ListUnitResponse::Loaded(level, v))
}

pub async fn list_loaded_units_by_patterns(
    level: UnitDBusLevel,
    patterns: &[&str],
) -> Result<ListUnitResponse, SystemdErrors> {
    let v = systemd_manager_async(level)
        .await?
        .list_units_by_patterns(&[], patterns)
        .await?;
    Ok(ListUnitResponse::Loaded(level, v))
}

pub async fn list_loaded_units_timers(
    level: UnitDBusLevel,
) -> Result<ListUnitResponse, SystemdErrors> {
    list_loaded_units_by_patterns(level, &["*.timer"]).await
}

pub async fn list_loaded_units_sockets(
    level: UnitDBusLevel,
) -> Result<ListUnitResponse, SystemdErrors> {
    list_loaded_units_by_patterns(level, &["*.socket"]).await
}

pub async fn list_loaded_units_paths(
    level: UnitDBusLevel,
) -> Result<ListUnitResponse, SystemdErrors> {
    list_loaded_units_by_patterns(level, &["*.path"]).await
}

pub async fn list_loaded_units_automounts(
    level: UnitDBusLevel,
) -> Result<ListUnitResponse, SystemdErrors> {
    list_loaded_units_by_patterns(level, &["*.automount"]).await
}

pub async fn list_unit_files(level: UnitDBusLevel) -> Result<ListUnitResponse, SystemdErrors> {
    let v = systemd_manager_async(level)
        .await?
        .list_unit_files()
        .await?;
    Ok(ListUnitResponse::File(level, v))
}

pub async fn list_unit_files_by_patterns(
    level: UnitDBusLevel,
    patterns: &[&str],
) -> Result<ListUnitResponse, SystemdErrors> {
    let v = systemd_manager_async(level)
        .await?
        .list_unit_files_by_patterns(&[], patterns)
        .await?;
    Ok(ListUnitResponse::File(level, v))
}

pub async fn list_unit_files_timers(
    level: UnitDBusLevel,
) -> Result<ListUnitResponse, SystemdErrors> {
    list_unit_files_by_patterns(level, &["*.timer"]).await
}

pub async fn list_unit_files_sockets(
    level: UnitDBusLevel,
) -> Result<ListUnitResponse, SystemdErrors> {
    list_unit_files_by_patterns(level, &["*.socket"]).await
}

pub async fn list_unit_files_paths(
    level: UnitDBusLevel,
) -> Result<ListUnitResponse, SystemdErrors> {
    list_unit_files_by_patterns(level, &["*.path"]).await
}

pub async fn list_unit_files_automounts(
    level: UnitDBusLevel,
) -> Result<ListUnitResponse, SystemdErrors> {
    list_unit_files_by_patterns(level, &["*.automount"]).await
}

pub async fn complete_unit_information(
    units: &[CompleteUnitPropertiesCallParams],
) -> Result<Vec<UpdatedUnitInfo>, SystemdErrors> {
    sysdbus::complete_unit_information(units).await
}

pub async fn complete_single_unit_information(
    primary_name: String,
    level: UnitDBusLevel,
    object_path: String,
    status: UnitFileStatus,
) -> Result<Vec<UpdatedUnitInfo>, SystemdErrors> {
    let units = [CompleteUnitPropertiesCallParams::new_params(
        level,
        primary_name,
        object_path,
        status,
    )];
    sysdbus::complete_unit_information(&units).await
}

/// Takes a unit name as input and attempts to start it
/// # returns
/// job_path
pub fn start_unit(
    level: UnitDBusLevel,
    unit_name: &str,
    mode: StartStopMode,
) -> Result<String, SystemdErrors> {
    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    match level {
        UnitDBusLevel::System | UnitDBusLevel::Both => {
            if proxy_switcher::PROXY_SWITCHER.start() && !unit_name.starts_with(PROXY_SERVICE) {
                proxy_call_blocking!(start_unit, unit_name, mode.as_str())
            } else {
                systemd_manager()
                    .start_unit(unit_name, mode.as_str())
                    .map(|o| o.to_string())
                    .map_err(|err| err.into())
                // sysdbus::start_unit(level, unit_name, mode)
            }
        }

        UnitDBusLevel::UserSession => sysdbus::dbus_proxies::systemd_manager_session()
            .start_unit(unit_name, mode.as_str())
            .map(|o| o.to_string())
            .map_err(|err| err.into()),
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        use crate::sysdbus::dbus_proxies::systemd_manager_blocking;

        systemd_manager_blocking(level)
            .start_unit(unit_name, mode.as_str())
            .map(|o| o.to_string())
            .map_err(|err| err.into())
    }
}

/// Takes a unit name as input and attempts to stop it.
pub fn stop_unit(
    level: UnitDBusLevel,
    unit_name: &str,
    mode: StartStopMode,
) -> Result<String, SystemdErrors> {
    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    match level {
        UnitDBusLevel::System | UnitDBusLevel::Both => {
            if proxy_switcher::PROXY_SWITCHER.stop() && !unit_name.starts_with(PROXY_SERVICE) {
                proxy_call_blocking!(stop_unit, unit_name, mode.as_str())
            } else {
                systemd_manager()
                    .stop_unit(unit_name, mode.as_str())
                    .map(|o| o.to_string())
                    .map_err(|err| err.into())

                // sysdbus::stop_unit(level, unit_name, mode)
            }
        }

        UnitDBusLevel::UserSession => sysdbus::dbus_proxies::systemd_manager_session()
            .stop_unit(unit_name, mode.as_str())
            .map(|o| o.to_string())
            .map_err(|err| err.into()),
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        use crate::sysdbus::dbus_proxies::systemd_manager_blocking;

        systemd_manager_blocking(level)
            .stop_unit(unit_name, mode.as_str())
            .map(|o| o.to_string())
            .map_err(|err| err.into())
    }
}

pub fn restart_unit(
    level: UnitDBusLevel,
    unit_name: &str,
    mode: StartStopMode,
) -> Result<String, SystemdErrors> {
    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    match level {
        UnitDBusLevel::System | UnitDBusLevel::Both => {
            if proxy_switcher::PROXY_SWITCHER.restart() && !unit_name.starts_with(PROXY_SERVICE) {
                proxy_call_blocking!(restart_unit, unit_name, mode.as_str())
            } else {
                systemd_manager()
                    .restart_unit(unit_name, mode.as_str())
                    .map(|o| o.to_string())
                    .map_err(|err| err.into())
                // sysdbus::restart_unit(level, unit_name, mode)
            }
        }

        UnitDBusLevel::UserSession => sysdbus::dbus_proxies::systemd_manager_session()
            .restart_unit(unit_name, mode.as_str())
            .map(|o| o.to_string())
            .map_err(|err| err.into()),
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        use crate::sysdbus::dbus_proxies::systemd_manager_blocking;

        systemd_manager_blocking(level)
            .restart_unit(unit_name, mode.as_str())
            .map(|o| o.to_string())
            .map_err(|err| err.into())
    }
}

pub fn disenable_unit_file(
    primary_name: &str,
    level: UnitDBusLevel,
    enable_status: UnitFileStatus,
    expected_status: UnitFileStatus,
) -> Result<DisEnAbleUnitFilesResponse, SystemdErrors> {
    match expected_status {
        UnitFileStatus::Enabled | UnitFileStatus::EnabledRuntime => enable_unit_file(
            level,
            primary_name,
            DisEnableFlags::SdSystemdUnitForce.into(),
        ),
        _ => {
            let flags: BitFlags<DisEnableFlags> = if enable_status.is_runtime() {
                DisEnableFlags::SdSystemdUnitRuntime.into()
            } else {
                DisEnableFlags::empty()
            };

            disable_unit_file(level, primary_name, flags)
        }
    }
}

pub fn enable_unit_file(
    level: UnitDBusLevel,
    unit_file: &str,
    flags: BitFlags<DisEnableFlags>,
) -> Result<DisEnAbleUnitFilesResponse, SystemdErrors> {
    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    match level {
        UnitDBusLevel::System | UnitDBusLevel::Both => {
            if proxy_switcher::PROXY_SWITCHER.enable_unit_file() {
                proxy_call_blocking!(
                    enable_unit_files_with_flags,
                    &[unit_file],
                    flags.bits_c() as u64
                )
            } else {
                systemd_manager()
                    .enable_unit_files_with_flags(&[unit_file], flags.bits_c() as u64)
                    .map_err(|err| err.into())
            }
        }
        UnitDBusLevel::UserSession => sysdbus::dbus_proxies::systemd_manager_session()
            .enable_unit_files_with_flags(&[unit_file], flags.bits_c() as u64)
            .map_err(|err| err.into()),
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        use crate::sysdbus::dbus_proxies::systemd_manager_blocking;
        systemd_manager_blocking(level)
            .enable_unit_files_with_flags(&[unit_file], flags.bits_c() as u64)
            .map_err(|err| err.into())
    }
}

pub fn disable_unit_file(
    level: UnitDBusLevel,
    unit_file: &str,
    flags: BitFlags<DisEnableFlags>,
) -> Result<DisEnAbleUnitFilesResponse, SystemdErrors> {
    info!("{:?} {} {:?}", level, unit_file, flags.bits_c());
    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    match level {
        UnitDBusLevel::System | UnitDBusLevel::Both => {
            if proxy_switcher::PROXY_SWITCHER.disable_unit_file() {
                proxy_call_blocking!(
                    disable_unit_files_with_flags,
                    &[unit_file],
                    flags.bits_c() as u64
                )
            } else {
                systemd_manager()
                    .disable_unit_files_with_flags_and_install_info(
                        &[unit_file],
                        flags.bits_c() as u64,
                    )
                    .map_err(|err| err.into())
            }
        }
        UnitDBusLevel::UserSession => sysdbus::dbus_proxies::systemd_manager_session()
            .disable_unit_files_with_flags_and_install_info(&[unit_file], flags.bits_c() as u64)
            .map_err(|err| err.into()),
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        use crate::sysdbus::dbus_proxies::systemd_manager_blocking;
        systemd_manager_blocking(level)
            .disable_unit_files_with_flags_and_install_info(&[unit_file], flags.bits_c() as u64)
            .map_err(|err| err.into())
    }
}

pub async fn fetch_drop_in_paths(
    level: UnitDBusLevel,
    unit_name: &str,
) -> Result<Vec<String>, SystemdErrors> {
    sysdbus::fetch_drop_in_paths(level, unit_name).await
}
/// Read the unit file and return it's contents so that we can display it
pub fn fetch_unit_file_content(
    file_path: Option<&str>,
    unit_primary_name: &str,
) -> Result<String, SystemdErrors> {
    let Some(file_path) = file_path else {
        warn!("No file path for {:?}", unit_primary_name);
        return Ok(String::new());
    };

    file_open_get_content(file_path, unit_primary_name)
}

#[allow(unused)]
fn flatpak_file_open_get_content(
    file_path: &str,
    unit_primary_name: &str,
) -> Result<String, SystemdErrors> {
    file_open_get_content(file_path, unit_primary_name).or_else(|e| {
        info!("Trying to fetch file content through 'cat' command, because {e:?}");
        file_open_get_content_cat(file_path, unit_primary_name)
    })
}

fn file_open_get_content_cat(
    file_path: &str,
    unit_primary_name: &str,
) -> Result<String, SystemdErrors> {
    info!(
        "Flatpak Fetching file content Unit: {} File \"{file_path}\"",
        unit_primary_name
    );
    //Use the REAL path because try to acceess through the 'cat' command
    commander_output(&["cat", file_path], None)
        .map(|cat_output| String::from_utf8_lossy(&cat_output.stdout).to_string())
        .inspect_err(|e| warn!("Can't open file {file_path:?} with 'cat' command, reason: {e:?}"))
}

fn file_open_get_content(
    file_path: &str,
    unit_primary_name: &str,
) -> Result<String, SystemdErrors> {
    //To get the relative path from a Flatpak
    let file_path = flatpak_host_file_path(file_path);

    info!(
        "Fetching file content Unit: {} File: {}",
        unit_primary_name,
        file_path.display()
    );

    let mut file = File::open(&file_path).map_err(|e| {
        warn!(
            "Can't open file \"{}\", reason: {e} {:?}",
            file_path.display(),
            e.kind()
        );
        SystemdErrors::IoError(e)
    })?;

    let mut output = String::new();
    let _ = file.read_to_string(&mut output);

    Ok(output)
}

/// Obtains the journal log for the given unit.
pub fn get_unit_journal(
    primary_name: String,
    level: UnitDBusLevel,
    boot_filter: BootFilter,
    range: EventRange,
    message_max_char: usize,
    timestamp_style: TimestampStyle,
) -> Result<JournalEventChunk, SystemdErrors> {
    journal::get_unit_journal_events(
        primary_name,
        level,
        boot_filter,
        range,
        message_max_char,
        timestamp_style,
    )
}

#[allow(clippy::too_many_arguments)]
pub fn get_unit_journal_continuous(
    unit_name: String,
    level: UnitDBusLevel,
    range: EventRange,
    journal_continuous_receiver: std::sync::mpsc::Receiver<()>,
    sender: std::sync::mpsc::Sender<JournalEventChunk>,
    message_max_char: usize,
    timestamp_style: TimestampStyle,
    check_for_new_journal_entry: fn(),
) {
    if let Err(err) = journal::get_unit_journal_events_continuous(
        unit_name,
        level,
        range,
        journal_continuous_receiver,
        sender,
        message_max_char,
        timestamp_style,
        check_for_new_journal_entry,
    ) {
        warn!(
            "Journal TailError type: {:?}  Error: {:?}",
            err.type_id(),
            err
        );
    } else {
        warn!("Ok journal tail thread finished");
    }
}

pub fn list_boots() -> Result<Vec<Boot>, SystemdErrors> {
    journal::list_boots()
}

pub fn fetch_last_time() -> Result<u64, SystemdErrors> {
    journal::fetch_last_time()
}

pub fn commander_output(
    prog_n_args: &[&str],
    environment_variables: Option<&[(&str, &str)]>,
) -> Result<std::process::Output, SystemdErrors> {
    match commander_blocking(prog_n_args, environment_variables).output() {
        Ok(output) => {
            if cfg!(feature = "flatpak") {
                info!("Command Exit status: {}", output.status);

                if !output.status.success() {
                    warn!("Flatpak mode, command line did not succeed, please investigate.");
                    error!("Command exit status: {}", output.status);
                    info!(
                        "{}",
                        String::from_utf8(output.stdout).expect("from_utf8 failed")
                    );
                    error!(
                        "{}",
                        String::from_utf8(output.stderr).expect("from_utf8 failed")
                    );
                    let vec = prog_n_args.iter().map(|s| s.to_string()).collect();
                    return Err(SystemdErrors::CmdNoFreedesktopFlatpakPermission(
                        Some(vec),
                        None,
                    ));
                }
            }
            Ok(output)
        }
        Err(err) => {
            error!("commander_output {err}");

            match test_flatpak_spawn() {
                Ok(()) => Err(SystemdErrors::IoError(err)),
                Err(e1) => {
                    error!("commander_output e1 {e1}");
                    Err(SystemdErrors::CmdNoFlatpakSpawn)
                }
            }
        }
    }
}

pub fn generate_file_uri(file_path: &str) -> String {
    let flatpak_host_file_path = flatpak_host_file_path(file_path);
    format!("file://{}", flatpak_host_file_path.display())
}

pub fn fetch_system_info() -> Result<Vec<(UnitType, String, String)>, SystemdErrors> {
    //TODO check with Session (user)
    sysdbus::fetch_system_info(UnitDBusLevel::System)
}

pub fn fetch_system_unit_info_native(
    unit: &UnitInfo,
) -> Result<Vec<(UnitType, String, OwnedValue)>, SystemdErrors> {
    let level = unit.dbus_level();
    let unit_type: UnitType = unit.unit_type();
    let object_path = unit.object_path();

    sysdbus::fetch_system_unit_info_native(level, &object_path, unit_type)
}

pub fn fetch_system_unit_info_native_map(
    unit: &UnitInfo,
) -> Result<HashMap<String, OwnedValue>, SystemdErrors> {
    let level = unit.dbus_level();
    let unit_type: UnitType = unit.unit_type();
    let object_path = unit.object_path();

    sysdbus::fetch_system_unit_info_native_map(level, &object_path, unit_type)
}

/* fn get_unit_path(unit: &UnitInfo) -> String {
    match unit.object_path() {
        Some(s) => s,
        None => {
            let object_path = sysdbus::unit_dbus_path_from_name(&unit.primary());
            unit.set_object_path(object_path.clone());
            object_path
        }
    }
}
 */
pub fn fetch_unit(
    level: UnitDBusLevel,
    unit_primary_name: &str,
) -> Result<UnitInfo, SystemdErrors> {
    sysdbus::fetch_unit(level, unit_primary_name)
}

pub fn kill_unit(
    level: UnitDBusLevel,
    primary_name: &str,
    who: KillWho,
    signal: i32,
) -> Result<(), SystemdErrors> {
    sysdbus::kill_unit(level, primary_name, who, signal)
}

pub fn freeze_unit(params: Option<(UnitDBusLevel, String)>) -> Result<(), SystemdErrors> {
    if let Some((_level, primary_name)) = params {
        #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
        match _level {
            UnitDBusLevel::System | UnitDBusLevel::Both => {
                if proxy_switcher::PROXY_SWITCHER.freeze() {
                    proxy_call_blocking!(freeze_unit, &primary_name)
                } else {
                    let proxy = systemd_manager();
                    proxy.freeze_unit(&primary_name)?;
                    Ok(())
                }
            }
            UnitDBusLevel::UserSession => sysdbus::dbus_proxies::systemd_manager_session()
                .freeze_unit(&primary_name)
                .map_err(|err| err.into()),
        }

        #[cfg(any(feature = "flatpak", feature = "appimage"))]
        {
            let proxy = systemd_manager();
            proxy.freeze_unit(&primary_name)?;
            Ok(())
        }
    } else {
        Err(SystemdErrors::NoUnit)
    }
}

pub fn thaw_unit(params: Option<(UnitDBusLevel, String)>) -> Result<(), SystemdErrors> {
    let Some((level, primary_name)) = params else {
        return Err(SystemdErrors::NoUnit);
    };

    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    match level {
        UnitDBusLevel::System | UnitDBusLevel::Both => {
            if proxy_switcher::PROXY_SWITCHER.thaw() {
                proxy_call_blocking!(thaw_unit, &primary_name)
            } else {
                let proxy = systemd_manager();
                proxy.thaw_unit(&primary_name)?;
                Ok(())
            }
        }
        UnitDBusLevel::UserSession => sysdbus::dbus_proxies::systemd_manager_session()
            .thaw_unit(&primary_name)
            .map_err(|err| err.into()),
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        use crate::sysdbus::dbus_proxies::systemd_manager_blocking;
        let proxy = systemd_manager_blocking(level);
        proxy.thaw_unit(&primary_name)?;
        Ok(())
    }
}

pub fn reload_unit(
    level: UnitDBusLevel,
    primary_name: &str,
    mode: StartStopMode,
) -> Result<String, SystemdErrors> {
    sysdbus::reload_unit(level, primary_name, mode.as_str())
}

pub fn queue_signal_unit(
    level: UnitDBusLevel,
    primary_name: &str,
    who: KillWho,
    signal: i32,
    value: i32,
) -> Result<(), SystemdErrors> {
    sysdbus::queue_signal_unit(level, primary_name, who, signal, value)
}

pub fn clean_unit(
    level: UnitDBusLevel,
    unit_name: &str,
    what: &[String],
) -> Result<(), SystemdErrors> {
    //just send all if seleted
    let mut what_peekable = what
        .iter()
        .filter(|c_op| *c_op == CleanOption::All.code())
        .peekable();

    let clean_what: Vec<&str> = if what_peekable.peek().is_some() {
        vec![CleanOption::All.code()]
    } else {
        what.iter().map(|s| s.as_str()).collect()
    };

    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    match level {
        UnitDBusLevel::System | UnitDBusLevel::Both => {
            if proxy_switcher::PROXY_SWITCHER.clean() {
                proxy_call_blocking!(clean_unit, unit_name, &clean_what)
            } else {
                let proxy = systemd_manager();
                proxy
                    .clean_unit(unit_name, &clean_what)
                    .map_err(|err| err.into())
            }
        }
        UnitDBusLevel::UserSession => sysdbus::dbus_proxies::systemd_manager_session()
            .clean_unit(unit_name, &clean_what)
            .map_err(|err| err.into()),
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        use crate::sysdbus::dbus_proxies::systemd_manager_blocking;

        systemd_manager_blocking(level)
            .clean_unit(unit_name, &clean_what)
            .map_err(|err| err.into())
    }
}

pub fn mask_unit_files(
    level: UnitDBusLevel,
    primary_name: &str,
    runtime: bool,
    force: bool,
) -> Result<Vec<DisEnAbleUnitFiles>, SystemdErrors> {
    sysdbus::mask_unit_files(level, &[primary_name], runtime, force)
}

pub fn preset_unit_files(
    level: UnitDBusLevel,
    primary_name: &str,
    runtime: bool,
    force: bool,
) -> Result<DisEnAbleUnitFilesResponse, SystemdErrors> {
    sysdbus::preset_unit_file(level, &[primary_name], runtime, force)
}

pub fn reenable_unit_file(
    level: UnitDBusLevel,
    primary_name: &str,
    runtime: bool,
    force: bool,
) -> Result<DisEnAbleUnitFilesResponse, SystemdErrors> {
    sysdbus::reenable_unit_file(level, &[primary_name], runtime, force)
}

pub fn unmask_unit_files(
    level: UnitDBusLevel,
    primary_name: &str,
    runtime: bool,
) -> Result<Vec<DisEnAbleUnitFiles>, SystemdErrors> {
    sysdbus::unmask_unit_files(level, &[primary_name], runtime)
}

pub fn link_unit_files(
    dbus_level: UnitDBusLevel,
    unit_file: &str,
    runtime: bool,
    force: bool,
) -> Result<Vec<DisEnAbleUnitFiles>, SystemdErrors> {
    sysdbus::link_unit_files(dbus_level, &[unit_file], runtime, force)
}

pub async fn daemon_reload(level: UnitDBusLevel) -> Result<(), SystemdErrors> {
    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    if level.user_session() || !proxy_switcher::PROXY_SWITCHER.reload() {
        info!("Reloading Daemon - Direct");
        systemd_manager_async(level)
            .await?
            .reload()
            .await
            .map_err(|err| err.into())
    } else {
        info!("Reloading Daemon - Proxy");
        println!("proxy");
        proxy_call_async!(reload)
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        info!("Reloading Daemon - Direct");
        systemd_manager_async(level)
            .await?
            .reload()
            .await
            .map_err(|err| err.into())
    }
}

#[derive(Debug, PartialEq, Eq)]
pub struct Dependency {
    pub unit_name: String,
    pub state: ActiveState,
    pub children: BTreeSet<Dependency>,
}

impl Dependency {
    pub fn new(unit_name: &str) -> Self {
        Self {
            unit_name: unit_name.to_string(),
            state: ActiveState::Unknown,
            children: BTreeSet::new(),
        }
    }

    fn partial_clone(&self) -> Dependency {
        Self {
            unit_name: self.unit_name.clone(),
            state: self.state,
            children: BTreeSet::new(),
        }
    }
}

impl Ord for Dependency {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.unit_name.cmp(&other.unit_name)
    }
}

impl PartialOrd for Dependency {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

pub fn fetch_unit_dependencies(
    level: UnitDBusLevel,
    primary_name: &str,
    object_path: &str,
    dependency_type: DependencyType,
    plain: bool,
) -> Result<Dependency, SystemdErrors> {
    sysdbus::unit_get_dependencies(level, primary_name, object_path, dependency_type, plain)
}

pub fn get_unit_active_state(
    level: UnitDBusLevel,
    primary_name: &str,
) -> Result<ActiveState, SystemdErrors> {
    let object_path = sysdbus::unit_dbus_path_from_name(primary_name);

    sysdbus::get_unit_active_state(level, &object_path)
}

pub fn retreive_unit_processes(
    unit: &UnitInfo,
) -> Result<BTreeMap<String, BTreeSet<UnitProcess>>, SystemdErrors> {
    let level = unit.dbus_level();

    let unit_processes = sysdbus::retreive_unit_processes(level, &unit.primary())?;

    // let mut unit_processes_out = Vec::with_capacity(unit_processes.len());
    let mut unit_processes_map: BTreeMap<String, BTreeSet<UnitProcess>> = BTreeMap::new();
    for unit_process in unit_processes {
        let unit_process = {
            let Some(unit_name) = unit_process.path.rsplit_once('/').map(|a| a.1) else {
                warn!("No unit name for path {:?}", unit_process.path);
                continue;
            };

            let unit_name_idx = unit_process.path.len() - unit_name.len();

            UnitProcess {
                path: unit_process.path,
                pid: unit_process.pid,
                name: unit_process.name,
                unit_name: unit_name_idx,
            }
        };

        if let Some(set) = unit_processes_map.get_mut(unit_process.unit_name()) {
            set.insert(unit_process);
        } else {
            let mut set = BTreeSet::new();
            let key = unit_process.unit_name().to_string();
            set.insert(unit_process);
            unit_processes_map.insert(key, set);
        }
    }

    Ok(unit_processes_map)
}

#[derive(Debug)]
pub struct SystemdSignalRow {
    pub time_stamp: u64,
    pub signal: SystemdSignal,
}

impl SystemdSignalRow {
    pub fn new(signal: SystemdSignal) -> Self {
        let current_system_time = SystemTime::now();
        let since_the_epoch = current_system_time
            .duration_since(UNIX_EPOCH)
            .expect("Time went backwards");
        let time_stamp =
            since_the_epoch.as_secs() * 1_000_000 + since_the_epoch.subsec_nanos() as u64 / 1_000;
        SystemdSignalRow { time_stamp, signal }
    }

    pub fn type_text(&self) -> &str {
        self.signal.type_text()
    }

    pub fn details(&self) -> String {
        self.signal.details()
    }
}

#[derive(Debug)]
pub enum SystemdSignal {
    UnitNew(String, OwnedObjectPath),
    UnitRemoved(String, OwnedObjectPath),
    JobNew(u32, OwnedObjectPath, String),
    JobRemoved(u32, OwnedObjectPath, String, String),
    StartupFinished(u64, u64, u64, u64, u64, u64),
    UnitFilesChanged,
    Reloading(bool),
}

impl SystemdSignal {
    pub fn type_text(&self) -> &str {
        match self {
            SystemdSignal::UnitNew(_, _) => "UnitNew",
            SystemdSignal::UnitRemoved(_, _) => "UnitRemoved",
            SystemdSignal::JobNew(_, _, _) => "JobNew",
            SystemdSignal::JobRemoved(_, _, _, _) => "JobRemoved",
            SystemdSignal::StartupFinished(_, _, _, _, _, _) => "StartupFinished",
            SystemdSignal::UnitFilesChanged => "UnitFilesChanged",
            SystemdSignal::Reloading(_) => "Reloading",
        }
    }

    pub fn details(&self) -> String {
        match self {
            SystemdSignal::UnitNew(id, unit) => format!("{id} {unit}"),
            SystemdSignal::UnitRemoved(id, unit) => format!("{id} {unit}"),
            SystemdSignal::JobNew(id, job, unit) => {
                format!("unit={unit} id={id} path={job}")
            }
            SystemdSignal::JobRemoved(id, job, unit, result) => {
                format!("unit={unit} id={id} path={job} result={result}")
            }
            SystemdSignal::StartupFinished(firmware, loader, kernel, initrd, userspace, total) => {
                format!(
                    "firmware={firmware} loader={loader} kernel={kernel} initrd={initrd} userspace={userspace} total={total}",
                )
            }
            SystemdSignal::UnitFilesChanged => String::new(),
            SystemdSignal::Reloading(active) => format!("firmware={active}"),
        }
    }
}

pub async fn watch_systemd_signals(
    systemd_signal_sender: mpsc::Sender<SystemdSignalRow>,
    cancellation_token: tokio_util::sync::CancellationToken,
) {
    if let Err(err) =
        sysdbus::watcher::watch_systemd_signals(systemd_signal_sender, cancellation_token).await
    {
        error!("Error listening to jobs {err:?}");
    }
}

pub async fn test(test_name: &str, level: UnitDBusLevel) {
    info!("Testing {test_name:?}");

    if let Err(error) = sysdbus::test(test_name, level).await {
        error!("{error:#?}");
    }
}

#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
pub struct UnitPropertyFetch {
    pub name: String,
    pub signature: String,
    pub access: String,
}

impl UnitPropertyFetch {
    fn new(p: &zbus_xml::Property) -> Self {
        let access = match p.access() {
            zbus_xml::PropertyAccess::Read => "read",
            zbus_xml::PropertyAccess::Write => "write",
            zbus_xml::PropertyAccess::ReadWrite => "readwrite",
        };

        UnitPropertyFetch {
            name: p.name().to_string(),
            signature: p.ty().to_string(),
            access: access.to_string(),
        }
    }
}

pub async fn fetch_unit_interface_properties()
-> Result<BTreeMap<String, Vec<UnitPropertyFetch>>, SystemdErrors> {
    sysdbus::fetch_unit_interface_properties().await
}

pub async fn fetch_unit_properties(
    level: UnitDBusLevel,
    unit_primary_name: &str,
    path: &str,
    unit_properties: UnitProperties,
    properties: Vec<(UnitType, &str, Quark)>,
) -> Result<Vec<UnitPropertySetter>, SystemdErrors> {
    sysdbus::fetch_unit_properties(level, unit_primary_name, path, unit_properties, properties)
        .await
}

pub fn fetch_unit_property_blocking(
    level: UnitDBusLevel,
    unit_primary_name: &str,
    unit_type: UnitType,
    unit_property: &str,
) -> Result<OwnedValue, SystemdErrors> {
    sysdbus::fetch_unit_property_blocking(level, unit_primary_name, unit_type, unit_property)
}

pub async fn create_drop_in(
    user_session: bool,
    runtime: bool,
    unit_name: &str,
    file_name: &str,
    content: &str,
) -> Result<String, SystemdErrors> {
    let file_path = create_drop_in_path_file(unit_name, runtime, user_session, file_name)?;

    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    let result = if user_session || !proxy_switcher::PROXY_SWITCHER.create_dropin() {
        file::create_drop_in(user_session, &file_path, content).await
    } else {
        proxy_call_async!(create_drop_in, runtime, unit_name, &file_path, content)
    };

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    let result = file::create_drop_in(user_session, &file_path, content).await;

    result.map(|_| file_path)
}

pub async fn save_file(
    level: UnitDBusLevel,
    file_path: &str,
    content: &str,
) -> Result<u64, SystemdErrors> {
    info!("Saving file {file_path:?}");

    let user_session = level.user_session();
    //TODO check the case of /run

    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    if user_session || !proxy_switcher::PROXY_SWITCHER.save_file() {
        save_text_to_file(file_path, content, user_session).await
    } else {
        proxy_call_async!(save_file, file_path, content)
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    save_text_to_file(file_path, content, user_session).await
}

pub async fn revert_unit_file_full(
    level: UnitDBusLevel,
    unit_name: &str,
) -> Result<Vec<DisEnAbleUnitFiles>, SystemdErrors> {
    info!("Reverting unit file {unit_name:?}");

    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
    if level.user_session() || !proxy_switcher::PROXY_SWITCHER.revert_unit_file() {
        systemd_manager_async(level)
            .await?
            .revert_unit_files(&[unit_name])
            .await
            .map_err(|err| err.into())
    } else {
        proxy_call_async!(revert_unit_files, &[unit_name])
    }

    #[cfg(any(feature = "flatpak", feature = "appimage"))]
    {
        systemd_manager_async(level)
            .await?
            .revert_unit_files(&[unit_name])
            .await
            .map_err(|err| err.into())
    }
}
pub async fn fill_list_unit_files(
    level: UnitDBusLevel,
) -> Result<Vec<SystemdUnitFile>, SystemdErrors> {
    sysdbus::fill_list_unit_files(level).await
}