Saving status, lots of development.

src/daemon.rs

@@ -0,0 +1,122 @@
+// <hive-up - update program fot Kira Linux.>
+// Copyright (C) <2026>  <Kira Foundation>
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+/*
+   hive-up daemon logic
+*/
+
+use std::fs;
+use std::process::Command;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread;
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+use time_format;
+
+use crate::hive_config::HiveConfig;
+use crate::hive_db;
+use crate::hive_system;
+
+#[derive(Debug)]
+pub enum DaemonError {
+    IoError(std::io::Error),
+    DBError(hive_db::DBError),
+    ExecCommandError(hive_system::ExecCommandError),
+    TimestampError,
+}
+
+// 2. Implement From for each wrapped error type
+impl From<std::io::Error> for DaemonError {
+    fn from(err: std::io::Error) -> Self {
+        DaemonError::IoError(err)
+    }
+}
+
+impl From<hive_db::DBError> for DaemonError {
+    fn from(err: hive_db::DBError) -> Self {
+        DaemonError::DBError(err)
+    }
+}
+
+impl From<hive_system::ExecCommandError> for DaemonError {
+    fn from(err: hive_system::ExecCommandError) -> Self {
+        DaemonError::ExecCommandError(err)
+    }
+}
+
+impl std::fmt::Display for DaemonError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            DaemonError::IoError(e) => write!(f, "IO Error: {}", e),
+            DaemonError::DBError(e) => {
+                write!(f, "Database error: {}", e)
+            },
+            DaemonError::ExecCommandError(e) => {
+                write!(f, "Exec Command Error: {}", e)
+            },
+            DaemonError::TimestampError => write!(f, "Timestamp Error"),
+        }
+    }
+}
+
+// Implement std::error::Error
+impl std::error::Error for DaemonError {}
+
+fn get_timestamp_sec() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("Time went backwards")
+        .as_secs()
+}
+
+pub fn run(
+    config: HiveConfig,
+    term_flag: Arc<AtomicBool>,
+    reload_flag: Arc<AtomicBool>,
+) -> Result<(), DaemonError> {
+    let duration = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("Time went backwards");
+
+    let mut bzz_db = hive_db::read_db()?;
+
+    //duration.as_secs()
+    let keep_going = true;
+
+    //last_check.
+    while keep_going {
+        thread::sleep(Duration::from_secs(1));
+
+        // if updates check is turned on
+        if config.update.updates_check_interval != 0 {
+            let timestamp = get_timestamp_sec();
+            let hours_since_update_check = timestamp
+                .checked_sub(bzz_db.last_update_check)
+                .ok_or(DaemonError::TimestampError)?
+                / 3600;
+
+            if hours_since_update_check > config.update.updates_check_interval {
+                // perform update check
+                let packages_num = hive_system::check_updates()?;
+                // updating las tupdate timestamp in db
+                bzz_db.last_update_check = get_timestamp_sec();
+                hive_db::write_db(&bzz_db)?;
+            }
+        }
+    }
+
+    Ok(())
+}