Struct S3Staging 

pub struct S3Staging {
    pub client: Client,
    pub bucket: String,
    pub root_path: String,
    pub root_path_slash: String,
    pub inode_file: String,
    pub config: StagingConfig,
    pub runtime_config: HyperFileRuntimeConfig,
    pub interceptor: Option<Arc<dyn StagingIntercept<Self>>>,
}

Fields

client: Client

bucket: String

root_path: String

root_path_slash: String

inode_file: String

config: StagingConfig

runtime_config: HyperFileRuntimeConfig

interceptor: Option<Arc<dyn StagingIntercept<Self>>>

Implementations

impl S3Staging

pub fn pesudo( client: &Client, config: StagingConfig, runtime_config: HyperFileRuntimeConfig, ) -> Self

pub async fn from( client: &Client, config: StagingConfig, runtime_config: HyperFileRuntimeConfig, ) -> Result<Self>

pub async fn create( client: &Client, config: StagingConfig, runtime_config: HyperFileRuntimeConfig, ) -> Result<Self>

impl S3Staging

pub async fn cli_list( client: &Client, bucket: &str, prefix: &str, segid: SegmentId, ) -> Result<Vec<SegmentId>>

pub async fn cli_build_block_map( client: &Client, bucket: &str, key: &str, ) -> Result<Vec<(BlockIndex, BlockPtr)>>

Trait Implementations

impl Clone for S3Staging

fn clone(&self) -> S3Staging

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl SegmentReadWrite for S3Staging

fn append(&self, segid: SegmentId, buf: &[u8]) -> Result<()>

async fn done(&self, segid: SegmentId, buf: &[u8], len: usize) -> Result<()>

async fn remove(&self, segid: SegmentId) -> Result<()>

async fn open(&self, segid: SegmentId) -> Result<SegmentSum>

async fn list(&self, segid: SegmentId) -> Result<Vec<SegmentId>>

async fn build_block_map( &self, segid: SegmentId, ) -> Result<Vec<(BlockIndex, BlockPtr)>>

impl Staging<S3BlockLoader> for S3Staging

fn to_block_loader(&self) -> S3BlockLoader

async fn load_inode(&self, buf: &mut [u8]) -> Result<Option<OnDiskState>>

async fn load_inode_from_segment( &self, buf: &mut [u8], segid: SegmentId, ) -> Result<Option<OnDiskState>>

async fn load_segment_timestamp(&self, segid: SegmentId) -> Result<(i64, i64)>

async fn flush_inode( &self, buf: &[u8], inode_state: &Option<OnDiskState>, flag: FlushInodeFlag, ) -> Result<Option<OnDiskState>>

async fn remove_inode(&self, inode_state: &Option<OnDiskState>) -> Result<()>

async fn load_data_block( &self, segid: SegmentId, staging_off: usize, offset: usize, block_size: usize, buf: &mut [u8], ) -> Result<()>

fn new_segwr( &self, segid: SegmentId, hyper_file_config: &HyperFileMetaConfig, ) -> Writer<S3Staging>

fn dir_filename(&self) -> (&str, &str)

fn root_path(&self) -> &str

fn config(&self) -> &StagingConfig

async fn unlink(&self) -> Result<()>

fn interceptor(&mut self, i: impl StagingIntercept<Self> + 'static)