fedora-update-feedback 2.1.4

Provide feedback for Fedora updates (inspired by fedora-easy-karma)
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

use bodhi::{BodhiClient, ContentType, FedoraRelease, QueryError, Update, UpdateStatus};

use crate::output::progress_bar;

/// This helper function queries updates in "testing" state for a specific release, and prints a
/// nice progress bar to indicate query progress.
pub async fn query_testing(bodhi: &BodhiClient, release: FedoraRelease) -> Result<Vec<Update>, String> {
    let testing = "Updates (testing)";

    let testing_progress = |p, ps| progress_bar(testing, p, ps);

    let releases = vec![release];
    let testing_query = bodhi::query::UpdateQuery::new()
        .releases(&releases)
        .content_type(ContentType::RPM)
        .status(UpdateStatus::Testing)
        .callback(testing_progress);

    let testing_updates = match bodhi.paginated_request(&testing_query).await {
        Ok(updates) => updates,
        Err(error) => {
            return if let QueryError::BodhiError { error } = error {
                let mut messages: Vec<String> = Vec::new();
                for errmsg in error.errors {
                    for (key, value) in errmsg {
                        messages.push(format!("{}: {}", key, value));
                    }
                }
                Err(format!(
                    "Internal server error:\n{}\n{}\n",
                    error.status,
                    messages.join("\n")
                ))
            } else {
                Err(error.to_string())
            }
        },
    };

    Ok(testing_updates)
}

/// This helper function queries updates in "obsolete" state for a specific release, and prints a
/// nice progress bar to indicate query progress.
pub async fn query_obsoleted(bodhi: &BodhiClient, release: FedoraRelease) -> Result<Vec<Update>, String> {
    let obsolete = "Updates (obsolete)";
    let obsolete_progress = |p, ps| progress_bar(obsolete, p, ps);

    let releases = vec![release];
    let obsolete_query = bodhi::query::UpdateQuery::new()
        .releases(&releases)
        .content_type(ContentType::RPM)
        .status(UpdateStatus::Obsolete)
        .callback(obsolete_progress);

    let obsolete_updates = match bodhi.paginated_request(&obsolete_query).await {
        Ok(updates) => updates,
        Err(error) => {
            return Err(error.to_string());
        },
    };

    Ok(obsolete_updates)
}

/// This helper function queries updates in "pending" state for a specific release, and prints a
/// nice progress bar to indicate query progress.
pub async fn query_pending(bodhi: &BodhiClient, release: FedoraRelease) -> Result<Vec<Update>, String> {
    let pending = "Updates (pending)";
    let pending_progress = |p, ps| progress_bar(pending, p, ps);

    let releases = vec![release];
    let pending_query = bodhi::query::UpdateQuery::new()
        .releases(&releases)
        .content_type(ContentType::RPM)
        .status(UpdateStatus::Pending)
        .callback(pending_progress);

    let pending_updates = match bodhi.paginated_request(&pending_query).await {
        Ok(updates) => updates,
        Err(error) => {
            return Err(error.to_string());
        },
    };

    Ok(pending_updates)
}

/// This helper function queries updates in "unpushed" state for a specific release, and prints a
/// nice progress bar to indicate query progress.
pub async fn query_unpushed(bodhi: &BodhiClient, release: FedoraRelease) -> Result<Vec<Update>, String> {
    let unpushed = "Updates (unpushed)";
    let unpushed_progress = |p, ps| progress_bar(unpushed, p, ps);

    let releases = vec![release];
    let unpushed_query = bodhi::query::UpdateQuery::new()
        .releases(&releases)
        .content_type(ContentType::RPM)
        .status(UpdateStatus::Unpushed)
        .callback(unpushed_progress);

    let unpushed_updates = match bodhi.paginated_request(&unpushed_query).await {
        Ok(updates) => updates,
        Err(error) => {
            return Err(error.to_string());
        },
    };

    Ok(unpushed_updates)
}