upstream-rs 2.7.0

Fetch package updates directly from the source.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

#[cfg(target_os = "linux")]
use crate::services::artifact::AppImageExtractor;
use crate::{
    application::operations::metadata_op::MetadataManager,
    models::upstream::Package,
    output::{self, Status},
    services::integration::{DesktopManager, SymlinkManager},
    storage::database::PackageDatabase,
    utils::static_paths::UpstreamPaths,
};
use anyhow::{Context, Result};

pub fn run_pin(name: String) -> Result<()> {
    let paths = UpstreamPaths::new()?;
    let mut package_database = PackageDatabase::open(&paths.config.packages_database_file)?;
    let mut package_manager = MetadataManager::new(&mut package_database);

    println!("{}", output::title("Package pin"));

    package_manager.pin_package(&name)?;
    output::status_line(Status::Ok, &name, "pinned");

    Ok(())
}

pub fn run_unpin(name: String) -> Result<()> {
    let paths = UpstreamPaths::new()?;
    let mut package_database = PackageDatabase::open(&paths.config.packages_database_file)?;
    let mut package_manager = MetadataManager::new(&mut package_database);

    println!("{}", output::title("Package unpin"));

    package_manager.unpin_package(&name)?;
    output::status_line(Status::Ok, &name, "unpinned");

    Ok(())
}

pub fn run_rename(old_name: String, new_name: String) -> Result<()> {
    let paths = UpstreamPaths::new()?;
    let mut package_database = PackageDatabase::open(&paths.config.packages_database_file)?;
    let package_before = package_database
        .get_package(&old_name)?
        .ok_or_else(|| anyhow::anyhow!("Package '{}' not found", old_name))?;

    let mut package_manager = MetadataManager::new(&mut package_database);
    println!("{}", output::title("Package rename"));

    let renamed = package_manager.rename_package(&old_name, &new_name)?;
    if !renamed {
        output::status_line(Status::Skip, &old_name, "old and new names are identical");
        return Ok(());
    }

    if let Some(exec_path) = package_before.exec_path.as_ref() {
        let symlink_manager = SymlinkManager::new(&paths.integration.symlinks_dir);
        let mut created_new = false;

        if let Err(err) = symlink_manager.add_link(exec_path, &new_name) {
            println!(
                "{}",
                output::warning(format!(
                    "Renamed package but failed to create new symlink '{}': {}",
                    new_name, err
                ))
            );
        } else {
            created_new = true;
        }

        if created_new && let Err(err) = symlink_manager.remove_link(&old_name) {
            println!(
                "{}",
                output::warning(format!(
                    "Renamed package but failed to remove old symlink '{}': {}",
                    old_name, err
                ))
            );
        }
    }

    println!(
        "{}",
        output::success(format!("Package '{}' renamed to '{}'.", old_name, new_name))
    );
    Ok(())
}

pub async fn run_add_entry(name: String) -> Result<()> {
    let (paths, mut package_database, mut package) = load_installed_package(&name)?;

    #[cfg(target_os = "linux")]
    let appimage_extractor =
        AppImageExtractor::new().context("Failed to initialize appimage extractor")?;

    #[cfg(target_os = "linux")]
    let desktop_manager = DesktopManager::new(&paths, &appimage_extractor);
    #[cfg(not(target_os = "linux"))]
    let desktop_manager = DesktopManager::new(&paths);

    println!("{}", output::title("Package add-entry"));

    let mut ignored_messages = Some(|_: &str| {});
    desktop_manager
        .enable_package_entry(&mut package, &mut ignored_messages)
        .await?;

    save_package(&mut package_database, &package)?;
    output::status_line(Status::Ok, &name, "entry added");

    Ok(())
}

pub async fn run_rm_entry(name: String) -> Result<()> {
    let (paths, mut package_database, mut package) = load_installed_package(&name)?;

    #[cfg(target_os = "linux")]
    let appimage_extractor =
        AppImageExtractor::new().context("Failed to initialize appimage extractor")?;

    #[cfg(target_os = "linux")]
    let desktop_manager = DesktopManager::new(&paths, &appimage_extractor);
    #[cfg(not(target_os = "linux"))]
    let desktop_manager = DesktopManager::new(&paths);

    println!("{}", output::title("Package rm-entry"));

    let mut ignored_messages = Some(|_: &str| {});
    desktop_manager.disable_package_entry(&mut package, &mut ignored_messages)?;

    save_package(&mut package_database, &package)?;
    output::status_line(Status::Ok, &name, "entry removed");

    Ok(())
}

fn load_installed_package(name: &str) -> Result<(UpstreamPaths, PackageDatabase, Package)> {
    let paths = UpstreamPaths::new()?;
    let package_database = PackageDatabase::open(&paths.config.packages_database_file)?;
    let package = package_database
        .get_package(name)?
        .ok_or_else(|| anyhow::anyhow!("Package '{}' not found", name))?;

    Ok((paths, package_database, package))
}

fn save_package(package_database: &mut PackageDatabase, package: &Package) -> Result<()> {
    package_database.upsert_package(package).context(format!(
        "Failed to save package '{}' to storage",
        package.name
    ))
}