Grcov report - backend.rs

1

use std::{fmt::Debug, marker::PhantomData};

2

3

use async_trait::async_trait;

4

use bonsaidb_core::{

5

    actionable,

6

    custom_api::{CustomApi, CustomApiError, Infallible},

7

    permissions::{Dispatcher, PermissionDenied},

8

    schema::{InsertError, InvalidNameError},

9

};

10

11

use crate::{server::ConnectedClient, CustomServer, Error};

12

13

/// Tailors the behavior of a server to your needs.

14

#[async_trait]

15

pub trait Backend: Debug + Send + Sync + Sized + 'static {

16

    /// The custom API definition. If you do not wish to have an API, `()` may be provided.

17

    type CustomApi: CustomApi;

18

19

    /// The type of data that can be stored in

20

    /// [`ConnectedClient::set_client_data`]. This allows state to be stored

21

    /// associated with each connected client.

22

    type ClientData: Send + Sync + Debug;

23

24

    /// The type that implements the

25

    /// [`Dispatcher`](bonsaidb_core::permissions::Dispatcher) trait.

26

    type CustomApiDispatcher: CustomApiDispatcher<Self>;

27

28

    /// Invoked once upon the server starting up.

29

    #[allow(unused_variables)]

30

70

    async fn initialize(server: &CustomServer<Self>) {}

31

32

    // TODO: add client connections events, client errors, etc.

33

    /// A client disconnected from the server. This is invoked before authentication has been performed.

34

    #[allow(unused_variables)]

35

    #[must_use]

36

116

    async fn client_connected(

37

116

        client: &ConnectedClient<Self>,

38

116

        server: &CustomServer<Self>,

39

116

    ) -> ConnectionHandling {

40

116

        log::info!(

41

            "{:?} client connected from {:?}",

42

            client.transport(),

43

            client.address()

44

);

45

46

116

        ConnectionHandling::Accept

47

232

48

49

    /// A client disconnected from the server.

50

    #[allow(unused_variables)]

51

56

    async fn client_disconnected(client: ConnectedClient<Self>, server: &CustomServer<Self>) {

52

56

        log::info!(

53

            "{:?} client disconnected ({:?})",

54

            client.transport(),

55

            client.address()

56

);

57

56

58

59

    /// A client successfully authenticated.

60

    #[allow(unused_variables)]

61

    async fn client_authenticated(client: ConnectedClient<Self>, server: &CustomServer<Self>) {

62

        log::info!(

63

            "{:?} client authenticated as user: {}",

64

            client.transport(),

65

            client.user_id().await.unwrap()

66

);

67

68

69

70

/// A trait that can dispatch requests for a [`CustomApi`].

71

pub trait CustomApiDispatcher<B: Backend>:

72

    Dispatcher<<B::CustomApi as CustomApi>::Request, Result = BackendApiResult<B::CustomApi>> + Debug

73

74

    /// Returns a dispatcher to handle custom api requests. The `server` and

75

    /// `client` parameters are provided to allow the dispatcher to have access

76

    /// to them when handling the individual actions.

77

    fn new(server: &CustomServer<B>, client: &ConnectedClient<B>) -> Self;

78

79

80

/// A [`Backend`] with no custom functionality.

81

#[cfg_attr(feature = "cli", derive(clap::Subcommand))]

82

#[derive(Debug)]

83

pub enum NoBackend {}

84

85

impl Backend for NoBackend {

86

    type CustomApi = ();

87

    type CustomApiDispatcher = NoDispatcher<Self>;

88

    type ClientData = ();

89

90

91

/// Defines a no-op dispatcher for a backend with no custom api.

92

#[derive(Debug)]

93

pub struct NoDispatcher<B: Backend>(PhantomData<B>);

94

95

impl<B: Backend<CustomApi = ()>> CustomApiDispatcher<B> for NoDispatcher<B> {

96

    fn new(_server: &CustomServer<B>, _client: &ConnectedClient<B>) -> Self {

97

        Self(PhantomData)

98

99

100

101

#[async_trait]

102

impl<B: Backend<CustomApi = ()>> actionable::Dispatcher<()> for NoDispatcher<B> {

103

    type Result = Result<(), BackendError>;

104

105

    async fn dispatch(&self, _permissions: &actionable::Permissions, _request: ()) -> Self::Result {

106

        Ok(())

107

108

109

110

/// Controls how a server should handle a connection.

111

pub enum ConnectionHandling {

112

    /// The server should accept this connection.

113

    Accept,

114

    /// The server should reject this connection.

115

    Reject,

116

117

118

/// An error that can occur inside of a [`Backend`] function.

119

#[derive(thiserror::Error, Debug)]

120

pub enum BackendError<E: CustomApiError = Infallible> {

121

    /// A backend-related error.

122

    #[error("backend error: {0}")]

123

    Backend(E),

124

    /// A server-related error.

125

    #[error("server error: {0}")]

126

    Server(#[from] Error),

127

128

129

impl<E: CustomApiError> From<PermissionDenied> for BackendError<E> {

130

4

    fn from(permission_denied: PermissionDenied) -> Self {

131

4

        Self::Server(Error::from(permission_denied))

132

4

133

134

135

impl<E: CustomApiError> From<bonsaidb_core::Error> for BackendError<E> {

136

    fn from(err: bonsaidb_core::Error) -> Self {

137

        Self::Server(Error::from(err))

138

139

140

141

impl<E: CustomApiError> From<InvalidNameError> for BackendError<E> {

142

    fn from(err: InvalidNameError) -> Self {

143

        Self::Server(Error::from(err))

144

145

146

147

#[cfg(feature = "websockets")]

148

impl<E: CustomApiError> From<bincode::Error> for BackendError<E> {

149

    fn from(other: bincode::Error) -> Self {

150

        Self::Server(Error::from(bonsaidb_local::Error::from(other)))

151

152

153

154

impl<E: CustomApiError> From<pot::Error> for BackendError<E> {

155

    fn from(other: pot::Error) -> Self {

156

        Self::Server(Error::from(bonsaidb_local::Error::from(other)))

157

158

159

160

impl<T, E> From<InsertError<T>> for BackendError<E>

161

where

162

    E: CustomApiError,

163

164

    fn from(error: InsertError<T>) -> Self {

165

        Self::Server(Error::from(error.error))

166

167

168

169

pub type BackendApiResult<Api> =

170

    Result<<Api as CustomApi>::Response, BackendError<<Api as CustomApi>::Error>>;