Struct Talks 

pub struct Talks { /* private fields */ }

A conversation store on disk.

Implementations

impl Talks

pub fn open() -> Self

The operator’s conversations, <home>/talks.

pub fn at(root: PathBuf) -> Self

A store at an explicit root. Tests use this, which is why none of them need the operator’s real home.

pub fn root(&self) -> &Path

Directory holding the conversation files.

pub fn path_of(&self, id: &str) -> PathBuf

Path for one conversation id.

pub fn artifacts_of(&self, id: &str) -> PathBuf

Where one conversation’s prompts and CLI output are kept, beside the record rather than inside it.

pub fn attachments_dir(&self, id: &str) -> PathBuf

Where this conversation’s attached images live: a subdirectory of artifacts_of, so deleting the conversation deletes its attachments too and nothing here needs its own cleanup path.

pub fn put_attachment( &self, id: &str, mime: &str, name: &str, data: &[u8], ) -> Result<Attachment>

Persist one already-validated attachment and return its metadata.

web::talk_attachment_post is the only caller: it has already checked mime against the whitelist and sniffed the bytes, so an unrecognised mime reaching here is a bug in that caller, not something an operator did. The id is minted here and never taken from the client; name is stored for display only and never used to build a path.

pub fn attachment_meta( &self, id: &str, att_id: &str, ) -> Result<Option<Attachment>>

Just the metadata, without reading the image bytes back off disk - what web::talk_say uses to turn an id the operator referenced into an Attachment before appending a Turn, where the bytes themselves are of no interest. None for an id this conversation never stored - including one that merely looks plausible: valid_attachment_id is checked here too, not only by the caller, the same defence-in-depth Questions::panel_asset uses for its own asset ids.

pub fn read_attachment( &self, id: &str, att_id: &str, ) -> Result<Option<(Attachment, Vec<u8>)>>

A stored attachment’s metadata and its bytes together, for serving it back on GET. None under the same conditions as Talks::attachment_meta, which this is built on.

pub fn put(&self, t: &mut Talk) -> Result<()>

Write a conversation, atomically, so a process killed mid-write leaves the previous state readable rather than a truncated file.

pub fn get(&self, id: &str) -> Result<Talk>

Load a conversation by id or unambiguous id prefix.

pub fn list(&self) -> Vec<Talk>

Every conversation on disk: open first, then newest first, so what the operator is still using belongs above what they are done with.

pub fn resolve_id(&self, prefix: &str) -> Result<String>

Expand an id prefix to exactly one conversation id.

pub fn revision(&self) -> u64

Change detection token: the newest modification time in the store, in milliseconds.

pub fn count_open(&self) -> usize

How many conversations are still open.

pub fn remove(&self, id: &str) -> Result<()>

Remove a conversation from disk, record and artifacts both. The operator’s way of saying “not just done, gone” - close alone leaves the record as history.

Takes Talks::guard for the same reason close does: a delete racing a record or the tail of [turn] must not land between their own read and write, or the file removed here would look, to them, like a record that simply has not been written yet. The other half of that story is on their side - both check under this same guard that the record they are about to write is still there, and give up without writing if it is not, which is what stops their put from resurrecting a conversation this call already removed.

Trait Implementations

impl Clone for Talks

fn clone(&self) -> Talks

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Talks

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.