Files
javis_bot/app/src/channel_sync.rs
javis-bot d4bd4acfe9 fix(app): channel sync keeps a new channel's empty fields out on retry, orders saves, drops stale lookups
- A rate-limited edit of a newly registered channel is retried with the
  same "never clear Discord with an empty field" rule (it was retried as
  an existing channel and cleared the topic).
- Channel edits go one at a time, and Discord's form of the name is
  written back only while the settings still hold the name that was sent,
  so a slow answer to an earlier save never overwrites a later one.
- The chat channel screen drops a Discord name/topic lookup that answers
  after the ID was changed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 19:49:47 +09:00

432 lines
20 KiB
Rust

//! Chat channel names and topics kept in step with Discord (`app/src/admin.spec.md`, "Chat channel
//! names and topics"; `docs/v2/conversation.md`, "채널 이름·주제 반영"). When the chat channel
//! settings are saved, each channel with `syncDiscord` whose name or description changed gets them as
//! its Discord name and topic; Discord's own form of the name (spaces become `-`) is written back.
//! Discord allows only a few such edits per channel in ten minutes: a refused edit is "pending" and
//! tried again by itself after the wait Discord names. Without the permission (or any other refusal)
//! the edit is "failed" with the reason, and the app keeps what the user wrote.
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use async_trait::async_trait;
use serde::Serialize;
use serde_json::{json, Value};
use crate::settings::ChatChannelSettings;
/// Discord's limit for a channel topic.
pub const TOPIC_MAX: usize = 1024;
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ChannelInfo {
pub name: String,
pub topic: String,
}
#[derive(Debug, Clone, PartialEq)]
pub enum ApiError {
/// Too many edits: try again after this long.
RateLimited(Duration),
Failed(String),
}
/// Discord's channel endpoints (a fake in tests).
#[async_trait]
pub trait ChannelApi: Send + Sync {
async fn info(&self, id: u64) -> Result<ChannelInfo, ApiError>;
/// Set what is given; returns the channel as Discord stored it.
async fn edit(&self, id: u64, name: Option<&str>, topic: Option<&str>) -> Result<ChannelInfo, ApiError>;
}
#[derive(Debug, Clone, PartialEq, Serialize)]
#[serde(tag = "state", rename_all = "camelCase")]
pub enum SyncState {
Applied { name: String },
#[serde(rename_all = "camelCase")]
Pending { retry_in_sec: u64 },
Failed { reason: String },
}
/// Refuse (before anything is saved) a description Discord would not take as a topic.
pub fn check_topics(channels: &[ChatChannelSettings]) -> Result<(), String> {
match channels.iter().find(|c| c.sync_discord && c.description.chars().count() > TOPIC_MAX) {
Some(c) => Err(format!("채널 {}의 설명이 {}자를 넘어 디스코드 주제로 쓸 수 없습니다 ({}자)", c.id, TOPIC_MAX,
c.description.chars().count())),
None => Ok(()),
}
}
/// The channels to bring to Discord after a save: `syncDiscord` on and new, or with another name or
/// description than before.
pub fn changed(old: &[ChatChannelSettings], new: &[ChatChannelSettings]) -> Vec<ChatChannelSettings> {
new.iter().filter(|c| c.sync_discord)
.filter(|c| old.iter().find(|o| o.id == c.id)
.is_none_or(|o| o.name != c.name || o.description != c.description || !o.sync_discord))
.cloned().collect()
}
pub struct Syncer {
api: Arc<dyn ChannelApi>,
settings_file: PathBuf,
status: Mutex<HashMap<u64, SyncState>>,
/// Channels with a retry already waiting (another save while waiting adds none), and whether
/// that channel was new (so the retry still keeps empty fields out).
retrying: Mutex<HashMap<u64, bool>>,
/// One channel edit at a time: a later save waits for an earlier one, so a slow answer to the
/// earlier never lands after the later.
edit_lock: tokio::sync::Mutex<()>,
}
impl Syncer {
pub fn new(api: Arc<dyn ChannelApi>, settings_file: PathBuf) -> Arc<Self> {
Arc::new(Self { api, settings_file, status: Mutex::default(), retrying: Mutex::default(),
edit_lock: tokio::sync::Mutex::new(()) })
}
/// A channel's name and topic on Discord now (the screens fill a newly registered channel with them).
pub async fn info(&self, id: u64) -> Result<ChannelInfo, String> {
self.api.info(id).await.map_err(|e| match e {
ApiError::RateLimited(w) => format!("디스코드가 {}초 뒤에 다시 물어 달라고 합니다", w.as_secs()),
ApiError::Failed(r) => r,
})
}
pub fn status(&self) -> HashMap<u64, SyncState> {
self.status.lock().unwrap().clone()
}
/// Bring these channels to Discord now; `old` tells which ones are new (a new one never clears a
/// Discord name or topic with an empty field).
pub async fn sync(self: &Arc<Self>, channels: Vec<ChatChannelSettings>, old: &[ChatChannelSettings])
-> Vec<(u64, SyncState)> {
let mut out = vec![];
for c in channels {
let is_new = !old.iter().any(|o| o.id == c.id);
let state = self.sync_one(&c, is_new).await;
self.status.lock().unwrap().insert(c.id, state.clone());
out.push((c.id, state));
}
out
}
async fn sync_one(self: &Arc<Self>, c: &ChatChannelSettings, is_new: bool) -> SyncState {
let _one_at_a_time = self.edit_lock.lock().await;
let current = match self.api.info(c.id).await {
Ok(i) => i,
Err(e) => return self.refused(c.id, e, is_new),
};
let keep = |v: &str| !(is_new && v.trim().is_empty());
let name = (keep(&c.name) && c.name != current.name).then_some(c.name.as_str());
let topic = (keep(&c.description) && c.description != current.topic).then_some(c.description.as_str());
if name.is_none() && topic.is_none() {
return SyncState::Applied { name: current.name };
}
match self.api.edit(c.id, name, topic).await {
Ok(stored) => {
if keep(&c.name) && stored.name != c.name {
self.write_name(c.id, &c.name, &stored.name);
}
crate::info_log!("chat", "channel {} name and topic updated on Discord", c.id);
SyncState::Applied { name: stored.name }
}
Err(e) => self.refused(c.id, e, is_new),
}
}
fn refused(self: &Arc<Self>, id: u64, e: ApiError, is_new: bool) -> SyncState {
match e {
ApiError::RateLimited(wait) => {
crate::info_log!("chat", "channel {id}: Discord asks to wait {}s before the next edit", wait.as_secs());
let first = {
let mut r = self.retrying.lock().unwrap();
let first = !r.contains_key(&id);
*r.entry(id).or_insert(is_new) |= is_new;
first
};
if first {
let me = self.clone();
tokio::spawn(async move {
tokio::time::sleep(wait).await;
let is_new = me.retrying.lock().unwrap().remove(&id).unwrap_or(false);
me.retry(id, is_new).await;
});
}
SyncState::Pending { retry_in_sec: wait.as_secs().max(1) }
}
ApiError::Failed(reason) => {
crate::warn_log!("chat", "channel {id}: name and topic not updated on Discord: {reason}");
SyncState::Failed { reason }
}
}
}
/// Try a pending channel again with what the settings hold now.
async fn retry(self: &Arc<Self>, id: u64, is_new: bool) {
let Ok(settings) = crate::settings::load_settings(&self.settings_file) else { return };
match settings.chat_channels.into_iter().find(|c| c.id == id && c.sync_discord) {
Some(c) => {
let state = self.sync_one(&c, is_new).await;
self.status.lock().unwrap().insert(id, state);
}
None => {
self.status.lock().unwrap().remove(&id);
}
}
}
/// Show Discord's form of the name (spaces become `-`) in the app too, only while the settings
/// still hold the name that was sent (a later save keeps its own).
fn write_name(&self, id: u64, sent: &str, name: &str) {
let Ok(view) = crate::settings_edit::view(&self.settings_file) else { return };
let Some(Value::Array(mut list)) = view.get("chatChannels").cloned() else { return };
let mut changed = false;
for c in &mut list {
if c["id"].as_str() == Some(id.to_string().as_str()) && c["name"].as_str() == Some(sent) {
c["name"] = json!(name);
changed = true;
}
}
if !changed {
return;
}
let mut changes = serde_json::Map::new();
changes.insert("chatChannels".into(), Value::Array(list));
if let Err(e) = crate::settings_edit::apply(&self.settings_file, &changes) {
crate::warn_log!("chat", "channel {id}: could not write Discord's name back: {}", e.0);
}
}
}
/// Discord's REST API with the stored bot token. Serenity's client waits out rate limits by itself
/// (up to ten minutes for channel edits), so these two calls go out directly and report the wait.
pub struct DiscordRest {
pub secrets_file: PathBuf,
pub base: String,
}
impl DiscordRest {
pub fn new(secrets_file: PathBuf) -> Self {
Self { secrets_file, base: "https://discord.com/api/v10".into() }
}
async fn call(&self, req: impl FnOnce(&reqwest::Client, String) -> reqwest::RequestBuilder) -> Result<ChannelInfo, ApiError> {
let token = crate::secrets::Secrets::new(&self.secrets_file).get(crate::secrets::DISCORD_TOKEN)
.ok().flatten().ok_or_else(|| ApiError::Failed("봇 토큰이 저장되어 있지 않습니다".into()))?;
let client = reqwest::Client::builder().timeout(Duration::from_secs(15)).build()
.map_err(|e| ApiError::Failed(e.to_string()))?;
let r = req(&client, self.base.clone()).header("Authorization", format!("Bot {token}"))
.header("User-Agent", "DiscordBot (https://github.com/jarvis, 0.1)").send().await
.map_err(|e| ApiError::Failed(format!("디스코드에 연결하지 못했습니다: {e}")))?;
let status = r.status().as_u16();
let body: Value = serde_json::from_str(&r.text().await.unwrap_or_default()).unwrap_or_default();
match status {
200..=299 => Ok(ChannelInfo { name: body["name"].as_str().unwrap_or_default().to_owned(),
topic: body["topic"].as_str().unwrap_or_default().to_owned() }),
429 => Err(ApiError::RateLimited(Duration::from_secs_f64(body["retry_after"].as_f64().unwrap_or(60.0).ceil()))),
403 => Err(ApiError::Failed("봇에 이 채널의 채널 관리 권한이 없습니다".into())),
404 => Err(ApiError::Failed("디스코드에서 이 채널을 찾지 못했습니다".into())),
_ => Err(ApiError::Failed(format!("디스코드가 거절했습니다 ({status}): {}",
body["message"].as_str().unwrap_or_default()))),
}
}
}
#[async_trait]
impl ChannelApi for DiscordRest {
async fn info(&self, id: u64) -> Result<ChannelInfo, ApiError> {
self.call(|c, base| c.get(format!("{base}/channels/{id}"))).await
}
async fn edit(&self, id: u64, name: Option<&str>, topic: Option<&str>) -> Result<ChannelInfo, ApiError> {
let mut body = serde_json::Map::new();
if let Some(n) = name {
body.insert("name".into(), json!(n));
}
if let Some(t) = topic {
body.insert("topic".into(), json!(t));
}
let body = Value::Object(body).to_string();
self.call(move |c, base| c.patch(format!("{base}/channels/{id}"))
.header("Content-Type", "application/json").body(body)).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::datadir::temp_dir;
/// Discord as the tests need it: names lose their spaces, a channel may refuse, and the first
/// `limited` edits are rate limited.
#[derive(Default)]
struct FakeDiscord {
channels: Mutex<HashMap<u64, ChannelInfo>>,
forbidden: Vec<u64>,
limited: Mutex<u32>,
edits: Mutex<Vec<(u64, Option<String>, Option<String>)>>,
/// How long each next edit takes (the first save's slow answer).
delays: Mutex<Vec<Duration>>,
}
#[async_trait]
impl ChannelApi for FakeDiscord {
async fn info(&self, id: u64) -> Result<ChannelInfo, ApiError> {
self.channels.lock().unwrap().get(&id).cloned().ok_or_else(|| ApiError::Failed("없음".into()))
}
async fn edit(&self, id: u64, name: Option<&str>, topic: Option<&str>) -> Result<ChannelInfo, ApiError> {
if self.forbidden.contains(&id) {
return Err(ApiError::Failed("봇에 이 채널의 채널 관리 권한이 없습니다".into()));
}
let delay = { let mut d = self.delays.lock().unwrap(); if d.is_empty() { None } else { Some(d.remove(0)) } };
if let Some(d) = delay {
tokio::time::sleep(d).await;
}
{
let mut l = self.limited.lock().unwrap();
if *l > 0 {
*l -= 1;
return Err(ApiError::RateLimited(Duration::from_millis(200)));
}
}
self.edits.lock().unwrap().push((id, name.map(String::from), topic.map(String::from)));
let mut chans = self.channels.lock().unwrap();
let c = chans.get_mut(&id).unwrap();
if let Some(n) = name {
c.name = n.replace(' ', "-");
}
if let Some(t) = topic {
c.topic = t.into();
}
Ok(c.clone())
}
}
const A: u64 = 100000000000000001;
const B: u64 = 100000000000000002;
fn ch(id: u64, name: &str, description: &str) -> ChatChannelSettings {
ChatChannelSettings { id, name: name.into(), description: description.into(), read: true, send: true, edit: true,
react: true, delete: false, pin: false, answer_all: false, sync_discord: true }
}
fn fake(forbidden: Vec<u64>, limited: u32) -> Arc<FakeDiscord> {
let f = FakeDiscord { forbidden, limited: Mutex::new(limited), ..Default::default() };
f.channels.lock().unwrap().insert(A, ChannelInfo { name: "일정".into(), topic: "".into() });
f.channels.lock().unwrap().insert(B, ChannelInfo { name: "잡담".into(), topic: "아무 말".into() });
Arc::new(f)
}
fn settings_with(chans: &[ChatChannelSettings]) -> PathBuf {
let f = temp_dir("sync").join("settings.json");
std::fs::create_dir_all(f.parent().unwrap()).unwrap();
let list: Vec<Value> = chans.iter().map(|c| json!({"id": c.id.to_string(), "name": c.name,
"description": c.description})).collect();
std::fs::write(&f, json!({"chatChannels": list}).to_string()).unwrap();
f
}
#[test]
fn only_new_or_edited_channels_that_keep_discord_in_step_are_sent() {
let old = vec![ch(A, "일정", ""), ch(B, "잡담", "아무 말")];
let mut off = ch(B, "잡담2", "아무 말");
off.sync_discord = false;
assert!(changed(&old, &old).is_empty());
assert_eq!(changed(&old, &[ch(A, "일정 표", ""), off]).iter().map(|c| c.id).collect::<Vec<_>>(), [A]);
assert_eq!(changed(&[], &[ch(B, "잡담", "아무 말")]).len(), 1, "a newly registered channel");
}
#[test]
fn a_topic_over_discord_s_limit_is_refused_before_saving() {
let long = "가".repeat(TOPIC_MAX + 1);
assert!(check_topics(&[ch(A, "일정", &long)]).unwrap_err().contains("1024"));
let mut off = ch(A, "일정", &long);
off.sync_discord = false;
assert!(check_topics(&[off]).is_ok(), "not sent to Discord: any length");
}
#[tokio::test]
async fn an_edit_reaches_discord_and_discord_s_form_of_the_name_comes_back() {
let d = fake(vec![], 0);
let file = settings_with(&[ch(A, "일정 표", "할 일")]);
let s = Syncer::new(d.clone(), file.clone());
let out = s.sync(vec![ch(A, "일정 표", "할 일")], &[ch(A, "일정", "")]).await;
assert_eq!(out, [(A, SyncState::Applied { name: "일정-표".into() })]);
assert_eq!(d.channels.lock().unwrap()[&A], ChannelInfo { name: "일정-표".into(), topic: "할 일".into() });
let saved = crate::settings::load_settings(&file).unwrap();
assert_eq!(saved.chat_channels[0].name, "일정-표", "the app shows Discord's name");
}
#[tokio::test]
async fn without_permission_it_fails_with_the_reason_and_the_app_keeps_the_text() {
let d = fake(vec![A], 0);
let file = settings_with(&[ch(A, "일정 표", "할 일")]);
let s = Syncer::new(d.clone(), file.clone());
let out = s.sync(vec![ch(A, "일정 표", "할 일")], &[]).await;
assert!(matches!(&out[0].1, SyncState::Failed { reason } if reason.contains("권한")), "{out:?}");
assert_eq!(crate::settings::load_settings(&file).unwrap().chat_channels[0].name, "일정 표");
assert_eq!(d.channels.lock().unwrap()[&A].name, "일정");
}
#[tokio::test]
async fn a_rate_limited_edit_is_pending_and_goes_through_by_itself_with_the_latest_text() {
let d = fake(vec![], 1);
let file = settings_with(&[ch(A, "일정 표", "할 일")]);
let s = Syncer::new(d.clone(), file.clone());
let out = s.sync(vec![ch(A, "일정 표", "할 일")], &[ch(A, "일정", "")]).await;
assert!(matches!(out[0].1, SyncState::Pending { .. }), "{out:?}");
// Edited again while waiting: the retry sends what the settings hold then.
std::fs::write(&file, json!({"chatChannels": [{"id": A.to_string(), "name": "일정 표 2", "description": "할 일"}]})
.to_string()).unwrap();
// A second save while waiting is pending too, but adds no second retry.
*d.limited.lock().unwrap() = 1;
let again = s.sync(vec![ch(A, "일정 표 2", "할 일")], &[ch(A, "일정 표", "할 일")]).await;
assert!(matches!(again[0].1, SyncState::Pending { .. }), "{again:?}");
tokio::time::sleep(Duration::from_millis(500)).await;
assert_eq!(s.status()[&A], SyncState::Applied { name: "일정-표-2".into() });
assert_eq!(d.channels.lock().unwrap()[&A].name, "일정-표-2");
assert_eq!(d.edits.lock().unwrap().len(), 1, "one retry, one edit");
}
#[tokio::test]
async fn a_new_channel_with_empty_fields_never_clears_discord_and_unchanged_ones_are_not_edited() {
let d = fake(vec![], 0);
let s = Syncer::new(d.clone(), settings_with(&[]));
let out = s.sync(vec![ch(B, "", "")], &[]).await;
assert_eq!(out, [(B, SyncState::Applied { name: "잡담".into() })]);
assert_eq!(d.channels.lock().unwrap()[&B].topic, "아무 말");
s.sync(vec![ch(B, "잡담", "아무 말")], &[]).await;
assert!(d.edits.lock().unwrap().is_empty(), "nothing differs from Discord: no edit");
}
#[tokio::test]
async fn a_retried_new_channel_still_never_clears_discord_with_an_empty_field() {
let d = fake(vec![], 1);
let file = settings_with(&[ch(B, "잡담 2", "")]);
let s = Syncer::new(d.clone(), file);
let out = s.sync(vec![ch(B, "잡담 2", "")], &[]).await;
assert!(matches!(out[0].1, SyncState::Pending { .. }), "{out:?}");
tokio::time::sleep(Duration::from_millis(500)).await;
assert_eq!(s.status()[&B], SyncState::Applied { name: "잡담-2".into() });
assert_eq!(d.channels.lock().unwrap()[&B].topic, "아무 말", "the retry kept the empty description out");
}
#[tokio::test]
async fn a_slow_first_save_never_overwrites_a_later_one() {
let d = fake(vec![], 0);
*d.delays.lock().unwrap() = vec![Duration::from_millis(300)];
let file = settings_with(&[ch(A, "일정 표", "")]);
let s = Syncer::new(d.clone(), file.clone());
let s1 = s.clone();
let first = tokio::spawn(async move { s1.sync(vec![ch(A, "일정 표", "")], &[ch(A, "일정", "")]).await });
tokio::time::sleep(Duration::from_millis(50)).await;
// Saved again while Discord still answers the first edit.
std::fs::write(&file, json!({"chatChannels": [{"id": A.to_string(), "name": "회의", "description": ""}]}).to_string()).unwrap();
s.sync(vec![ch(A, "회의", "")], &[ch(A, "일정 표", "")]).await;
first.await.unwrap();
assert_eq!(d.channels.lock().unwrap()[&A].name, "회의", "Discord ends with the later save");
assert_eq!(crate::settings::load_settings(&file).unwrap().chat_channels[0].name, "회의", "and so does the app");
}
}