Struct Server 

pub struct Server {
    pub inner: Arc<Inner>,
    pub core: Arc<Core>,
}

Fields

inner: Arc<Inner>

core: Arc<Core>

Implementations

impl Server

pub async fn email_to_id( &self, directory: &Directory, email: &str, session_id: u64, ) -> Result<Option<u32>>

pub async fn rcpt( &self, directory: &Directory, email: &str, session_id: u64, ) -> Result<RcptType>

pub async fn vrfy( &self, directory: &Directory, address: &str, session_id: u64, ) -> Result<Vec<String>>

pub async fn expn( &self, directory: &Directory, address: &str, session_id: u64, ) -> Result<Vec<String>>

impl Server

pub async fn get_access_token( &self, principal: impl Into<PrincipalOrId>, ) -> Result<Arc<AccessToken>>

pub async fn invalidate_principal_caches( &self, changed_principals: ChangedPrincipals, )

impl Server

pub async fn introspect_access_token( &self, token: &str, access_token: &AccessToken, ) -> Result<OAuthIntrospect>

impl Server

pub fn issue_id_token( &self, subject: impl Into<String>, issuer: impl Into<String>, audience: impl Into<String>, claims: StandardClaims, ) -> Result<String>

impl Server

pub async fn encode_access_token( &self, grant_type: GrantType, account_id: u32, client_id: &str, expiry_in: u64, ) -> Result<String>

pub async fn validate_access_token( &self, expected_grant_type: Option<GrantType>, token_: &str, ) -> Result<TokenInfo>

pub async fn password_hash(&self, account_id: u32) -> Result<String>

impl Server

pub async fn is_http_authenticated_request_allowed( &self, access_token: &AccessToken, ) -> Result<Option<InFlight>>

pub async fn is_http_anonymous_request_allowed( &self, addr: &IpAddr, ) -> Result<()>

pub fn is_upload_allowed( &self, access_token: &AccessToken, ) -> Result<Option<InFlight>>

impl Server

pub async fn get_role_permissions( &self, role_id: u32, ) -> Result<Arc<RolePermissions>>

impl Server

pub async fn authenticate( &self, req: &AuthRequest<'_>, ) -> Result<Arc<AccessToken>>

impl Server

pub fn build_mta_sts_policy(&self) -> Option<Policy>

impl Server

pub fn store(&self) -> &Store

pub fn blob_store(&self) -> &BlobStore

pub fn search_store(&self) -> &SearchStore

pub fn in_memory_store(&self) -> &InMemoryStore

pub fn directory(&self) -> &Directory

pub fn get_directory(&self, name: &str) -> Option<&Arc<Directory>>

pub fn get_directory_or_default( &self, name: &str, session_id: u64, ) -> &Arc<Directory>

pub fn get_in_memory_store(&self, name: &str) -> Option<&InMemoryStore>

pub fn get_in_memory_store_or_default( &self, name: &str, session_id: u64, ) -> &InMemoryStore

pub fn get_data_store(&self, name: &str, session_id: u64) -> &Store

pub fn get_arc_sealer( &self, name: &str, session_id: u64, ) -> Option<Arc<ArcSealer>>

pub fn get_dkim_signer( &self, name: &str, session_id: u64, ) -> Option<Arc<DkimSigner>>

pub fn get_trusted_sieve_script( &self, name: &str, session_id: u64, ) -> Option<&Arc<Sieve>>

pub fn get_untrusted_sieve_script( &self, name: &str, session_id: u64, ) -> Option<&Arc<Sieve>>

pub fn get_route_or_default( &self, name: &str, session_id: u64, ) -> &RoutingStrategy

pub fn get_virtual_queue_or_default(&self, name: &QueueName) -> &VirtualQueue

pub fn get_queue_or_default( &self, name: &str, session_id: u64, ) -> &QueueStrategy

pub fn get_tls_or_default(&self, name: &str, session_id: u64) -> &TlsStrategy

pub fn get_connection_or_default( &self, name: &str, session_id: u64, ) -> &ConnectionStrategy

pub async fn get_used_quota(&self, account_id: u32) -> Result<i64>

pub async fn has_available_quota( &self, quotas: &ResourceToken, item_size: u64, ) -> Result<()>

pub async fn get_resource_token( &self, access_token: &AccessToken, account_id: u32, ) -> Result<ResourceToken>

pub async fn archives<I, CB>( &self, account_id: u32, collection: Collection, documents: &I, cb: CB, ) -> Result<()>

where I: DocumentSet + Send + Sync, CB: FnMut(u32, Archive<AlignedBytes>) -> Result<bool> + Send + Sync,

pub async fn all_archives<CB>( &self, account_id: u32, collection: Collection, field: u8, cb: CB, ) -> Result<()>

where CB: FnMut(u32, Archive<AlignedBytes>) -> Result<()> + Send + Sync,

pub async fn document_ids( &self, account_id: u32, collection: Collection, field: impl Into<u8>, ) -> Result<RoaringBitmap>

pub async fn document_exists( &self, account_id: u32, collection: Collection, field: impl Into<u8>, filter: impl AsRef<[u8]>, ) -> Result<bool>

pub async fn document_ids_matching( &self, account_id: u32, collection: Collection, field: impl Into<u8>, filter: impl AsRef<[u8]>, ) -> Result<RoaringBitmap>

pub fn notify_task_queue(&self)

pub async fn total_queued_messages(&self) -> Result<u64>

pub fn generate_snowflake_id(&self) -> u64

pub async fn commit_batch(&self, builder: BatchBuilder) -> Result<AssignedIds>

pub async fn delete_changes( &self, account_id: u32, max_entries: Option<usize>, max_duration: Option<Duration>, ) -> Result<()>

pub async fn broadcast_push_notification( &self, notification: PushNotification, ) -> bool

pub async fn cluster_broadcast(&self, event: BroadcastEvent)

pub async fn put_jmap_blob( &self, account_id: u32, data: &[u8], ) -> Result<BlobId>

pub async fn put_temporary_blob( &self, account_id: u32, data: &[u8], hold_for: u64, ) -> Result<(BlobHash, BlobOp)>

pub async fn total_accounts(&self) -> Result<u64>

pub async fn total_domains(&self) -> Result<u64>

pub async fn spam_model_reload(&self) -> Result<()>

impl Server

pub async fn dns_exists_mx(&self, entry: &str) -> Result<bool>

pub async fn dns_exists_ip(&self, entry: &str) -> Result<bool>

pub async fn dns_exists_ptr(&self, entry: &str) -> Result<bool>

pub async fn dns_exists_ipv4(&self, entry: &str) -> Result<bool>

pub async fn dns_exists_ipv6(&self, entry: &str) -> Result<bool>

impl Server

pub async fn eval_if<'x, R: TryFrom<Variable<'x>>, V: ResolveVariable>( &'x self, if_block: &'x IfBlock, resolver: &'x V, session_id: u64, ) -> Option<R>

pub async fn eval_expr<'x, R: TryFrom<Variable<'x>>, V: ResolveVariable>( &'x self, expr: &'x Expression, resolver: &'x V, expr_id: &str, session_id: u64, ) -> Option<R>

impl Server

pub async fn renew(&self, provider: &AcmeProvider) -> Result<Duration>

impl Server

pub async fn init_acme(&self, provider: &AcmeProvider) -> Result<Duration>

pub fn has_acme_tls_providers(&self) -> bool

pub fn has_acme_http_providers(&self) -> bool

impl Server

pub async fn lookup_asn_country(&self, ip: IpAddr) -> AsnGeoLookupResult

impl Server

pub async fn is_rcpt_fail2banned(&self, ip: IpAddr, rcpt: &str) -> Result<bool>

pub async fn is_scanner_fail2banned(&self, ip: IpAddr) -> Result<bool>

pub async fn is_http_banned_path(&self, path: &str, ip: IpAddr) -> Result<bool>

pub async fn is_loiter_fail2banned(&self, ip: IpAddr) -> Result<bool>

pub async fn is_auth_fail2banned( &self, ip: IpAddr, login: Option<&str>, ) -> Result<bool>

pub async fn block_ip(&self, ip: IpAddr) -> Result<()>

pub fn has_auth_fail2ban(&self) -> bool

pub fn is_ip_blocked(&self, ip: &IpAddr) -> bool

pub fn is_ip_allowed(&self, ip: &IpAddr) -> bool

impl Server

pub async fn reload_blocked_ips(&self) -> Result<ReloadResult>

pub async fn reload_certificates(&self) -> Result<ReloadResult>

pub async fn reload_lookups(&self) -> Result<ReloadResult>

pub async fn reload(&self) -> Result<ReloadResult>

impl Server

pub async fn refresh_acls( &self, acl_changes: &[AclGrant], current: Option<&[AclGrant]>, )

pub async fn refresh_archived_acls( &self, acl_changes: &[AclGrant], acl_current: &[ArchivedAclGrant], )

impl Server

pub async fn get_blob_section( &self, hash: &BlobHash, section: &BlobSection, ) -> Result<Option<Vec<u8>>>

impl Server

pub async fn subscribe_push_manager( &self, access_token: &AccessToken, types: Bitmap<DataType>, ) -> Result<Receiver<PushNotification>>

impl Server

pub async fn export_prometheus_metrics(&self) -> Result<String>

impl Server

pub async fn process_alerts(&self) -> Option<Vec<AlertMessage>>

impl Server

pub fn is_enterprise_edition(&self) -> bool

pub fn licensed_accounts(&self) -> u32

pub fn log_license_details(&self)

pub async fn can_create_account(&self) -> Result<bool>

pub async fn logo_resource( &self, domain: &str, ) -> Result<Option<Resource<Vec<u8>>>>

Trait Implementations

impl AnalyzeReport for Server

fn analyze_report(&self, message: Message<'static>, session_id: u64)

impl Authenticator for Server

async fn authenticate_headers( &self, req: &HttpRequest, session: &HttpSessionData, allow_api_access: bool, ) -> Result<(Option<InFlight>, Arc<AccessToken>)>

impl Autoconfig for Server

async fn handle_autoconfig_request( &self, req: &HttpRequest, ) -> Result<HttpResponse>

async fn handle_autodiscover_request( &self, body: Option<Vec<u8>>, ) -> Result<HttpResponse>

async fn autoconfig_parameters<'x>( &'x self, emailaddress: &'x str, fail_if_invalid: bool, ) -> Result<(String, String, &'x str)>

impl BlobCopy for Server

async fn blob_copy( &self, request: CopyBlobRequest, access_token: &AccessToken, ) -> Result<CopyBlobResponse>

impl BlobDownload for Server

async fn blob_download( &self, blob_id: &BlobId, access_token: &AccessToken, ) -> Result<Option<Vec<u8>>>

async fn has_access_blob( &self, blob_id: &BlobId, access_token: &AccessToken, ) -> Result<bool>

impl BlobOperations for Server

async fn blob_get( &self, request: GetRequest<Blob>, access_token: &AccessToken, ) -> Result<GetResponse<Blob>>

async fn blob_lookup( &self, request: BlobLookupRequest, ) -> Result<BlobLookupResponse>

impl BlobUpload for Server

async fn blob_upload_many( &self, request: BlobUploadRequest, access_token: &AccessToken, ) -> Result<BlobUploadResponse>

async fn blob_upload( &self, account_id: Id, content_type: &str, data: &[u8], access_token: Arc<AccessToken>, ) -> Result<UploadResponse>

impl ChangesLookup for Server

async fn changes( &self, request: ChangesRequest, object: MethodObject, access_token: &AccessToken, ) -> Result<IntermediateChangesResponse>

impl ClientRegistrationHandler for Server

async fn handle_oauth_registration_request( &self, req: &mut HttpRequest, session: HttpSessionData, ) -> Result<HttpResponse>

async fn validate_client_registration( &self, client_id: &str, redirect_uri: Option<&str>, account_id: u32, ) -> Result<Option<ErrorType>>

impl Clone for Server

fn clone(&self) -> Server

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CryptoHandler for Server

async fn handle_crypto_get( &self, access_token: Arc<AccessToken>, ) -> Result<HttpResponse>

async fn handle_crypto_post( &self, access_token: Arc<AccessToken>, body: Option<Vec<u8>>, ) -> Result<HttpResponse>

impl DavRequestHandler for Server

async fn handle_dav_request( &self, request: HttpRequest, access_token: Arc<AccessToken>, session: &HttpSessionData, resource: DavResourceName, method: DavMethod, ) -> HttpResponse

impl DkimManagement for Server

async fn handle_manage_dkim( &self, req: &HttpRequest, path: Vec<&str>, body: Option<Vec<u8>>, access_token: &AccessToken, ) -> Result<HttpResponse>

async fn handle_get_public_key(&self, path: Vec<&str>) -> Result<HttpResponse>

async fn handle_create_signature( &self, body: Option<Vec<u8>>, ) -> Result<HttpResponse>

async fn create_dkim_key( &self, algo: Algorithm, id: impl AsRef<str>, domain: impl Into<String>, selector: impl Into<String>, ) -> Result<()>

impl DmarcReporting for Server

async fn send_dmarc_aggregate_report(&self, event: ReportEvent)

async fn generate_dmarc_aggregate_report( &self, event: &ReportEvent, rua: &mut Vec<URI>, serialized_size: Option<&mut Serializer<SerializedSize>>, span_id: u64, ) -> Result<Option<Report>>

async fn delete_dmarc_report(&self, event: ReportEvent)

async fn schedule_dmarc(&self, event: Box<DmarcEvent>)

impl DnsLookup for Server

async fn ip_lookup( &self, key: &str, strategy: IpLookupStrategy, max_results: usize, ) -> Result<Vec<IpAddr>>

async fn resolve_host( &self, remote_host: &NextHop<'_>, envelope: &impl ResolveVariable, ) -> Result<IpLookupResult, Status<HostResponse<Box<str>>, ErrorDetails>>

impl DnsManagement for Server

async fn handle_manage_dns( &self, req: &HttpRequest, path: Vec<&str>, access_token: &AccessToken, ) -> Result<HttpResponse>

async fn build_dns_records(&self, domain_name: &str) -> Result<Vec<DnsRecord>>

impl EmailCopy for Server

async fn copy_message( &self, from_account_id: u32, from_message_id: u32, resource_token: &ResourceToken, mailboxes: Vec<u32>, keywords: Vec<Keyword>, received_at: Option<u64>, session_id: u64, ) -> Result<Result<IngestedEmail, CopyMessageError>>

impl EmailDeletion for Server

async fn emails_delete( &self, account_id: u32, tenant_id: Option<u32>, batch: &mut BatchBuilder, document_ids: RoaringBitmap, ) -> Result<RoaringBitmap>

async fn purge_accounts(&self, use_roles: bool)

async fn purge_account(&self, account_id: u32)

async fn emails_auto_expunge( &self, account_id: u32, hold_period: u64, ) -> Result<()>

async fn purge_email_submissions( &self, account_id: u32, hold_period: u64, ) -> Result<()>

impl EmailGet for Server

async fn email_get( &self, request: GetRequest<Email>, access_token: &AccessToken, ) -> Result<GetResponse<Email>>

impl EmailImport for Server

async fn email_import( &self, request: ImportEmailRequest, access_token: &AccessToken, session: &HttpSessionData, ) -> Result<ImportEmailResponse>

impl EmailIngest for Server

async fn email_ingest(&self, params: IngestEmail<'_>) -> Result<IngestedEmail>

async fn find_thread_id( &self, account_id: u32, thread_name: &str, message_ids: &[CheekyHash], ) -> Result<ThreadResult>

async fn assign_email_ids( &self, account_id: u32, mailbox_ids: impl IntoIterator<Item = u32> + Sync + Send, generate_email_id: bool, ) -> Result<impl Iterator<Item = u32> + 'static>

async fn add_account_spam_sample( &self, batch: &mut BatchBuilder, account_id: u32, document_id: u32, is_spam: bool, span_id: u64, ) -> Result<()>

fn add_spam_sample( &self, batch: &mut BatchBuilder, hash: BlobHash, is_spam: bool, hold_sample: bool, span_id: u64, )

impl EmailParse for Server

async fn email_parse( &self, request: ParseRequest<Email>, access_token: &AccessToken, ) -> Result<ParseResponse<Email>>

impl EmailQuery for Server

async fn email_query( &self, request: QueryRequest<Email>, access_token: &AccessToken, ) -> Result<QueryResponse>

impl EmailSearchSnippet for Server

async fn email_search_snippet( &self, request: GetSearchSnippetRequest, access_token: &AccessToken, ) -> Result<GetSearchSnippetResponse>

impl EmailSet for Server

async fn email_set( &self, request: SetRequest<'_, Email>, access_token: &AccessToken, session: &HttpSessionData, ) -> Result<SetResponse<Email>>

impl EmailSubmissionGet for Server

async fn email_submission_get( &self, request: GetRequest<EmailSubmission>, ) -> Result<GetResponse<EmailSubmission>>

impl EmailSubmissionQuery for Server

async fn email_submission_query( &self, request: QueryRequest<EmailSubmission>, ) -> Result<QueryResponse>

impl EmailSubmissionSet for Server

async fn email_submission_set<'x>( &self, request: SetRequest<'x, EmailSubmission>, instance: &Arc<ServerInstance>, next_call: &mut Option<Call<RequestMethod<'x>>>, ) -> Result<SetResponse<EmailSubmission>>

async fn send_message( &self, account_id: u32, response: &SetResponse<EmailSubmission>, instance: &Arc<ServerInstance>, object: Value<'_, EmailSubmissionProperty, EmailSubmissionValue>, ) -> Result<Result<EmailSubmission, SetError<EmailSubmissionProperty>>>

impl EventSourceHandler for Server

async fn handle_event_source( &self, req: HttpRequest, access_token: Arc<AccessToken>, ) -> Result<HttpResponse>

impl FormHandler for Server

async fn handle_contact_form( &self, session: &HttpSessionData, form: &ContactForm, form_data: FormData, ) -> Result<HttpResponse>

impl GroupwareCache for Server

async fn fetch_dav_resources( &self, access_token: &AccessToken, account_id: u32, collection: SyncCollection, ) -> Result<Arc<DavResources>>

async fn create_default_addressbook( &self, access_token: &AccessToken, account_id: u32, account_name: &str, ) -> Result<Option<u32>>

async fn create_default_calendar( &self, access_token: &AccessToken, account_id: u32, account_name: &str, ) -> Result<Option<u32>>

async fn get_or_create_default_calendar( &self, access_token: &AccessToken, account_id: u32, ) -> Result<Option<u32>>

fn cached_dav_resources( &self, account_id: u32, collection: SyncCollection, ) -> Option<Arc<DavResources>>

impl HasQueueQuota for Server

async fn has_quota(&self, message: &mut MessageWrapper) -> bool

async fn check_quota<'x>( &'x self, quota: &'x QueueQuota, envelope: &impl ResolveVariable, size: u64, id: u64, refs: &mut Vec<QuotaKey>, session_id: u64, ) -> bool

impl IdentityGet for Server

async fn identity_get( &self, request: GetRequest<Identity>, ) -> Result<GetResponse<Identity>>

async fn identity_get_or_create(&self, account_id: u32) -> Result<RoaringBitmap>

impl IdentitySet for Server

async fn identity_set( &self, request: SetRequest<'_, Identity>, access_token: &AccessToken, ) -> Result<SetResponse<Identity>>

impl IsAllowed for Server

async fn is_allowed<'x>( &'x self, throttle: &'x QueueRateLimiter, envelope: &impl ResolveVariable, session_id: u64, ) -> Result<(), u64>

impl ItipAutoExpunge for Server

async fn itip_ids(&self, account_id: u32) -> Result<RoaringBitmap>

async fn itip_auto_expunge( &self, account_id: u32, hold_period: u64, ) -> Result<()>

impl ItipIngest for Server

async fn itip_ingest( &self, access_token: &AccessToken, resource_token: &ResourceToken, sender: &str, recipient: &str, itip_message: &str, ) -> Result<Option<ItipMessage<ICalendar>>, ItipIngestError>

async fn http_rsvp_url( &self, account_id: u32, document_id: u32, attendee: &str, ) -> Option<ItipRsvpUrl>

async fn http_rsvp_handle(&self, query: &str, language: &str) -> Result<String>

impl JmapAcl for Server

async fn acl_validate( &self, grants: &[AclGrant], ) -> Result<(), ShareValidationError>

impl JmapEmailCopy for Server

async fn email_copy<'x>( &self, request: CopyRequest<'x, Email>, access_token: &AccessToken, next_call: &mut Option<Call<RequestMethod<'x>>>, session: &HttpSessionData, ) -> Result<CopyResponse<Email>>

impl LockReport for Server

async fn try_lock_report(&self, key: &[u8]) -> bool

async fn unlock_report(&self, key: &[u8])

impl LogManagement for Server

async fn handle_view_logs( &self, req: &HttpRequest, access_token: &AccessToken, ) -> Result<HttpResponse>

impl MailDelivery for Server

async fn deliver_message(&self, message: IngestMessage) -> LocalDeliveryResult

impl MailboxDestroy for Server

async fn mailbox_destroy( &self, account_id: u32, document_id: u32, access_token: &AccessToken, remove_emails: bool, ) -> Result<Result<Option<u64>, MailboxDestroyError>>

impl MailboxFnc for Server

async fn create_system_folders(&self, account_id: u32) -> Result<()>

async fn mailbox_create_path( &self, account_id: u32, path: &str, ) -> Result<Option<u32>>

impl MailboxGet for Server

async fn mailbox_get( &self, request: GetRequest<Mailbox>, access_token: &AccessToken, ) -> Result<GetResponse<Mailbox>>

impl MailboxQuery for Server

async fn mailbox_query( &self, request: QueryRequest<Mailbox>, access_token: &AccessToken, ) -> Result<QueryResponse>

impl MailboxSet for Server

async fn mailbox_set( &self, request: SetRequest<'_, Mailbox>, access_token: &AccessToken, ) -> Result<SetResponse<Mailbox>>

async fn mailbox_set_item( &self, changes_: Map<'_, MailboxProperty, MailboxValue>, update: Option<(u32, Archive<Mailbox>)>, ctx: &SetContext<'_>, ) -> Result<Result<ObjectIndexBuilder<Mailbox, Mailbox>, SetError<MailboxProperty>>>

impl ManageReload for Server

async fn handle_manage_reload( &self, req: &HttpRequest, path: Vec<&str>, access_token: &AccessToken, ) -> Result<HttpResponse>

async fn handle_manage_update( &self, req: &HttpRequest, path: Vec<&str>, access_token: &AccessToken, ) -> Result<HttpResponse>

impl ManageReports for Server

async fn handle_manage_reports( &self, req: &HttpRequest, path: Vec<&str>, access_token: &AccessToken, ) -> Result<HttpResponse>

impl ManageSettings for Server

async fn handle_manage_settings( &self, req: &HttpRequest, path: Vec<&str>, body: Option<Vec<u8>>, access_token: &AccessToken, ) -> Result<HttpResponse>

impl ManageSpamHandler for Server

async fn handle_manage_spam( &self, req: &HttpRequest, path: Vec<&str>, body: Option<Vec<u8>>, session: &HttpSessionData, access_token: &AccessToken, ) -> Result<HttpResponse>

impl ManageStore for Server

async fn handle_manage_store( &self, req: &HttpRequest, path: Vec<&str>, body: Option<Vec<u8>>, session: &HttpSessionData, access_token: &AccessToken, ) -> Result<HttpResponse>

async fn housekeeper_request( &self, event: HousekeeperEvent, ) -> Result<HttpResponse>

impl ManagementApi for Server

async fn handle_api_manage_request( &self, req: &mut HttpRequest, access_token: Arc<AccessToken>, session: &HttpSessionData, ) -> Result<HttpResponse>

impl MergeThreadsTask for Server

async fn merge_threads( &self, account_id: u32, threads: &MergeThreadIds<AHashSet<u32>>, ) -> bool

impl MessageCacheFetch for Server

async fn get_cached_messages( &self, account_id: u32, ) -> Result<Arc<MessageStoreCache>>

impl MtaStsLookup for Server

async fn lookup_mta_sts_policy( &self, domain: &str, timeout: Duration, ) -> Result<Arc<Policy>, Error>

impl OAuthApiHandler for Server

async fn handle_oauth_api_request( &self, access_token: Arc<AccessToken>, body: Option<Vec<u8>>, ) -> Result<HttpResponse>

async fn handle_device_auth( &self, req: &mut HttpRequest, session: HttpSessionData, ) -> Result<HttpResponse>

async fn handle_oauth_metadata( &self, req: HttpRequest, session: HttpSessionData, ) -> Result<HttpResponse>

impl OpenIdHandler for Server

async fn handle_userinfo_request( &self, access_token: &AccessToken, ) -> Result<HttpResponse>

async fn handle_oidc_metadata( &self, req: HttpRequest, session: HttpSessionData, ) -> Result<HttpResponse>

impl ParseHttp for Server

async fn parse_http_request( &self, req: HttpRequest, session: HttpSessionData, ) -> Result<HttpResponse>

impl PrincipalGet for Server

async fn principal_get( &self, request: GetRequest<Principal>, access_token: &AccessToken, ) -> Result<GetResponse<Principal>>

impl PrincipalManager for Server

async fn handle_manage_principal( &self, req: &HttpRequest, path: Vec<&str>, body: Option<Vec<u8>>, access_token: &AccessToken, ) -> Result<HttpResponse>

async fn handle_account_auth_get( &self, access_token: Arc<AccessToken>, ) -> Result<HttpResponse>

async fn handle_account_auth_post( &self, req: &HttpRequest, access_token: Arc<AccessToken>, body: Option<Vec<u8>>, ) -> Result<HttpResponse>

fn assert_supported_directory(&self, override_: bool) -> Result<()>

impl PrincipalQuery for Server

async fn principal_query( &self, request: QueryRequest<Principal>, access_token: &AccessToken, session: &HttpSessionData, ) -> Result<QueryResponse>

impl Purge for Server

async fn purge(&self, purge: PurgeType, store_idx: u32)

impl PushSubscriptionFetch for Server

async fn push_subscription_get( &self, request: GetRequest<PushSubscription>, access_token: &AccessToken, ) -> Result<GetResponse<PushSubscription>>

impl PushSubscriptionSet for Server

async fn push_subscription_set( &self, request: SetRequest<'_, PushSubscription>, access_token: &AccessToken, ) -> Result<SetResponse<PushSubscription>>

impl QueryChanges for Server

async fn query_changes( &self, request: QueryChangesRequestMethod, access_token: &AccessToken, ) -> Result<QueryChangesResponse>

impl QueueManagement for Server

async fn handle_manage_queue( &self, req: &HttpRequest, path: Vec<&str>, access_token: &AccessToken, ) -> Result<HttpResponse>

impl QuotaGet for Server

async fn quota_get( &self, request: GetRequest<Quota>, access_token: &AccessToken, ) -> Result<GetResponse<Quota>>

impl QuotaQuery for Server

async fn quota_query( &self, request: QueryRequest<Quota>, access_token: &AccessToken, ) -> Result<QueryResponse>

impl ReindexIndexTask for Server

async fn reindex( &self, index: SearchIndex, account_id: Option<u32>, tenant_id: Option<u32>, ) -> Result<()>

impl RequestHandler for Server

async fn handle_jmap_request<'x>( &self, request: Request<'x>, access_token: Arc<AccessToken>, session: &HttpSessionData, ) -> Response<'x>

async fn handle_method_call<'x>( &self, method: RequestMethod<'x>, method_name: MethodName, access_token: &AccessToken, next_call: &mut Option<Call<RequestMethod<'x>>>, session: &HttpSessionData, ) -> Result<ResponseMethod<'x>>

impl RunScript for Server

async fn run_script( &self, script_id: String, script: Arc<Sieve>, params: ScriptParameters<'_>, ) -> ScriptResult

impl SendAlarmTask for Server

async fn send_alarm( &self, account_id: u32, document_id: u32, alarm: &CalendarAlarm, server_instance: Arc<ServerInstance>, ) -> bool

impl SendDsn for Server

async fn send_dsn(&self, message: &mut MessageWrapper)

async fn log_dsn(&self, message: &MessageWrapper)

impl SendImipTask for Server

async fn send_imip( &self, account_id: u32, document_id: u32, due: TaskEpoch, server_instance: Arc<ServerInstance>, ) -> bool

impl SessionHandler for Server

async fn handle_session_resource( &self, base_url: String, access_token: Arc<AccessToken>, ) -> Result<Session>

impl SieveScriptDelete for Server

async fn sieve_script_delete( &self, account_id: u32, document_id: u32, access_token: &AccessToken, batch: &mut BatchBuilder, ) -> Result<bool>

impl SieveScriptGet for Server

async fn sieve_script_get( &self, request: GetRequest<Sieve>, ) -> Result<GetResponse<Sieve>>

impl SieveScriptIngest for Server

async fn sieve_script_ingest( &self, access_token: &AccessToken, blob_hash: &BlobHash, raw_message: &[u8], envelope_from: &str, envelope_from_authenticated: bool, envelope_to: &IngestRecipient, session_id: u64, active_script: ActiveScript, autogenerated: &mut Vec<AutogeneratedMessage>, ) -> Result<IngestedEmail>

async fn sieve_script_get_active_id( &self, account_id: u32, ) -> Result<Option<u32>>

async fn sieve_script_get_active( &self, account_id: u32, ) -> Result<Option<ActiveScript>>

async fn sieve_script_get_by_name( &self, account_id: u32, name: &str, ) -> Result<Option<Sieve>>

async fn sieve_script_compile( &self, account_id: u32, document_id: u32, ) -> Result<Option<CompiledScript>>

impl SieveScriptQuery for Server

async fn sieve_script_query( &self, request: QueryRequest<Sieve>, ) -> Result<QueryResponse>

impl SieveScriptSet for Server

async fn sieve_script_set( &self, request: SetRequest<'_, Sieve>, access_token: &AccessToken, session: &HttpSessionData, ) -> Result<SetResponse<Sieve>>

async fn sieve_set_item<'x>( &self, changes_: Value<'_, SieveProperty, SieveValue>, update: Option<(u32, Archive<&'x ArchivedSieveScript>)>, ctx: &SetContext<'_>, session_id: u64, ) -> Result<Result<(ObjectIndexBuilder<&'x ArchivedSieveScript, SieveScript>, Option<Vec<u8>>), SetError<SieveProperty>>>

impl SieveScriptValidate for Server

async fn sieve_script_validate( &self, request: ValidateSieveScriptRequest, access_token: &AccessToken, ) -> Result<ValidateSieveScriptResponse>

impl SmtpReporting for Server

async fn send_report( &self, from_addr: &str, rcpts: impl Iterator<Item = impl AsRef<str> + Sync + Send> + Sync + Send, report: Vec<u8>, sign_config: &IfBlock, deliver_now: bool, parent_session_id: u64, )

async fn send_autogenerated( &self, from_addr: impl AsRef<str> + Sync + Send, rcpts: impl Iterator<Item = impl AsRef<str> + Sync + Send> + Sync + Send, raw_message: Vec<u8>, sign_config: Option<&IfBlock>, parent_session_id: u64, )

async fn schedule_report(&self, report: impl Into<ReportingEvent> + Sync + Send)

async fn sign_message( &self, message: &mut MessageWrapper, config: &IfBlock, bytes: &[u8], ) -> Option<Vec<u8>>

impl SmtpSpool for Server

fn new_message( &self, return_path: impl AsRef<str>, span_id: u64, ) -> MessageWrapper

async fn next_event(&self, queue: &mut Queue) -> QueuedMessages

async fn try_lock_event(&self, queue_id: QueueId, queue_name: QueueName) -> bool

async fn unlock_event(&self, queue_id: QueueId, queue_name: QueueName)

async fn read_message( &self, queue_id: QueueId, queue_name: QueueName, ) -> Option<MessageWrapper>

async fn read_message_archive( &self, id: QueueId, ) -> Result<Option<Archive<AlignedBytes>>>

impl SpamClassifier for Server

async fn spam_train(&self, retrain: bool) -> Result<()>

async fn spam_classify(&self, ctx: &mut SpamFilterContext<'_>) -> Result<()>

async fn spam_build_tokens<'x>( &self, ctx: &'x SpamFilterContext<'_>, ) -> Tokens<'x>

impl SpamFilterAnalyzeClassify for Server

async fn spam_filter_analyze_classify(&self, ctx: &mut SpamFilterContext<'_>)

async fn spam_filter_analyze_spam_trap( &self, ctx: &mut SpamFilterContext<'_>, ) -> bool

impl SpamFilterAnalyzeDate for Server

async fn spam_filter_analyze_date(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeDmarc for Server

async fn spam_filter_analyze_dmarc(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeDomain for Server

async fn spam_filter_analyze_domain(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeEhlo for Server

async fn spam_filter_analyze_ehlo(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeFrom for Server

async fn spam_filter_analyze_from(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeHeaders for Server

async fn spam_filter_analyze_headers(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeHtml for Server

async fn spam_filter_analyze_html(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeIp for Server

async fn spam_filter_analyze_ip(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeLlm for Server

async fn spam_filter_analyze_llm(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeMid for Server

async fn spam_filter_analyze_message_id(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeMime for Server

async fn spam_filter_analyze_mime(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzePyzor for Server

async fn spam_filter_analyze_pyzor(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeReceived for Server

async fn spam_filter_analyze_received(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeRecipient for Server

async fn spam_filter_analyze_recipient(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeReplyTo for Server

async fn spam_filter_analyze_reply_to(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeRules for Server

async fn spam_filter_analyze_rules(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeScore for Server

async fn spam_filter_finalize( &self, ctx: &mut SpamFilterContext<'_>, ) -> SpamFilterAction<SpamFilterScore>

async fn spam_filter_classify( &self, ctx: &mut SpamFilterContext<'_>, ) -> SpamFilterAction<SpamFilterScore>

impl SpamFilterAnalyzeSubject for Server

async fn spam_filter_analyze_subject(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterAnalyzeUrl for Server

async fn spam_filter_analyze_url(&self, ctx: &mut SpamFilterContext<'_>)

impl SpamFilterInit for Server

fn spam_filter_init<'x>( &self, input: SpamFilterInput<'x>, ) -> SpamFilterContext<'x>

impl StateManager for Server

async fn get_state( &self, account_id: u32, collection: SyncCollection, ) -> Result<State>

async fn assert_state( &self, account_id: u32, collection: SyncCollection, if_in_state: &Option<State>, ) -> Result<State>

impl TelemetryApi for Server

async fn handle_telemetry_api_request( &self, req: &HttpRequest, path: Vec<&str>, access_token: &AccessToken, ) -> Result<HttpResponse>

impl ThreadGet for Server

async fn thread_get( &self, request: GetRequest<Thread>, ) -> Result<GetResponse<Thread>>

impl TlsReporting for Server

async fn send_tls_aggregate_report(&self, events: Vec<ReportEvent>)

async fn generate_tls_aggregate_report( &self, events: &[ReportEvent], rua: &mut Vec<ReportUri>, serialized_size: Option<&mut Serializer<SerializedSize>>, span_id: u64, ) -> Result<Option<TlsReport>>

async fn schedule_tls(&self, event: Box<TlsEvent>)

async fn delete_tls_report(&self, events: Vec<ReportEvent>)

impl TlsaLookup for Server

async fn tlsa_lookup<'x>( &self, key: impl IntoFqdn<'x> + Sync + Send, ) -> Result<Option<Arc<Tlsa>>>

impl TokenHandler for Server

async fn handle_token_request( &self, req: &mut HttpRequest, session: HttpSessionData, ) -> Result<HttpResponse>

async fn handle_token_introspect( &self, req: &mut HttpRequest, access_token: &AccessToken, session_id: u64, ) -> Result<HttpResponse>

async fn issue_token( &self, account_id: u32, client_id: &str, issuer: String, nonce: Option<String>, with_refresh_token: bool, with_id_token: bool, ) -> Result<OAuthResponse>

impl TroubleshootApi for Server

async fn handle_troubleshoot_api_request( &self, req: &HttpRequest, path: Vec<&str>, access_token: &AccessToken, body: Option<Vec<u8>>, ) -> Result<HttpResponse>

impl UndeleteApi for Server

async fn handle_undelete_api_request( &self, req: &HttpRequest, path: Vec<&str>, body: Option<Vec<u8>>, session: &HttpSessionData, ) -> Result<HttpResponse>

impl VacationResponseGet for Server

async fn vacation_response_get( &self, request: GetRequest<VacationResponse>, ) -> Result<GetResponse<VacationResponse>>

async fn get_vacation_sieve_script_id( &self, account_id: u32, ) -> Result<Option<u32>>

impl VacationResponseSet for Server

async fn vacation_response_set( &self, request: SetRequest<'_, VacationResponse>, access_token: &AccessToken, ) -> Result<SetResponse<VacationResponse>>

fn build_script(&self, obj: &mut SieveScript) -> Result<Vec<u8>>

impl WebSocketHandler for Server

async fn handle_websocket_stream( &self, stream: WebSocketStream<TokioIo<Upgraded>>, access_token: Arc<AccessToken>, session: HttpSessionData, )

impl WebSocketUpgrade for Server

async fn upgrade_websocket_connection( &self, req: HttpRequest, access_token: Arc<AccessToken>, session: HttpSessionData, ) -> Result<HttpResponse>