554 lines
20 KiB
Rust
554 lines
20 KiB
Rust
use crate::net::wire;
|
||
use std::time::{Duration, Instant};
|
||
|
||
const REQUEST_TIMEOUT: Duration = Duration::from_secs(20);
|
||
|
||
struct Pending {
|
||
request: wire::ForumRequest,
|
||
started: Instant,
|
||
}
|
||
|
||
/// View state belongs to one authenticated node session; mutations stay drafts until ACK.
|
||
#[derive(Default)]
|
||
pub struct ForumState {
|
||
pub supported: bool,
|
||
pub channel_id: Option<String>,
|
||
pub joined: bool,
|
||
pub topics: Vec<wire::ForumTopic>,
|
||
pub posts: Vec<wire::ForumPost>,
|
||
pub topic_id: Option<String>,
|
||
pub creating: bool,
|
||
pub title_draft: String,
|
||
pub body_draft: String,
|
||
pub reply_draft: String,
|
||
pub error: String,
|
||
pub topics_offset: Option<u32>,
|
||
pub posts_offset: Option<u32>,
|
||
pub waiting_join: Option<Instant>,
|
||
topic_draft_id: Option<String>,
|
||
first_message_id: Option<String>,
|
||
reply_message_id: Option<String>,
|
||
pending: Option<Pending>,
|
||
}
|
||
impl ForumState {
|
||
pub fn suspend(&mut self) {
|
||
self.supported = false;
|
||
self.joined = false;
|
||
self.pending = None;
|
||
self.waiting_join = None;
|
||
}
|
||
pub fn with_support(supported: bool) -> Self {
|
||
Self {
|
||
supported,
|
||
..Default::default()
|
||
}
|
||
}
|
||
pub fn edit_title(&mut self, value: String) {
|
||
if !self.busy() && self.title_draft != value {
|
||
self.title_draft = value;
|
||
self.topic_draft_id = None;
|
||
self.first_message_id = None;
|
||
}
|
||
}
|
||
pub fn edit_body(&mut self, value: String) {
|
||
if !self.busy() && self.body_draft != value {
|
||
self.body_draft = value;
|
||
self.topic_draft_id = None;
|
||
self.first_message_id = None;
|
||
}
|
||
}
|
||
pub fn edit_reply(&mut self, value: String) {
|
||
if !self.busy() && self.reply_draft != value {
|
||
self.reply_draft = value;
|
||
self.reply_message_id = None;
|
||
}
|
||
}
|
||
pub fn loading(&self) -> bool {
|
||
self.waiting_join.is_some()
|
||
|| self
|
||
.pending
|
||
.as_ref()
|
||
.is_some_and(|p| !crate::net::forum::is_mutation(&p.request))
|
||
}
|
||
pub fn busy(&self) -> bool {
|
||
self.pending
|
||
.as_ref()
|
||
.is_some_and(|p| crate::net::forum::is_mutation(&p.request))
|
||
}
|
||
pub fn pending(&self) -> bool {
|
||
self.pending.is_some() || self.waiting_join.is_some()
|
||
}
|
||
pub fn select(&mut self, channel: &str) {
|
||
if self.channel_id.as_deref() != Some(channel) {
|
||
*self = Self {
|
||
supported: self.supported,
|
||
..Default::default()
|
||
};
|
||
}
|
||
self.channel_id = Some(channel.to_owned());
|
||
self.joined = false;
|
||
self.waiting_join = Some(Instant::now());
|
||
self.error.clear();
|
||
}
|
||
pub fn create(&mut self) {
|
||
if self.pending() || !self.supported {
|
||
return;
|
||
}
|
||
self.creating = true;
|
||
self.topic_id = None;
|
||
self.posts.clear();
|
||
self.error.clear();
|
||
}
|
||
pub fn request(
|
||
&mut self,
|
||
operation: wire::ForumOperation,
|
||
offset: u32,
|
||
) -> Option<wire::ForumRequest> {
|
||
if !self.supported || !self.joined || self.pending() {
|
||
return None;
|
||
}
|
||
let channel_id = self.channel_id.clone()?;
|
||
let mut request = wire::ForumRequest {
|
||
request_id: uuid::Uuid::new_v4().to_string(),
|
||
channel_id,
|
||
operation: operation as i32,
|
||
offset,
|
||
limit: if operation == wire::ForumOperation::List {
|
||
20
|
||
} else {
|
||
50
|
||
},
|
||
..Default::default()
|
||
};
|
||
match operation {
|
||
wire::ForumOperation::List => (),
|
||
wire::ForumOperation::Open => {
|
||
request.topic_id = self.topic_id.clone()?;
|
||
if offset == 0 {
|
||
self.posts.clear();
|
||
self.posts_offset = None;
|
||
}
|
||
}
|
||
wire::ForumOperation::Create => {
|
||
let title = self.title_draft.trim();
|
||
let content = self.body_draft.trim();
|
||
if !valid_title(title) || !valid_body(content) {
|
||
self.error = "Enter a title (1–160 characters) and a first message (1–16000 characters).".into();
|
||
return None;
|
||
}
|
||
request.topic_id = self
|
||
.topic_draft_id
|
||
.get_or_insert_with(|| uuid::Uuid::new_v4().to_string())
|
||
.clone();
|
||
request.message_id = self
|
||
.first_message_id
|
||
.get_or_insert_with(|| uuid::Uuid::new_v4().to_string())
|
||
.clone();
|
||
request.title = title.to_owned();
|
||
request.content = content.to_owned();
|
||
}
|
||
wire::ForumOperation::Reply => {
|
||
if !valid_body(self.reply_draft.trim()) {
|
||
self.error = "Enter a reply (1–16000 characters).".into();
|
||
return None;
|
||
}
|
||
request.topic_id = self.topic_id.clone()?;
|
||
request.message_id = self
|
||
.reply_message_id
|
||
.get_or_insert_with(|| uuid::Uuid::new_v4().to_string())
|
||
.clone();
|
||
request.content = self.reply_draft.trim().to_owned();
|
||
}
|
||
_ => return None,
|
||
}
|
||
self.error.clear();
|
||
self.pending = Some(Pending {
|
||
request: request.clone(),
|
||
started: Instant::now(),
|
||
});
|
||
Some(request)
|
||
}
|
||
pub fn open(&mut self, id: &str) -> Option<wire::ForumRequest> {
|
||
if self.pending() || !self.topics.iter().any(|topic| topic.topic_id == id) {
|
||
return None;
|
||
}
|
||
self.topic_id = Some(id.to_owned());
|
||
self.creating = false;
|
||
self.posts.clear();
|
||
self.reply_draft.clear();
|
||
self.reply_message_id = None;
|
||
self.posts_offset = None;
|
||
self.request(wire::ForumOperation::Open, 0)
|
||
}
|
||
pub fn timeout(&mut self) {
|
||
if self
|
||
.waiting_join
|
||
.is_some_and(|at| at.elapsed() >= REQUEST_TIMEOUT)
|
||
|| self
|
||
.pending
|
||
.as_ref()
|
||
.is_some_and(|p| p.started.elapsed() >= REQUEST_TIMEOUT)
|
||
{
|
||
self.waiting_join = None;
|
||
self.pending = None;
|
||
self.error =
|
||
"The forum request timed out. Your draft has been kept; refresh or retry.".into();
|
||
}
|
||
}
|
||
pub fn result(&mut self, result: wire::ForumResult) {
|
||
let Some(pending) = self.pending.as_ref() else {
|
||
return;
|
||
};
|
||
let request = &pending.request;
|
||
if result.request_id != request.request_id
|
||
|| result.operation != request.operation
|
||
|| result.channel_id != request.channel_id
|
||
|| (!request.topic_id.is_empty() && result.topic_id != request.topic_id)
|
||
{
|
||
return;
|
||
}
|
||
let request = request.clone();
|
||
self.pending = None;
|
||
if result.error_code != 0 || !result.error.is_empty() {
|
||
self.error = result.error.chars().take(500).collect();
|
||
if self.error.is_empty() {
|
||
self.error = "The server refused this forum request.".into();
|
||
}
|
||
return;
|
||
}
|
||
if result.topics.len() > 50
|
||
|| result.posts.len() > 100
|
||
|| result
|
||
.topics
|
||
.iter()
|
||
.any(|t| t.channel_id != request.channel_id)
|
||
|| result.posts.iter().any(|p| {
|
||
p.topic_id != result.topic_id
|
||
|| p.message
|
||
.as_ref()
|
||
.is_none_or(|m| m.channel_id != request.channel_id)
|
||
})
|
||
{
|
||
self.error = "The server returned an invalid forum response.".into();
|
||
return;
|
||
}
|
||
let operation = wire::ForumOperation::try_from(request.operation).ok();
|
||
if matches!(
|
||
operation,
|
||
Some(wire::ForumOperation::Create | wire::ForumOperation::Reply)
|
||
) && !result.posts.iter().any(|p| {
|
||
p.message
|
||
.as_ref()
|
||
.is_some_and(|m| m.message_id == request.message_id)
|
||
}) {
|
||
self.error = "The server did not acknowledge this forum message.".into();
|
||
return;
|
||
}
|
||
self.error.clear();
|
||
match operation {
|
||
Some(wire::ForumOperation::List) => {
|
||
if request.offset == 0 {
|
||
self.topics.clear();
|
||
}
|
||
let count = result.topics.len() as u32;
|
||
for topic in result.topics {
|
||
self.upsert_topic(topic);
|
||
}
|
||
self.topics_offset = next_offset(request.offset, count, result.has_more);
|
||
}
|
||
Some(wire::ForumOperation::Open) => {
|
||
let count = result.posts.len() as u32;
|
||
if result.has_more
|
||
&& let Some(last) = result.posts.iter().map(|p| p.ordinal).max()
|
||
{
|
||
self.posts.retain(|p| p.ordinal <= last);
|
||
}
|
||
for topic in result.topics {
|
||
self.upsert_topic(topic);
|
||
}
|
||
for post in result.posts {
|
||
self.upsert_post(post);
|
||
}
|
||
self.posts_offset = next_offset(request.offset, count, result.has_more);
|
||
}
|
||
Some(wire::ForumOperation::Create) => {
|
||
self.creating = false;
|
||
self.topic_id = Some(request.topic_id);
|
||
self.title_draft.clear();
|
||
self.body_draft.clear();
|
||
self.topic_draft_id = None;
|
||
self.first_message_id = None;
|
||
self.posts.clear();
|
||
self.posts_offset = None;
|
||
for topic in result.topics {
|
||
self.upsert_topic(topic);
|
||
}
|
||
for post in result.posts {
|
||
self.upsert_post(post);
|
||
}
|
||
}
|
||
Some(wire::ForumOperation::Reply) => {
|
||
self.reply_draft.clear();
|
||
self.reply_message_id = None;
|
||
for topic in result.topics {
|
||
self.upsert_topic(topic);
|
||
}
|
||
// When a thread is only partially loaded, do not insert a later reply ahead
|
||
// of unseen posts: refresh/page through its chronological history instead.
|
||
if self.posts_offset.is_none() {
|
||
for post in result.posts {
|
||
self.upsert_post(post);
|
||
}
|
||
}
|
||
}
|
||
_ => (),
|
||
}
|
||
}
|
||
pub fn changed(&mut self, event: wire::ForumChanged) {
|
||
if self.channel_id.as_deref() != Some(event.channel_id.as_str()) || !self.supported {
|
||
return;
|
||
}
|
||
if let Some(topic) = event.topic
|
||
&& topic.channel_id == event.channel_id
|
||
{
|
||
self.upsert_topic(topic);
|
||
}
|
||
if self.posts_offset.is_none()
|
||
&& let Some(post) = event.post
|
||
&& self.topic_id.as_deref() == Some(post.topic_id.as_str())
|
||
&& post
|
||
.message
|
||
.as_ref()
|
||
.is_some_and(|m| m.channel_id == event.channel_id)
|
||
{
|
||
self.upsert_post(post);
|
||
}
|
||
}
|
||
fn upsert_topic(&mut self, topic: wire::ForumTopic) {
|
||
if let Some(current) = self
|
||
.topics
|
||
.iter_mut()
|
||
.find(|t| t.topic_id == topic.topic_id)
|
||
{
|
||
if current.updated_at <= topic.updated_at {
|
||
*current = topic;
|
||
}
|
||
} else {
|
||
self.topics.push(topic);
|
||
}
|
||
self.topics.sort_by(|a, b| {
|
||
b.updated_at
|
||
.cmp(&a.updated_at)
|
||
.then_with(|| a.topic_id.cmp(&b.topic_id))
|
||
});
|
||
}
|
||
fn upsert_post(&mut self, post: wire::ForumPost) {
|
||
let Some(message) = &post.message else {
|
||
return;
|
||
};
|
||
if !self.posts.iter().any(|p| {
|
||
p.message
|
||
.as_ref()
|
||
.is_some_and(|m| m.message_id == message.message_id)
|
||
}) {
|
||
self.posts.push(post);
|
||
}
|
||
self.posts.sort_by_key(|post| post.ordinal);
|
||
}
|
||
}
|
||
fn next_offset(offset: u32, count: u32, has_more: bool) -> Option<u32> {
|
||
(has_more && count > 0 && offset.saturating_add(count) <= 100_000)
|
||
.then_some(offset.saturating_add(count))
|
||
}
|
||
fn bidi_or_control(c: char) -> bool {
|
||
c.is_control()
|
||
|| matches!(c, '\u{061c}'|'\u{200e}'|'\u{200f}'|'\u{202a}'..='\u{202e}'|'\u{2066}'..='\u{2069}')
|
||
}
|
||
fn valid_title(value: &str) -> bool {
|
||
!value.is_empty() && value.chars().count() <= 160 && !value.chars().any(bidi_or_control)
|
||
}
|
||
fn valid_body(value: &str) -> bool {
|
||
!value.is_empty()
|
||
&& value.chars().count() <= 16000
|
||
&& value.len() <= 64 * 1024
|
||
&& !value
|
||
.chars()
|
||
.any(|c| bidi_or_control(c) && c != '\n' && c != '\t')
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
fn ready() -> ForumState {
|
||
ForumState {
|
||
supported: true,
|
||
joined: true,
|
||
channel_id: Some("forum".into()),
|
||
..Default::default()
|
||
}
|
||
}
|
||
fn topic(id: &str) -> wire::ForumTopic {
|
||
wire::ForumTopic {
|
||
topic_id: id.into(),
|
||
channel_id: "forum".into(),
|
||
title: "A real topic".into(),
|
||
..Default::default()
|
||
}
|
||
}
|
||
fn post(id: &str, topic: &str, ordinal: u64) -> wire::ForumPost {
|
||
wire::ForumPost {
|
||
topic_id: topic.into(),
|
||
ordinal,
|
||
message: Some(wire::ChatMessage {
|
||
message_id: id.into(),
|
||
channel_id: "forum".into(),
|
||
content: "A real reply".into(),
|
||
timestamp: 1000,
|
||
..Default::default()
|
||
}),
|
||
..Default::default()
|
||
}
|
||
}
|
||
fn response(request: &wire::ForumRequest) -> wire::ForumResult {
|
||
wire::ForumResult {
|
||
request_id: request.request_id.clone(),
|
||
operation: request.operation,
|
||
channel_id: request.channel_id.clone(),
|
||
topic_id: request.topic_id.clone(),
|
||
..Default::default()
|
||
}
|
||
}
|
||
#[test]
|
||
fn old_server_or_unacknowledged_join_cannot_prepare_forum_packets() {
|
||
let mut state = ready();
|
||
state.supported = false;
|
||
assert!(state.request(wire::ForumOperation::List, 0).is_none());
|
||
state.supported = true;
|
||
state.joined = false;
|
||
assert!(state.request(wire::ForumOperation::List, 0).is_none());
|
||
}
|
||
#[test]
|
||
fn failed_create_keeps_draft_and_stable_mutation_ids_until_matching_ack() {
|
||
let mut state = ready();
|
||
state.create();
|
||
state.edit_title("Topic".into());
|
||
state.edit_body("Opening post".into());
|
||
let first = state.request(wire::ForumOperation::Create, 0).unwrap();
|
||
assert!(state.topic_id.is_none());
|
||
assert_eq!(state.title_draft, "Topic");
|
||
let mut denied = response(&first);
|
||
denied.error_code = 5;
|
||
denied.error = "Permission denied".into();
|
||
state.result(denied);
|
||
assert_eq!(state.body_draft, "Opening post");
|
||
assert!(!state.busy());
|
||
let retry = state.request(wire::ForumOperation::Create, 0).unwrap();
|
||
assert_ne!(first.request_id, retry.request_id);
|
||
assert_eq!(first.topic_id, retry.topic_id);
|
||
assert_eq!(first.message_id, retry.message_id);
|
||
let mut stale = response(&first);
|
||
stale.topics = vec![topic(&first.topic_id)];
|
||
stale.posts = vec![post(&first.message_id, &first.topic_id, 1)];
|
||
state.result(stale);
|
||
assert!(state.busy());
|
||
assert_eq!(state.title_draft, "Topic");
|
||
let mut accepted = response(&retry);
|
||
accepted.topics = vec![topic(&retry.topic_id)];
|
||
accepted.posts = vec![post(&retry.message_id, &retry.topic_id, 1)];
|
||
state.result(accepted);
|
||
assert_eq!(state.topic_id.as_deref(), Some(retry.topic_id.as_str()));
|
||
assert_eq!(state.posts.len(), 1);
|
||
assert!(state.title_draft.is_empty());
|
||
assert!(state.body_draft.is_empty());
|
||
assert!(!state.creating);
|
||
}
|
||
#[test]
|
||
fn changing_failed_draft_allocates_new_object_ids_and_stale_node_results_are_ignored() {
|
||
let mut state = ready();
|
||
state.edit_title("Topic".into());
|
||
state.edit_body("First".into());
|
||
let old = state.request(wire::ForumOperation::Create, 0).unwrap();
|
||
let mut failed = response(&old);
|
||
failed.error = "Denied".into();
|
||
state.result(failed);
|
||
state.edit_body("Changed".into());
|
||
let new = state.request(wire::ForumOperation::Create, 0).unwrap();
|
||
assert_ne!(old.topic_id, new.topic_id);
|
||
assert_ne!(old.message_id, new.message_id);
|
||
state.select("different-forum");
|
||
state.result(response(&new));
|
||
assert!(state.topics.is_empty());
|
||
assert!(state.posts.is_empty());
|
||
assert_eq!(state.channel_id.as_deref(), Some("different-forum"));
|
||
}
|
||
#[test]
|
||
fn pagination_uses_actual_byte_bounded_page_size_and_posts_sort_by_ordinal() {
|
||
let mut state = ready();
|
||
state.topics.push(topic("topic"));
|
||
let request = state.open("topic").unwrap();
|
||
assert_eq!(request.limit, 50);
|
||
let mut result = response(&request);
|
||
result.topics = vec![topic("topic")];
|
||
result.posts = vec![post("two", "topic", 2), post("one", "topic", 1)];
|
||
result.has_more = true;
|
||
state.result(result);
|
||
assert_eq!(state.posts_offset, Some(2));
|
||
assert_eq!(
|
||
state.posts.iter().map(|p| p.ordinal).collect::<Vec<_>>(),
|
||
vec![1, 2]
|
||
);
|
||
let request = state
|
||
.request(wire::ForumOperation::Open, state.posts_offset.unwrap())
|
||
.unwrap();
|
||
assert_eq!(request.offset, 2);
|
||
let mut last = response(&request);
|
||
last.posts = vec![post("three", "topic", 3)];
|
||
state.result(last);
|
||
assert!(state.posts_offset.is_none());
|
||
assert_eq!(state.posts.len(), 3);
|
||
}
|
||
#[test]
|
||
fn changed_ack_and_page_overlap_deduplicate_even_with_equal_millisecond_timestamps() {
|
||
let mut state = ready();
|
||
state.topics.push(topic("topic"));
|
||
state.topic_id = Some("topic".into());
|
||
state.posts.push(post("first", "topic", 1));
|
||
state.edit_reply("Own reply".into());
|
||
let request = state.request(wire::ForumOperation::Reply, 0).unwrap();
|
||
state.changed(wire::ForumChanged {
|
||
channel_id: "forum".into(),
|
||
topic: Some(topic("topic")),
|
||
post: Some(post("third", "topic", 3)),
|
||
});
|
||
let mut result = response(&request);
|
||
result.topics = vec![topic("topic")];
|
||
result.posts = vec![post(&request.message_id, "topic", 2)];
|
||
state.result(result);
|
||
state.changed(wire::ForumChanged {
|
||
channel_id: "forum".into(),
|
||
topic: Some(topic("topic")),
|
||
post: Some(post(&request.message_id, "topic", 2)),
|
||
});
|
||
assert_eq!(
|
||
state.posts.iter().map(|p| p.ordinal).collect::<Vec<_>>(),
|
||
vec![1, 2, 3]
|
||
);
|
||
assert!(state.reply_draft.is_empty());
|
||
}
|
||
#[test]
|
||
fn timeout_keeps_text_and_retry_ids_and_invalid_reply_ack_cannot_clear_input() {
|
||
let mut state = ready();
|
||
state.topic_id = Some("topic".into());
|
||
state.edit_reply("Keep this".into());
|
||
let request = state.request(wire::ForumOperation::Reply, 0).unwrap();
|
||
state.pending.as_mut().unwrap().started = Instant::now() - REQUEST_TIMEOUT;
|
||
state.timeout();
|
||
assert_eq!(state.reply_draft, "Keep this");
|
||
assert!(!state.error.is_empty());
|
||
let retry = state.request(wire::ForumOperation::Reply, 0).unwrap();
|
||
assert_eq!(request.message_id, retry.message_id);
|
||
state.result(response(&retry));
|
||
assert_eq!(state.reply_draft, "Keep this");
|
||
assert!(!state.error.is_empty());
|
||
}
|
||
}
|