Struct MultiResourceWriter 

pub struct MultiResourceWriter<O, Opener: MultiResourceWriterOpener<O>, P> { /* private fields */ }

Writes a logical output partitioned across an ordered set of physical resources.

Contract

• Input/output: O, same as every delegate the opener produces.
• State/checkpoint: ResourceSetRevision plus the current output resource’s ordinal and embedded delegate position, through the paired MultiResourceWriterStream, following the same nested-envelope scheme as MultiResourceReader.
• Ordering: resources are filled in ResourceSet’s declared order; one write batch never spans two resources.
• Restartability: supplied explicitly at construction, same as multi_resource_reader.
• Thread safety: Send + Sync; one async-aware lock guards the active-or-poisoned state, the rollover decision, and the write together as one atomic critical section (this crate’s chunk runtime never actually calls write concurrently on one writer instance; the lock exists so this type’s own invariants hold regardless). The active resource and the poison flag deliberately share this single lock rather than living behind two separate ones: two locks would let a concurrent write read “not yet poisoned” before a poisoning transition commits and then roll over into a resource this writer is supposed to have permanently stopped using.
• Transaction/delivery: never claims a stronger mode than the current delegate writer supports; a rollover happens between writer calls, never inside one enlisted call.
• Failure semantics: a failure while writing to resource N does not roll over to resource N+1 – the same delegate is retried at the same resource on the framework’s own retry contract, exactly like an undecorated writer.
• Close: rollover closes the outgoing resource’s delegate stream (with crate::StreamRuntimeOutcome::ResourceBoundary, never Committed – the enclosing step attempt has not reached a terminal outcome yet) before opening the next one, never leaving two resources’ delegates open at once; the paired MultiResourceWriterStream::close closes whichever resource is still active at the step attempt’s own terminal outcome, and never re-closes a resource already closed by a rollover.
• Support tier: first-party.

Trait Implementations

impl<O, Opener, P> ItemWriter<O> for MultiResourceWriter<O, Opener, P>

where O: Sync + 'static, Opener: MultiResourceWriterOpener<O> + 'static, P: RolloverPolicy + 'static,

async fn write<'a>( &'a self, items: &'a [O], context: WriteContext<'a>, ) -> Result<WriteOutcome, WriterError>

Writes one borrowed, nonempty batch.