Adding hive-up.tml config file, db auto creation, and a bit of refactoring.

Cargo.lock

@@ -220,7 +220,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hive-up"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "clap",
  "nix",
@@ -235,9 +235,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.14.0"
+version = "2.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+checksum = "07aa2048142242915a31d35844fb311e0e53fcca590c3a0a40dcf1b841fa09eb"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -470,9 +470,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+checksum = "e6275cddf4610d1775e6d1fe9469b2e77d0f39fd98fb7450901b821e0c53649f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -501,15 +501,15 @@ dependencies = [
 
 [[package]]
 name = "time-format"
-version = "1.2.2"
+version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "caa08af685f978227b475da86d38312cd1acd5024338bf53a1ab9a799219507d"
+checksum = "fb54c799611991d3d4a66fee3ff17b9f600c2a0f8c0d34e8209dbd153ff0a87b"
 
 [[package]]
 name = "toml"
-version = "1.1.4+spec-1.1.0"
+version = "1.1.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3aace63f4bbcdfc2c965b059de67119c89c4017a70d633be6c104910f67056f5"
+checksum = "12c0ba9680044b4ce98d391a62094047eada0d64860b80166c39f4a6b5640785"
 dependencies = [
  "indexmap",
  "serde_core",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hive-up"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 
 [dependencies]
@@ -13,3 +13,14 @@ serde_json = "1.0"
 signal-hook = "0.4"
 time-format = "1.2"
 toml = "1.1"
+
+[profile.release]
+lto = true
+debug = false
+incremental = false
+codegen-units = 1
+opt-level = 2
+strip = true
+
+[registry]
+global-min-publish-age = "14 days"

files/99-kira-kernel-update.hook

@@ -0,0 +1,12 @@
+[Trigger]
+Operation = Upgrade
+Operation = Install
+Type = Package
+Target = linux-kira-lts
+Target = linux-kira-virt-lts
+Target = linux-kira-server-lts
+
+[Action]
+Description = Running custom command after kernel update
+When = PostTransaction
+Exec = /usr/bin/hive-up cli --update-boot

files/dinit.service

@@ -0,0 +1,6 @@
+type = process
+command = /usr/bin/hive-up daemon
+stop-command = /usr/bin/hive-up cli --upgrade
+depends-on = network.target
+logfile = /var/log/dinit/hive-up.log
+log-type = file

files/hive-up.toml

@@ -0,0 +1,12 @@
+# Section (Table) headers
+[update]
+# Interval between updates check in hours. 0 - no auto check for updates.
+check_interval = 58
+# Tells hive-up to automatically download updates when awailable.
+download_updates = true
+# Tells hive-up to automatically perform updates during system reboot
+auto_update = false
+
+# In [kernel] section user may specify kernel cmd
+# [kernel]
+# cmd = ""

src/daemon.rs

@@ -176,7 +176,7 @@ fn process_remoute(
 // doing what daemons usually beezz
 fn do_local_work(config: &HiveConfig, bzz_db: &mut HiveDb) -> Result<(), DaemonError> {
     // if updates check is turned on
-    if config.update.updates_check_interval != 0 {
+    if config.update.check_interval != 0 {
         let timestamp = get_timestamp_sec();
 
         // calculate how many hours passed sinse last update
@@ -186,7 +186,7 @@ fn do_local_work(config: &HiveConfig, bzz_db: &mut HiveDb) -> Result<(), DaemonE
             / 3600;
 
         // if more than updates_check_interval specifiyed in config - check for updates
-        if hours_since_update_check > config.update.updates_check_interval {
+        if hours_since_update_check > config.update.check_interval {
             // perform update check
             println!("Cheking for updates...");
             // now that may fail because of bad internet and idealy we

src/hive_config.rs

@@ -22,13 +22,13 @@ use serde::{Deserialize, Serialize};
 use std::fs;
 use toml;
 
-const CONFIG_PATH: &str = "/etc/hive_up.toml";
+const CONFIG_PATH: &str = "/etc/hive-up.toml";
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct HiveConfig {
     // Matches [kernel] in TOML
-    pub kernel: KernelConfig,
+    pub kernel: Option<KernelConfig>,
-    // Updates process config
+    // Updates [update] in TOML
     pub update: UpdateConfig,
 }
 
@@ -41,7 +41,7 @@ pub struct KernelConfig {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct UpdateConfig {
     /// Interval between updates check in hours. 0 - no auto check for updates.
-    pub updates_check_interval: u64,
+    pub check_interval: u64,
     /// Tells hive-up to automatically download updates when awailable.
     pub download_updates: bool,
     /// Tells hive-up to automatically perform updates during system reboot.
@@ -97,11 +97,11 @@ pub fn read_config() -> Result<HiveConfig, ConfigError> {
     Ok(config)
 }
 
-pub fn change_updates_check_interval(new_interval: u64) -> Result<HiveConfig, ConfigError> {
+// pub fn change_updates_check_interval(new_interval: u64) -> Result<HiveConfig, ConfigError> {
-    let mut config: HiveConfig = read_config()?;
+//     let mut config: HiveConfig = read_config()?;
-    config.update.updates_check_interval = new_interval;
+//     config.update.updates_check_interval = new_interval;
-    let conf_str = toml::to_string_pretty(&config)?;
+//     let conf_str = toml::to_string_pretty(&config)?;
-    fs::write(CONFIG_PATH, conf_str)?;
+//     fs::write(CONFIG_PATH, conf_str)?;
 
-    Ok(config)
+//     Ok(config)
-}
+// }

src/hive_db.rs

@@ -70,10 +70,29 @@ pub struct HiveDb {
     pub update_on_reboot: bool,
 }
 
+fn init_db() -> Result<HiveDb, DBError> {
+    let bzz_db = HiveDb{
+        update_check_timestamp: 0,
+        updates_available: 0,
+        update_status: false,
+        last_snapshot_time: "".into(),
+        update_on_reboot: false,
+    };
+    write_db(&bzz_db)?;
+    Ok(bzz_db)
+}
+
 pub fn read_db() -> Result<HiveDb, DBError> {
-    let file_content = fs::read_to_string(DB_PATH)?;
+    if fs::exists(DB_PATH)? {
-    let db: HiveDb = serde_json::from_str(&file_content)?;
+        let file_content = fs::read_to_string(DB_PATH)?;
-    Ok(db)
+        let db: HiveDb = serde_json::from_str(&file_content)?;
+        Ok(db)
+    }
+    else {
+        println!("WARNING database file do not exist {}", DB_PATH);
+        print!("Creating default db file...");
+        init_db()
+    }
 }
 
 pub fn write_db(db: &HiveDb) -> Result<(), DBError> {
@@ -94,26 +113,3 @@ pub fn update_last_check_update_time(new_timestamp: u64) -> Result<u64, DBError>
     Ok(old_value)
 }
 
-///
-/// writes new update_status to db
-/// and returns old db value on success
-///
-pub fn update_update_status(sucess_status: bool) -> Result<bool, DBError> {
-    let mut db = read_db()?;
-    let old_value = db.update_status;
-    db.update_status = sucess_status;
-    write_db(&db)?;
-    Ok(old_value)
-}
-
-///
-/// writes new last_update_timestamp to db
-/// and returns old value on success
-///
-pub fn update_last_update_timestamp(new_timestamp: String) -> Result<String, DBError> {
-    let mut db = read_db()?;
-    let old_value = db.last_snapshot_time;
-    db.last_snapshot_time = new_timestamp;
-    write_db(&db)?;
-    Ok(old_value)
-}

src/hive_intercom.rs

@@ -194,3 +194,12 @@ pub fn client_check_for_updates() -> Result<u32, IntercomError> {
         _ => Err(IntercomError::UnexpectedResponse),
     }
 }
+
+pub fn client_schedule_update() -> Result<(), IntercomError> {
+    let resp = send_and_recv(BzzReq::ScheduleUpdate)?;
+    match resp {
+        BzzResp::Finish => Ok(()),
+        BzzResp::Error(ex) => Err(IntercomError::ServerError(ex)),
+        _ => Err(IntercomError::UnexpectedResponse),
+    }
+}

src/hive_system.rs

@@ -25,14 +25,14 @@ use time_format;
 
 const SNAPS_DIR: &str = "/bzz-snaps";
 const EFI_BOOT_MOUNT_POINT: &str = "/beefi";
-const UKI_IMAGE_NAME: &str = "/beefi/EFI/kira-linux-lts.efi";
+const UKI_IMAGE_NAME: &str = "/beefi/EFI/linux-kira-lts.efi";
-const UKI_IMAGE_BACK_NAME: &str = "/beefi/EFI/kira-linux-lts-back.efi";
+const UKI_IMAGE_BACK_NAME: &str = "/beefi/EFI/linux-kira-lts-back.efi";
 const EFI_PARTLABEL: &str = "bee-efi";
 
 const BOOT_MENU_LABEL: &str = "Kira OS";
 const BOOT_MENU_LABEL_BACK: &str = "Kira OS Fallback";
-const BOOT_UKI_IMAGE_NAME: &str = "\\EFI\\kira-linux-lts.efi";
+const BOOT_UKI_IMAGE_NAME: &str = "\\EFI\\linux-kira-lts.efi";
-const BOOT_UKI_IMAGE_NAME_BACK: &str = "\\EFI\\kira-linux-lts-back.efi";
+const BOOT_UKI_IMAGE_NAME_BACK: &str = "\\EFI\\linux-kira-lts-back.efi";
 
 #[derive(Debug)]
 pub struct CommandFailed {
@@ -388,9 +388,13 @@ fn delete_all_efi_bootnums() -> Result<usize, ExecCommandError> {
 /// Creates EFI boot record
 /// boot_index - inserting it at specified boot index (bootorder)
 /// Assuming boot partition has "bee-efi" PARTLABEL
-/// 
+///
-fn efi_boot_record_create(boot_index: u16, boot_label: &str, uki_path: &str, maybe_kernel_cmd: &Option<String>) -> Result<(), ExecCommandError> {
+fn efi_boot_record_create(
-    
+    boot_index: u16,
+    boot_label: &str,
+    uki_path: &str,
+    maybe_kernel_cmd: &Option<String>,
+) -> Result<(), ExecCommandError> {
     let (efi_partno, efi_parent_dev) = get_efi_part_info()?;
 
     //let local_date = time_format::strftime_local("%Y-%m-%d", time_format::now().unwrap()).unwrap();
@@ -418,8 +422,6 @@ fn efi_boot_record_create(boot_index: u16, boot_label: &str, uki_path: &str, may
     Ok(())
 }
 
-
-
 ///
 /// Deletes all existing boot records and create a default
 ///
@@ -428,26 +430,31 @@ pub fn init_efi_boot_record(maybe_kernel_cmd: &Option<String>) -> Result<(), Exe
     delete_all_efi_bootnums()?;
     // 2 create defaul
     efi_boot_record_create(0, BOOT_MENU_LABEL, BOOT_UKI_IMAGE_NAME, maybe_kernel_cmd)?;
-    efi_boot_record_create(1, BOOT_MENU_LABEL_BACK, BOOT_UKI_IMAGE_NAME_BACK, maybe_kernel_cmd)?;
+    efi_boot_record_create(
+        1,
+        BOOT_MENU_LABEL_BACK,
+        BOOT_UKI_IMAGE_NAME_BACK,
+        maybe_kernel_cmd,
+    )?;
     Ok(())
 }
 
 ///
-/// List installed kernels by inspecting /usr/lib/modules directory 
+/// List installed kernels by inspecting /usr/lib/modules directory
 /// Result is a sorted vector of string
-/// 
+///
 fn list_installed_kernels() -> Result<Vec<String>, ExecCommandError> {
     use regex::Regex;
 
     let re = Regex::new(r#"^[0-9]+\.[0-9]+\.[0-9]+-[0-9]-kira-lts"#).unwrap();
     let mut kernel_dirs: Vec<String> = Vec::new();
-    
+
     // Oh boy we roll
     // finding first dir in /usr/lib/modules that matches common kernel name
     for r_d_entry in fs::read_dir("/usr/lib/modules")? {
         let d_entry = r_d_entry?;
         if d_entry.file_type()?.is_dir() {
-            let maybe_file_name = d_entry.file_name().to_str().map(|s|s.to_string());
+            let maybe_file_name = d_entry.file_name().to_str().map(|s| s.to_string());
             if let Some(file_name) = maybe_file_name {
                 if re.is_match(&file_name) {
                     kernel_dirs.push(file_name);
@@ -465,20 +472,20 @@ pub fn init_efi_boot_partition_content() -> Result<(), ExecCommandError> {
     if let Some(kernel_dir) = kernel_dirs.last() {
         let kernel_img_path = format!("/usr/lib/modules/{}/vmlinuz", kernel_dir);
         let efi_dir = format!("{}/EFI", EFI_BOOT_MOUNT_POINT);
-        println!("Romoving efi dir {}",efi_dir);
+        println!("Romoving efi dir {}", efi_dir);
         fs::remove_dir_all(&efi_dir)?;
-        println!("Creating efi dir {}",efi_dir);
+        println!("Creating efi dir {}", efi_dir);
         fs::create_dir(efi_dir)?;
         println!("Copy {} to {}", kernel_img_path, UKI_IMAGE_NAME);
         fs::copy(&kernel_img_path, UKI_IMAGE_NAME)?;
         println!("Copy {} to {}", kernel_img_path, UKI_IMAGE_BACK_NAME);
         fs::copy(&kernel_img_path, UKI_IMAGE_BACK_NAME)?;
         Ok(())
+    } else {
+        Err(ExecCommandError::Other(
+            "Cannot find kernel files under /usr/lib/modules dir!".into(),
+        ))
     }
-    else {
-        Err(ExecCommandError::Other("Cannot find kernel files under /usr/lib/modules dir!".into()))
-    }
-
 }
 
 ///
@@ -490,22 +497,28 @@ pub fn init_efi_boot_partition_content() -> Result<(), ExecCommandError> {
 /// sudo cp /usr/lib/modules/6.18.46-1-kira-lts/vmlinuz /beefi/EFI/kira-linux-lts.efi
 ///
 pub fn boot_update() -> Result<(), ExecCommandError> {
-    
     // find vmlinuz path in filesystem
     let kernel_dirs = list_installed_kernels()?;
-    
+
     // check if kernel even exist lol
     if let Some(kernel_dir) = kernel_dirs.last() {
         let kernel_img_path = format!("/usr/lib/modules/{}/vmlinuz", kernel_dir);
         // rename old kernel to
-        println!("Renaming old kernel {} to {}",UKI_IMAGE_NAME,UKI_IMAGE_BACK_NAME);
+        println!(
+            "Renaming old kernel {} to {}",
+            UKI_IMAGE_NAME, UKI_IMAGE_BACK_NAME
+        );
         fs::rename(UKI_IMAGE_NAME, UKI_IMAGE_BACK_NAME)?;
         // copy new kernel image
-        println!("Copy new kernel from {} to {}",kernel_img_path,UKI_IMAGE_NAME);
+        println!(
+            "Copy new kernel from {} to {}",
+            kernel_img_path, UKI_IMAGE_NAME
+        );
         fs::copy(&kernel_img_path, UKI_IMAGE_NAME)?;
         Ok(())
-    }
+    } else {
-    else {
+        Err(ExecCommandError::Other(
-        Err(ExecCommandError::Other("Cannot find kernel files under /usr/lib/modules dir!".into()))
+            "Cannot find kernel files under /usr/lib/modules dir!".into(),
+        ))
     }
 }

src/main.rs

@@ -18,7 +18,7 @@ use clap::{Args, Parser, Subcommand};
 use signal_hook;
 use std;
 use std::sync::Arc;
-use std::sync::atomic::{AtomicBool};
+use std::sync::atomic::AtomicBool;
 
 mod hive_system;
 
@@ -111,13 +111,17 @@ impl std::error::Error for HiveUpError {}
 #[derive(Args, Debug)]
 #[group(required = true, multiple = false)]
 struct RemoteArgs {
-    /// Ask daemon to chack for updates
+    /// Ask daemon to check for updates
     #[arg(long)]
     check_updates: bool,
 
     /// Ask daemon if there is any updates available
     #[arg(long)]
     updates_avail: bool,
+
+    /// Ask daemon to perform system update on next reboot
+    #[arg(long)]
+    schedule_update: bool,
 }
 
 #[derive(Args, Debug)]
@@ -208,11 +212,13 @@ fn main() -> Result<(), HiveUpError> {
                 hive_system::boot_update()?;
             } else if cli_args.init_boot_menu {
                 println!("Init EFI boot menu...");
-                hive_system::init_efi_boot_record(&bzz_config.kernel.cmd)?;
+                let kernel_cmd = bzz_config.kernel.and_then(|kk| kk.cmd.clone());
+                hive_system::init_efi_boot_record(&kernel_cmd)?;
             } else if cli_args.init_boot {
                 println!("Init EFI boot menu and EFI partition content...");
                 println!("Init EFI Partition content...");
-                hive_system::init_efi_boot_record(&bzz_config.kernel.cmd)?;
+                let kernel_cmd = bzz_config.kernel.and_then(|kk| kk.cmd.clone());
+                hive_system::init_efi_boot_record(&kernel_cmd)?;
                 println!("Init EFI boot menu...");
                 hive_system::init_efi_boot_partition_content()?;
             }
@@ -224,6 +230,10 @@ fn main() -> Result<(), HiveUpError> {
             } else if remote_args.updates_avail {
                 let up_num = hive_intercom::client_updates_available()?;
                 println!("Updates awailable: {}", up_num);
+            } else if remote_args.schedule_update {
+                println!("Scheduling system update...");
+                hive_intercom::client_schedule_update()?;
+                print!("Done!")
             }
         }
     }