Struct SessionManager 

pub struct SessionManager<I: Interface + ?Sized> { /* private fields */ }

Implementations

impl<I: Interface + ?Sized> SessionManager<I>

pub fn into_block_service( &self, orchestrator: &Arc<I::Orchestrator>, ) -> Arc<dyn BlockService>

Returns the memoized BlockService for this session manager.

impl<I: Interface + ?Sized> SessionManager<I>

pub fn new(interface: Arc<I>, block_size: u32) -> Self

where I: Sized,

pub fn block_size(&self) -> u32

pub fn complete_request(&self, request_id: RequestId, status: Status)

Reports the given task as complete with a given status.

pub fn terminate(&self)

Terminates the session manager. Blocks until all sessions have terminated.

Trait Implementations

impl Borrow<SessionManager<InterfaceAdapter>> for Orchestrator

fn borrow(&self) -> &SessionManager<InterfaceAdapter>

Immutably borrows from an owned value.

impl<I: Interface + ?Sized> Drop for SessionManager<I>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<I: Interface + ?Sized> SessionManager for SessionManager<I>

async fn open_session( orchestrator: Arc<Self::Orchestrator>, stream: SessionRequestStream, offset_map: OffsetMap, block_size: u32, ) -> Result<(), Error>

Called when a new session request stream is opened. Constructs a SessionHelper with the client-provided offset_map and device constraints, spawns the session runner via I::spawn_session, and processes FIFO requests until the session channel is closed or aborted.

const SUPPORTS_DECOMPRESSION: bool = false

type Orchestrator = <I as Interface>::Orchestrator

The Orchestrator is an object that holds the SessionManager and any other state that needs to be shared between sessions. It is responsible for keeping the SessionManager alive. We use this type instead of directly holding an Arc in BlockServer, to avoid nested Arcs in concrete implementations which need to keep additional state.

type Session = Arc<Session<I>>

fn session_eq(a: &Arc<Session<I>>, b: &Arc<Session<I>>) -> bool

Returns true iff a and b identify the same session. Used to scope group-ID lookups in the shared active_requests slab to the originating session.

async fn on_attach_vmo( _orchestrator: Arc<Self::Orchestrator>, _vmo: &Arc<Vmo>, ) -> Result<(), Status>

fn get_info(&self) -> Cow<'_, DeviceInfo>

Called to get block/partition information for Block::GetInfo, Partition::GetTypeGuid, etc.

fn active_requests(&self) -> &ActiveRequests<Arc<Session<I>>>

Returns the active requests.

fn get_volume_info( &self, ) -> impl Future<Output = Result<(VolumeManagerInfo, VolumeInfo), Status>> + Send

Called to handle the GetVolumeInfo FIDL call.

fn query_slices( &self, _start_slices: &[u64], ) -> impl Future<Output = Result<Vec<VsliceRange>, Status>> + Send

Called to handle the QuerySlices FIDL call.

fn extend( &self, _start_slice: u64, _slice_count: u64, ) -> impl Future<Output = Result<(), Status>> + Send

Called to handle the Shrink FIDL call.

fn shrink( &self, _start_slice: u64, _slice_count: u64, ) -> impl Future<Output = Result<(), Status>> + Send

Called to handle the Shrink FIDL call.