Grcov report - config.rs

1

use std::path::Path;

2

3

#[cfg(feature = "encryption")]

4

use bonsaidb_core::document::KeyId;

5

use bonsaidb_core::{permissions::Permissions, schema::Schema};

6

use bonsaidb_local::config::{Builder, KeyValuePersistence, StorageConfiguration};

7

#[cfg(feature = "encryption")]

8

use bonsaidb_local::vault::AnyVaultKeyStorage;

9

10

/// Configuration options for [`Server`](crate::Server)

11

#[derive(Debug)]

12

#[must_use]

13

#[non_exhaustive]

14

pub struct ServerConfiguration {

15

    /// The DNS name of the server.

16

    pub server_name: String,

17

    /// Number of sumultaneous requests a single client can have in flight at a

18

    /// time. Default value is 16. It is important to have this number be tuned

19

    /// relative to `request_workers` such that one client cannot overwhelm the

20

    /// entire queue.

21

    pub client_simultaneous_request_limit: usize,

22

    /// Number of simultaneous requests to be processed. Default value is 16.

23

    pub request_workers: usize,

24

    /// Configuration options for individual databases.

25

    pub storage: StorageConfiguration,

26

    /// The permissions granted to all connections to this server.

27

    pub default_permissions: DefaultPermissions,

28

    /// The permissions granted to authenticated connections to this server.

29

    pub authenticated_permissions: DefaultPermissions,

30

    /// The ACME settings for automatic TLS certificate management.

31

    #[cfg(feature = "acme")]

32

    pub acme: AcmeConfiguration,

33

34

35

impl ServerConfiguration {

36

    /// Sets [`Self::server_name`](Self#structfield.server_name) to `server_name` and returns self.

37

32

    pub fn server_name(mut self, server_name: impl Into<String>) -> Self {

38

32

        self.server_name = server_name.into();

39

32

        self

40

32

41

42

    /// Sets [`Self::client_simultaneous_request_limit`](Self#structfield.client_simultaneous_request_limit) to `request_limit` and returns self.

43

    pub const fn client_simultaneous_request_limit(mut self, request_limit: usize) -> Self {

44

        self.client_simultaneous_request_limit = request_limit;

45

        self

46

47

48

    /// Sets [`Self::request_workers`](Self#structfield.request_workers) to `workers` and returns self.

49

    pub const fn request_workers(mut self, workers: usize) -> Self {

50

        self.request_workers = workers;

51

        self

52

53

54

    /// Sets [`Self::default_permissions`](Self#structfield.default_permissions) to `default_permissions` and returns self.

55

76

    pub fn default_permissions<P: Into<DefaultPermissions>>(

56

76

        mut self,

57

76

        default_permissions: P,

58

76

    ) -> Self {

59

76

        self.default_permissions = default_permissions.into();

60

76

        self

61

76

62

63

    /// Sets [`Self::authenticated_permissions`](Self#structfield.authenticated_permissions) to `authenticated_permissions` and returns self.

64

2

    pub fn authenticated_permissions<P: Into<DefaultPermissions>>(

65

2

        mut self,

66

2

        authenticated_permissions: P,

67

2

    ) -> Self {

68

2

        self.authenticated_permissions = authenticated_permissions.into();

69

2

        self

70

2

71

72

    /// Sets [`AcmeConfiguration::contact_email`] to `contact_email` and returns self.

73

    #[cfg(feature = "acme")]

74

    pub fn acme_contact_email(mut self, contact_email: impl Into<String>) -> Self {

75

        self.acme.contact_email = Some(contact_email.into());

76

        self

77

78

79

    /// Sets [`AcmeConfiguration::directory`] to `directory` and returns self.

80

    #[cfg(feature = "acme")]

81

    pub fn acme_directory(mut self, directory: impl Into<String>) -> Self {

82

        self.acme.directory = directory.into();

83

        self

84

85

86

87

impl Default for ServerConfiguration {

88

796

    fn default() -> Self {

89

796

        Self {

90

796

            server_name: String::from("bonsaidb"),

91

796

            client_simultaneous_request_limit: 16,

92

796

            // TODO this was arbitrarily picked, it probably should be higher,

93

796

            // but it also should probably be based on the cpu's capabilities

94

796

            request_workers: 16,

95

796

            storage: bonsaidb_local::config::StorageConfiguration::default(),

96

796

            default_permissions: DefaultPermissions::Permissions(Permissions::default()),

97

796

            authenticated_permissions: DefaultPermissions::Permissions(Permissions::default()),

98

796

            #[cfg(feature = "acme")]

99

796

            acme: AcmeConfiguration::default(),

100

796

101

796

102

103

104

#[cfg(feature = "acme")]

105

mod acme {

106

    /// The Automated Certificate Management Environment (ACME) configuration.

107

    #[derive(Debug)]

108

    pub struct AcmeConfiguration {

109

        /// The contact email to register with the ACME directory for the account.

110

        pub contact_email: Option<String>,

111

        /// The ACME directory to use for registration. The default is

112

        /// [`LETS_ENCRYPT_PRODUCTION_DIRECTORY`].

113

        pub directory: String,

114

115

116

    impl Default for AcmeConfiguration {

117

796

        fn default() -> Self {

118

796

            Self {

119

796

                contact_email: None,

120

796

                directory: LETS_ENCRYPT_PRODUCTION_DIRECTORY.to_string(),

121

796

122

796

123

124

125

    pub use async_acme::acme::{LETS_ENCRYPT_PRODUCTION_DIRECTORY, LETS_ENCRYPT_STAGING_DIRECTORY};

126

127

128

#[cfg(feature = "acme")]

129

pub use acme::*;

130

131

/// The default permissions to use for all connections to the server.

132

#[derive(Debug)]

133

pub enum DefaultPermissions {

134

    /// Allow all permissions. Do not use outside of completely trusted environments.

135

    AllowAll,

136

    /// A defined set of permissions.

137

    Permissions(Permissions),

138

139

140

impl From<DefaultPermissions> for Permissions {

141

1591

    fn from(permissions: DefaultPermissions) -> Self {

142

1591

        match permissions {

143

847

            DefaultPermissions::Permissions(permissions) => permissions,

144

744

            DefaultPermissions::AllowAll => Self::allow_all(),

145

146

1591

147

148

149

impl From<Permissions> for DefaultPermissions {

150

85

    fn from(permissions: Permissions) -> Self {

151

85

        Self::Permissions(permissions)

152

85

153

154

155

impl Builder for ServerConfiguration {

156

    fn with_schema<S: Schema>(mut self) -> Result<Self, bonsaidb_local::Error> {

157

74

        self.storage.register_schema::<S>()?;

158

74

        Ok(self)

159

74

160

161

76

    fn path<P: AsRef<Path>>(mut self, path: P) -> Self {

162

76

        self.storage.path = Some(path.as_ref().to_owned());

163

76

        self

164

76

165

166

    fn unique_id(mut self, unique_id: u64) -> Self {

167

        self.storage.unique_id = Some(unique_id);

168

        self

169

170

171

    #[cfg(feature = "encryption")]

172

    fn vault_key_storage<VaultKeyStorage: AnyVaultKeyStorage>(

173

        mut self,

174

        key_storage: VaultKeyStorage,

175

    ) -> Self {

176

        self.storage.vault_key_storage = Some(Box::new(key_storage));

177

        self

178

179

180

    #[cfg(feature = "encryption")]

181

34

    fn default_encryption_key(mut self, key: KeyId) -> Self {

182

34

        self.storage.default_encryption_key = Some(key);

183

34

        self

184

34

185

186

    fn tasks_worker_count(mut self, worker_count: usize) -> Self {

187

        self.storage.workers.worker_count = worker_count;

188

        self

189

190

191

    fn check_view_integrity_on_open(mut self, check: bool) -> Self {

192

        self.storage.views.check_integrity_on_open = check;

193

        self

194

195

196

306

    fn key_value_persistence(mut self, persistence: KeyValuePersistence) -> Self {

197

306

        self.storage.key_value_persistence = persistence;

198

306

        self

199

306

200