Struct Service 

pub struct Service {
    services: Arc<OnceServices>,
    channel: RwLock<Option<Sender<CommandInput>>>,
    pub handle: RwLock<Option<Processor>>,
    pub complete: RwLock<Option<Completer>>,
    pub admin_alias: OwnedRoomAliasId,
    pub console: Arc<Console>,
}

Fields

services: Arc<OnceServices>

channel: RwLock<Option<Sender<CommandInput>>>

handle: RwLock<Option<Processor>>

complete: RwLock<Option<Completer>>

admin_alias: OwnedRoomAliasId

console: Arc<Console>

Implementations

impl Service

pub(super) async fn console_auto_start(&self)

Possibly spawn the terminal console at startup if configured.

impl Service

pub(super) async fn console_auto_stop(&self)

Shutdown the console when the admin worker terminates.

impl Service

pub async fn startup_execute(&self) -> Result

Execute admin commands after startup

impl Service

pub(super) async fn signal_execute(&self) -> Result

Execute admin commands after signal

impl Service

async fn execute_command(&self, i: usize, command: String) -> Result

Execute one admin command after startup or signal

impl Service

fn execute_command_output(i: usize, content: &RoomMessageEventContent) -> Result

impl Service

fn execute_command_error(i: usize, content: &RoomMessageEventContent) -> Result

impl Service

pub async fn make_user_admin(&self, user_id: &UserId) -> Result

Invite the user to the tuwunel admin room.

This is equivalent to granting server admin privileges.

impl Service

pub async fn revoke_admin(&self, user_id: &UserId) -> Result

Demote an admin, removing its rights.

impl Service

pub async fn notice(&self, body: &str)

Sends markdown notice to the admin room as the admin user.

pub async fn send_text(&self, body: &str)

Sends markdown message (not an m.notice for notification reasons) to the admin room as the admin user.

pub async fn send_message( &self, message_content: RoomMessageEventContent, ) -> Result

Sends a message to the admin room as the admin user (see send_text() for convenience).

pub async fn command( &self, command: String, reply_id: Option<OwnedEventId>, ) -> Result

Posts a command to the command processor queue and returns. Processing will take place on the service worker’s task asynchronously. Errors if the queue is full.

pub async fn command_in_place( &self, command: String, reply_id: Option<OwnedEventId>, ) -> ProcessorResult

Dispatches a command to the processor on the current task and waits for completion.

pub fn complete_command(&self, command: &str) -> Option<String>

Invokes the tab-completer to complete the command. When unavailable, None is returned.

async fn handle_signal(&self, sig: &'static str)

async fn handle_command(&self, command: CommandInput)

async fn handle_command_output(&self, content: RoomMessageEventContent)

async fn process_command(&self, command: CommandInput) -> ProcessorResult

pub async fn user_is_admin(&self, user_id: &UserId) -> bool

Checks whether a given user is an admin of this server

pub async fn get_admin_room(&self) -> Result<OwnedRoomId>

Gets the room ID of the admin room

Errors are propagated from the database, and will have None if there is no admin room

async fn handle_response(&self, content: RoomMessageEventContent) -> Result

async fn respond_to_room( &self, content: RoomMessageEventContent, room_id: &RoomId, user_id: &UserId, ) -> Result

async fn handle_response_error( &self, e: Error, room_id: &RoomId, user_id: &UserId, state_lock: &RoomMutexGuard, ) -> Result

pub async fn is_admin_command<Pdu>(&self, event: &Pdu, body: &str) -> bool

where Pdu: Event,

pub async fn is_admin_room(&self, room_id_: &RoomId) -> bool

Trait Implementations

impl Service for Service

fn build(args: &Args<'_>) -> Result<Arc<Self>>

Implement the construction of the service instance. Services are generally singletons so expect this to only be called once for a service type. Note that it may be called again after a server reload, but the prior instance will have been dropped first. Failure will shutdown the server with an error.

fn worker<'async_trait>( self: Arc<Self>, ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

where Self: 'async_trait,

Implement the service’s worker loop. The service manager spawns a task and calls this function after all services have been built.

fn interrupt<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Interrupt the service. This is sent to initiate a graceful shutdown. The service worker should return from its work loop.

fn name(&self) -> &str

Return the name of the service. i.e. crate::service::make_name(std::module_path!())

fn clear_cache<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear any caches or similar runtime state.

fn memory_usage<'life0, 'life1, 'async_trait>( &'life0 self, _out: &'life1 mut (dyn Write + Send), ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Memory usage report in a markdown string.

fn unconstrained(&self) -> bool

Return true if the service worker opts out of the tokio cooperative budgeting. This can reduce tail latency at the risk of event loop starvation.