Struct MessagesRpcService 

pub struct MessagesRpcService {
    pub store: Arc<RedisMessageStorage>,
    pub stream_sender: UnboundedSender<StreamMessage>,
    pub response_sender: UnboundedSender<CatchUpResponse>,
    pub subscription: Arc<RwLock<SubscriptionConfig>>,
    pub task_handle: Arc<RwLock<Option<AbortHandle>>>,
}

Fields

store: Arc<RedisMessageStorage>

stream_sender: UnboundedSender<StreamMessage>

Channel for sending streaming messages back to the relay service

response_sender: UnboundedSender<CatchUpResponse>

Channel for sending catch-up responses back to the relay service

subscription: Arc<RwLock<SubscriptionConfig>>

The current subscription config

task_handle: Arc<RwLock<Option<AbortHandle>>>

the running task handle for the subscription task

Implementations

impl MessagesRpcService

pub fn new( store: Arc<RedisMessageStorage>, ) -> (UnboundedReceiver<StreamMessage>, UnboundedReceiver<CatchUpResponse>, Self)

async fn start_subscription_task(&self) -> Result<(), MessageStoreError>

async fn abort_subscription_task(&self) -> Result<(), MessageStoreError>

Trait Implementations

impl Clone for MessagesRpcService

fn clone(&self) -> MessagesRpcService

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl MessageService for MessagesRpcService

async fn publish( self, _context: Context, message: MessageFull, ) -> Result<PublishResult, MessageError>

async fn message( self, _context: Context, id: MessageId, ) -> Result<Option<MessageFull>, MessageError>

Retrieve a specific message by its ID

async fn user_data( self, _context: Context, author: KeyId, storage_key: StoreKey, ) -> Result<Option<MessageFull>, MessageError>

Retrieve a specific user’s data by their key and storage key

async fn check_messages( self, _context: Context, message_ids: Vec<MessageId>, ) -> Result<Vec<Option<String>>, MessageError>

Check which messages the server already has and return their global stream IDs. Returns a vec of Option<String> in the same order as the input, where:

async fn subscribe( self, _context: Context, config: SubscriptionConfig, ) -> Result<(), MessageError>

Start the subscription

async fn update_filters( self, _context: Context, request: FilterUpdateRequest, ) -> Result<SubscriptionConfig, MessageError>

Update the running subscription filters with the actions. Returns the now final subscription config.

async fn catch_up( self, _context: Context, request: CatchUpRequest, ) -> Result<SubscriptionConfig, MessageError>

Update the internal subscription and catch up to the latest stream height for the given filter

fn serve(self) -> ServeMessageService<Self>

Returns a serving function to use with InFlightRequest::execute.