Struct bonsaidb_server::CustomServer

pub struct CustomServer<B: Backend = NoBackend> { /* private fields */ }

A BonsaiDb server.

Implementations

impl<B: Backend> CustomServer<B>

pub async fn listen_for_tcp_on<S: TcpService, T: ToSocketAddrs + Send + Sync>(
    &self,
    addr: T,
    service: S
) -> Result<(), Error>

Listens for HTTP traffic on port. This port will also receive WebSocket connections if feature websockets is enabled.

pub async fn listen_for_secure_tcp_on<S: TcpService, T: ToSocketAddrs + Send + Sync>(
    &self,
    addr: T,
    service: S
) -> Result<(), Error>

Listens for HTTPS traffic on port. This port will also receive WebSocket connections if feature websockets is enabled. If feature acme is enabled, this connection will automatically manage the server’s private key and certificate, which is also used for the QUIC-based protocol.

impl<B: Backend> CustomServer<B>

pub async fn listen_for_websockets_on<T: ToSocketAddrs + Send + Sync>(
    &self,
    addr: T,
    with_tls: bool
) -> Result<(), Error>

Listens for websocket connections on addr.

pub async fn handle_websocket<S: Stream<Item = Result<Message, E>> + Sink<Message> + Send + 'static, E: Debug + Send>(
    &self,
    connection: S,
    peer_address: SocketAddr
)

Handles an established tokio-tungstenite WebSocket stream.

impl<B: Backend> CustomServer<B>

pub async fn open(configuration: ServerConfiguration) -> Result<Self, Error>

Opens a server using directory for storage.

pub fn pinned_certificate_path(&self) -> PathBuf

Returns the path to the public pinned certificate, if this server has one. Note: this function will always succeed, but the file may not exist.

pub fn primary_domain(&self) -> &str

Returns the primary domain configured for this server.

pub async fn admin(&self) -> ServerDatabase<B>

Returns the administration database.

pub async fn install_self_signed_certificate(
    &self,
    overwrite: bool
) -> Result<(), Error>

Installs an X.509 certificate used for general purpose connections.

pub async fn install_pem_certificate(
    &self,
    certificate_chain: &[u8],
    private_key: &[u8]
) -> Result<(), Error>

Installs a certificate chain and private key used for TLS connections.

pub async fn install_certificate(
    &self,
    certificate_chain: &CertificateChain,
    private_key: &PrivateKey
) -> Result<(), Error>

Installs a certificate chain and private key used for TLS connections.

pub async fn certificate_chain(&self) -> Result<CertificateChain, Error>

Returns the current certificate chain.

pub async fn listen_on(&self, port: u16) -> Result<(), Error>

Listens for incoming client connections. Does not return until the server shuts down.

pub async fn connected_clients(&self) -> Vec<ConnectedClient<B>>

Returns all of the currently connected clients.

pub async fn broadcast(&self, response: CustomApiResult<B::CustomApi>)

Sends a custom API response to all connected clients.

pub async fn shutdown(&self, timeout: Option<Duration>) -> Result<(), Error>

Shuts the server down. If a timeout is provided, the server will stop accepting new connections and attempt to respond to any outstanding requests already being processed. After the timeout has elapsed or if no timeout was provided, the server is forcefully shut down.

pub async fn listen_for_shutdown(&self) -> Result<(), Error>

Listens for signals from the operating system that the server should shut down and attempts to gracefully shut down.

pub async fn authenticate_client_as<'name, N: Nameable<'name, u64> + Send + Sync>(
    &self,
    user: N,
    client: &ConnectedClient<B>
) -> Result<Permissions, Error>

Manually authenticates client as user. user can be the user’s id (u64) or the username (String/str). Returns the permissions that the user now has.

Methods from Deref<Target = Storage>

pub async fn backup<L>(&'_ self, location: L) -> Result<(), Error> where
    L: AnyBackupLocation, 

Stores a copy of all data in this instance to location.

pub async fn restore<L>(&'_ self, location: L) -> Result<(), Error> where
    L: AnyBackupLocation, 

Stores a copy of all data in this instance to location.

pub fn path(&self) -> &Path

Returns the path of the database storage.

pub fn unique_id(&self) -> StorageId

Returns the unique id of the server.

This value is set from the StorageConfiguration or randomly generated when creating a server. It shouldn’t be changed after a server is in use, as doing can cause issues. For example, the vault that manages encrypted storage uses the server ID to store the vault key. If the server ID changes, the vault key storage will need to be updated with the new server ID.

pub async fn register_schema<DB>(&'_ self) -> Result<(), Error> where
    DB: Schema, 

Registers a schema for use within the server.

pub async fn admin(&'_ self) -> Database

Returns the administration database.

Trait Implementations

impl<B: Backend> AcmeCache for CustomServer<B>

type Error = Error

The error type returned from the functions on this trait.

fn read_account<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    contacts: &'life1 [&'life2 str]
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Returns the previously written data for contacts, if any. This function should return None instead of erroring if data was not previously written for contacts.

fn write_account<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    contacts: &'life1 [&'life2 str],
    contents: &'life3 [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

Writes data for contacts. The data being written is unique for the combined list of contacts.

fn write_certificate<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
    &'life0 self,
    _domains: &'life1 [String],
    _directory_url: &'life2 str,
    key_pem: &'life3 str,
    certificate_pem: &'life4 str
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    'life4: 'async_trait,
    Self: 'async_trait, 

Writes a certificate retrieved from Acme. The parameters are:

impl<B: Backend> Clone for CustomServer<B>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Backend> Debug for CustomServer<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Backend> Deref for CustomServer<B>

type Target = Storage

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<B: Backend> ResolvesServerCert for CustomServer<B>

fn resolve(&self, client_hello: ClientHello<'_>) -> Option<Arc<CertifiedKey>>

Choose a certificate chain and matching key given simplified ClientHello information.

impl<B: Backend> StorageConnection for CustomServer<B>

type Database = ServerDatabase<B>

The type that represents a database for this implementation.

fn create_database_with_schema<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str,
    schema: SchemaName,
    only_if_needed: bool
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Creates a database named name using the SchemaName schema.

fn database<'life0, 'life1, 'async_trait, DB: Schema>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Self::Database, Error>> + Send + 'async_trait>> where
    DB: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Returns a reference to database name with schema DB.

fn delete_database<'life0, 'life1, 'async_trait>(
    &'life0 self,
    name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Deletes a database named name.

fn list_databases<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<Database>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Lists the databases in this storage.

fn list_available_schemas<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<SchemaName>, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Lists the SchemaNames registered with this storage.

fn create_user<'life0, 'life1, 'async_trait>(
    &'life0 self,
    username: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<u64, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Creates a user.

fn set_user_password<'user, 'life0, 'async_trait, U: Nameable<'user, u64> + Send + Sync>(
    &'life0 self,
    user: U,
    password: SensitiveString
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'user: 'async_trait,
    U: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Sets a user’s password.

fn authenticate<'user, 'life0, 'async_trait, U: Nameable<'user, u64> + Send + Sync>(
    &'life0 self,
    user: U,
    authentication: Authentication
) -> Pin<Box<dyn Future<Output = Result<Authenticated, Error>> + Send + 'async_trait>> where
    'user: 'async_trait,
    U: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Authenticates as a user with a authentication method.

fn add_permission_group_to_user<'user, 'group, 'life0, 'async_trait, U: Nameable<'user, u64> + Send + Sync, G: Nameable<'group, u64> + Send + Sync>(
    &'life0 self,
    user: U,
    permission_group: G
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'user: 'async_trait,
    'group: 'async_trait,
    U: 'async_trait,
    G: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Adds a user to a permission group.

fn remove_permission_group_from_user<'user, 'group, 'life0, 'async_trait, U: Nameable<'user, u64> + Send + Sync, G: Nameable<'group, u64> + Send + Sync>(
    &'life0 self,
    user: U,
    permission_group: G
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'user: 'async_trait,
    'group: 'async_trait,
    U: 'async_trait,
    G: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Removes a user from a permission group.

fn add_role_to_user<'user, 'group, 'life0, 'async_trait, U: Nameable<'user, u64> + Send + Sync, G: Nameable<'group, u64> + Send + Sync>(
    &'life0 self,
    user: U,
    role: G
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'user: 'async_trait,
    'group: 'async_trait,
    U: 'async_trait,
    G: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Adds a user to a permission group.

fn remove_role_from_user<'user, 'group, 'life0, 'async_trait, U: Nameable<'user, u64> + Send + Sync, G: Nameable<'group, u64> + Send + Sync>(
    &'life0 self,
    user: U,
    role: G
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'user: 'async_trait,
    'group: 'async_trait,
    U: 'async_trait,
    G: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Removes a user from a permission group.

fn create_database<'life0, 'life1, 'async_trait, DB>(
    &'life0 self,
    name: &'life1 str,
    only_if_needed: bool
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    DB: Schema + 'async_trait,
    Self: 'async_trait, 

Creates a database named name with the Schema provided.