Struct UploadSessionState 

pub struct UploadSessionState {
    pub namespace_id: NamespaceId,
    pub upload_id: UploadId,
    pub content_id: ContentId,
    pub created_at_ms: u64,
    pub transport: UploadSessionTransport,
    pub state: UploadSessionLifecycle,
}

Tracks one durable content-upload workflow independently of commit publication.

The record is an identity, a transport, and a state. Everything a transport needs lives in its own variant and everything a state needs lives in its own variant, so the combinations that used to be spelled with independent optional fields — a proxied session holding a provider upload, a multipart session promising content, a completed reference in two places at once — are not shapes this type has.

See upload before publish.

Fields

namespace_id: NamespaceId

Namespace authorized to consume the staged content.

upload_id: UploadId

Durable session identity used by staging and completion requests.

content_id: ContentId

Content object this session writes, allocated when the session began.

The identity exists before any byte is read, so the final object key is known up front and belongs to exactly this session. Every reference the record holds names this object; see the decoder below, which refuses a record that disagrees with itself.

created_at_ms: u64

Unix-millisecond creation stamp.

transport: UploadSessionTransport

How the bytes reach object storage, settled when the session opened.

state: UploadSessionLifecycle

The session’s lifecycle, and the field every upload operation compare-and-swaps against.

Trait Implementations

impl Clone for UploadSessionState

fn clone(&self) -> UploadSessionState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UploadSessionState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UploadSessionState

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Reads one session record and proves the one relationship its shape cannot: that every reference it holds names the object it owns.

The transport promise and the staged or completed reference are all about the same content object, whose identity the session allocated before any byte moved. A record whose references disagree with its own content_id describes two objects and cannot be acted on — a completion would verify one key and publish another — so it is refused at load like any other corruption, with no shim and no salvage.

impl Eq for UploadSessionState

impl PartialEq for UploadSessionState

fn eq(&self, other: &UploadSessionState) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for UploadSessionState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for UploadSessionState