concord 2.4.8

A terminal user interface client for Discord
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

use std::error::Error as StdError;

use thiserror::Error;

use crate::discord::{ActionBlockReason, DiscordAction};

pub type Result<T> = std::result::Result<T, AppError>;

#[derive(Debug, Error)]
pub enum AppError {
    #[error("login cancelled before a Discord token was saved")]
    LoginCancelled,
    #[error("Discord token must not be empty")]
    EmptyDiscordToken,
    #[error("Discord token is not a valid HTTP authorization header")]
    InvalidDiscordTokenHeader {
        #[source]
        source: reqwest::header::InvalidHeaderValue,
    },
    #[error("Discord rejected the token")]
    DiscordTokenRejected,
    #[error("message content must not be empty")]
    EmptyMessageContent,
    #[error("message content exceeds Discord's 2000 character limit: {len}")]
    MessageTooLong { len: usize },
    #[error("attachment exceeds upload limit: {filename} ({size} bytes, limit {limit} bytes)")]
    AttachmentTooLarge {
        filename: String,
        size: u64,
        limit: u64,
    },
    #[error("message has too many attachments: {count}")]
    TooManyAttachments { count: usize },
    #[error("Discord request failed: {0}")]
    DiscordRequest(String),
    #[error("Discord action blocked: cannot {action}: {reason}")]
    DiscordActionBlocked {
        action: DiscordAction,
        reason: ActionBlockReason,
    },
    #[error("Discord stopped authenticated requests after rejecting the session")]
    DiscordAuthenticationStopped,
    #[error("Discord rate limited {action}; try again in {retry_after_millis} ms")]
    DiscordRateLimited {
        action: String,
        retry_after_millis: u64,
    },
    #[error("Discord forum search index is warming; try again in {retry_after_millis} ms")]
    ForumSearchIndexWarming { retry_after_millis: u64 },
    #[error("message slowmode is active; try again in {retry_after_millis} ms")]
    MessageSlowModeActive { retry_after_millis: u64 },
    #[error(
        "Discord request circuit is open for {method} {path}; try again in {retry_after_millis} ms"
    )]
    DiscordRequestCircuitOpen {
        method: String,
        path: String,
        retry_after_millis: u64,
    },
    #[error("Discord requires a CAPTCHA to {action}")]
    CaptchaRequired { action: String },
    #[error("terminal I/O failed")]
    Io(#[from] std::io::Error),
    #[error("config file is not valid TOML")]
    ConfigTomlDeserialize(#[from] toml::de::Error),
    #[error("config file could not be written as TOML")]
    ConfigTomlSerialize(#[from] toml::ser::Error),
    #[error("credential store file is not valid TOML")]
    CredentialTomlDeserialize {
        #[source]
        source: toml::de::Error,
    },
    #[error("credential store file could not be written as TOML")]
    CredentialTomlSerialize {
        #[source]
        source: toml::ser::Error,
    },
    #[error("system keychain credential store failed")]
    CredentialKeychain {
        #[source]
        source: keyring::Error,
    },
    #[error("credential store task failed")]
    CredentialStoreTask {
        #[source]
        source: tokio::task::JoinError,
    },
    #[error("keymap config is invalid: {0}")]
    InvalidKeymapConfig(String),
    #[error("QR login failed: {0}")]
    QrLogin(String),
    #[error("QR login was cancelled in the Discord mobile app")]
    QrLoginCancelled,
}

impl AppError {
    pub fn log_detail(&self) -> String {
        format_error_chain(self)
    }
}

fn format_error_chain(error: &(dyn StdError + 'static)) -> String {
    let mut detail = error.to_string();
    append_source_chain(&mut detail, error.source());
    detail
}

fn append_source_chain(detail: &mut String, mut source: Option<&(dyn StdError + 'static)>) {
    let mut index = 1;
    while let Some(error) = source {
        detail.push_str(&format!("; source[{index}]={error}"));
        source = error.source();
        index += 1;
    }
}

#[cfg(test)]
mod tests {
    use super::AppError;

    #[test]
    fn non_http_log_detail_includes_source_chain() {
        let error = AppError::InvalidDiscordTokenHeader {
            source: reqwest::header::HeaderValue::from_str("bad\nvalue")
                .expect_err("newline makes header invalid"),
        };

        let detail = error.log_detail();

        assert!(detail.contains("Discord token is not a valid HTTP authorization header"));
        assert!(detail.contains("source[1]="));
    }
}