Struct FileSystem 

pub struct FileSystem<T: ShoalTable> {
    pub conf: Conf,
    pub intent_tx: AsyncSender<CompactionJob>,
    pub tasks: FuturesUnordered<Task<Result<(), ServerError>>>,
    /* private fields */
}

Store shoal data in an existing filesytem for persistence

Fields

conf: Conf

The config for shoal

intent_tx: AsyncSender<CompactionJob>

The channel to send intent log compactions on

tasks: FuturesUnordered<Task<Result<(), ServerError>>>

The different tasks spawned by this shards file system storage engine

Trait Implementations

impl<T: ShoalTable + 'static> ShoalStorage<T> for FileSystem<T>

where <T as Archive>::Archived: Deserialize<T, Strategy<Pool, Error>>, <T::Sort as Archive>::Archived: Deserialize<T::Sort, Strategy<Pool, Error>>, <T::Update as Archive>::Archived: Deserialize<T::Update, Strategy<Pool, Error>>, <<T as ShoalTable>::Sort as Archive>::Archived: Ord,

async fn new( shard_name: &str, conf: &Conf, medium_priority: TaskQueueHandle, ) -> Result<Self, ServerError>

Create a new instance of this storage engine

Arguments

• shard_name - The id of the shard that owns this table
• conf - The Shoal config

async fn insert(&mut self, insert: &Intents<T>) -> Result<u64, ServerError>

Write this new row to our storage

Arguments

• insert - The row to write

async fn delete( &mut self, partition_key: u64, sort_key: T::Sort, ) -> Result<u64, ServerError>

Delete a row from storage

Arguments

• partition_key - The key to the partition we are deleting data from
• sort_key - The sort key to use to delete data from with in a partition

async fn update(&mut self, update: Update<T>) -> Result<u64, ServerError>

Write a row update to storage

Arguments

• update - The update that was applied to our row

fn add_pending( &mut self, meta: QueryMetadata, pos: u64, response: ResponseAction<T>, )

Add a pending response action thats data is still being flushed

Arguments

• meta - The metadata for this query
• pos - The position at which this entry will have been flushed to disk
• response - The pending response action

async fn get_flushed( &mut self, flushed: &mut Vec<(SocketAddr, Response<T>)>, ) -> Result<(), ServerError>

Get all flushed response actions

Arguments

• flushed - The flushed actions to return

async fn flush(&mut self) -> Result<(), ServerError>

Flush all currently pending writes to storage

async fn read_intents( path: &PathBuf, partitions: &mut HashMap<u64, Partition<T>>, ) -> Result<(), ServerError>

Read an intent log from storage

Arguments

• path - The path to the intent log to read in

async fn shutdown(&mut self) -> Result<(), ServerError>

Shutdown this storage engine