perf(jmap): reuse one JMAP client per account within a process

lib/BackgroundJob/SyncJob.php

@@ -152,6 +152,8 @@ protected function run($argument) {
 					'exception' => $e,
 				]);
 			}
+		} finally {
+			$this->protocolFactory->releaseClients($account);
 		}
 	}
 }

lib/Protocol/ConnectionPool.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Mail\Protocol;
+
+use JmapClient\Client as JmapClient;
+use OCA\Mail\Account;
+use OCA\Mail\Exception\ServiceException;
+use OCA\Mail\JMAP\JmapClientFactory;
+use function hash;
+use function json_encode;
+
+/**
+ * Long-running processes that handle many accounts must release each
+ * account once done, or connections accumulate for the whole process.
+ */
+class ConnectionPool {
+	/** @var array<int, array{fingerprint: string, client: JmapClient}> */
+	private array $jmapClients = [];
+
+	public function __construct(
+		private JmapClientFactory $jmapClientFactory,
+	) {
+	}
+
+	/**
+	 * @throws ServiceException
+	 */
+	public function jmap(Account $account): JmapClient {
+		$id = $account->getId();
+		$fingerprint = $this->fingerprint($account);
+
+		$entry = $this->jmapClients[$id] ?? null;
+		if ($entry !== null && $entry['fingerprint'] === $fingerprint) {
+			return $entry['client'];
+		}
+
+		$client = $this->jmapClientFactory->getClient($account);
+		$this->jmapClients[$id] = [
+			'fingerprint' => $fingerprint,
+			'client' => $client,
+		];
+		return $client;
+	}
+
+	public function release(Account $account): void {
+		unset($this->jmapClients[$account->getId()]);
+	}
+
+	private function fingerprint(Account $account): string {
+		$mailAccount = $account->getMailAccount();
+		return hash('sha256', json_encode([
+			$mailAccount->getProtocol(),
+			$mailAccount->getInboundHost(),
+			$mailAccount->getInboundPort(),
+			$mailAccount->getInboundSslMode(),
+			$mailAccount->getPath(),
+			$mailAccount->getInboundUser(),
+			$mailAccount->getInboundPassword(),
+			$mailAccount->getAuthMethod(),
+		], JSON_THROW_ON_ERROR));
+	}
+}

lib/Protocol/ProtocolFactory.php

@@ -51,6 +51,7 @@ public function __construct(
 		private ContainerInterface $container,
 		private IMAPClientFactory $imapClientFactory,
 		private JmapClientFactory $jmapClientFactory,
+		private ConnectionPool $connectionPool,
 	) {
 	}
 
@@ -63,11 +64,17 @@ public function imapClient(Account $account, bool $useCache = true): Horde_Imap_
 	}
 
 	/**
+	 * Get the account's shared JMAP client, which may already be connected
+	 *
 	 * @throws ServiceException
 	 */
 	public function jmapClient(Account $account): JmapClient {
 		$this->verifyProtocol($account, MailAccount::PROTOCOL_JMAP);
-		return $this->jmapClientFactory->getClient($account);
+		return $this->connectionPool->jmap($account);
+	}
+
+	public function releaseClients(Account $account): void {
+		$this->connectionPool->release($account);
 	}
 
 	/**
@@ -84,10 +91,7 @@ public function testConnection(Account $account): void {
 		}
 
 		if ($protocol === MailAccount::PROTOCOL_JMAP) {
-			$client = $this->jmapClient($account);
-			if (!$client->sessionStatus()) {
-				$client->connect();
-			}
+			$this->jmapClientFactory->getClient($account)->connect();
 			return;
 		}
 

lib/Service/DraftsService.php

@@ -211,6 +211,12 @@ public function flush() {
 				]);
 			}
 		}
+
+		foreach ($accounts as $account) {
+			if ($account !== null) {
+				$this->protocolFactory->releaseClients($account);
+			}
+		}
 	}
 
 	/**

lib/Service/JMAP/JmapOperationsService.php

@@ -64,8 +64,6 @@
 class JmapOperationsService {
 	protected Client $dataStore;
 	protected ?string $dataAccount = null;
-	private ?int $sessionAccountId = null;
-	private bool $supportsBlob = false;
 
 	protected array $entityPropertiesBasic = [
 		'id', 'blobId', 'threadId', 'mailboxIds', 'messageId', 'size',
@@ -98,22 +96,17 @@ public function __construct(
 	public function connect(Account $account): bool {
 		$this->dataStore = $this->protocolFactory->jmapClient($account);
 		try {
-			// evaluate if client was already connected
 			if (!$this->dataStore->sessionStatus()) {
 				$this->dataStore->connect();
 			}
 		} catch (Throwable $e) {
 			throw new ServiceException('Could not connect to JMAP server: ' . $e->getMessage(), 0, $e);
 		}
-		if ($this->sessionAccountId !== $account->getId()) {
-			$sessionAccount = $this->dataStore->sessionAccountDefault('mail');
-			if ($sessionAccount === null) {
-				throw new ServiceException('JMAP session does not provide a default mail account', 1);
-			}
-			$this->sessionAccountId = $account->getId();
-			$this->dataAccount = $sessionAccount->id();
-			$this->supportsBlob = $this->dataStore->sessionCapable('blob');
+		$sessionAccount = $this->dataStore->sessionAccountDefault('mail');
+		if ($sessionAccount === null) {
+			throw new ServiceException('JMAP session does not provide a default mail account', 1);
 		}
+		$this->dataAccount = $sessionAccount->id();
 
 		return true;
 	}

lib/Service/OutboxService.php

@@ -16,6 +16,7 @@
 use OCA\Mail\Events\OutboxMessageCreatedEvent;
 use OCA\Mail\Exception\ClientException;
 use OCA\Mail\Exception\ServiceException;
+use OCA\Mail\Protocol\ProtocolFactory;
 use OCA\Mail\Send\Chain;
 use OCA\Mail\Service\Attachment\AttachmentService;
 use OCP\AppFramework\Db\DoesNotExistException;
@@ -42,6 +43,7 @@ public function __construct(
 		ITimeFactory $timeFactory,
 		private LoggerInterface $logger,
 		private Chain $sendChain,
+		private ProtocolFactory $protocolFactory,
 	) {
 		$this->eventDispatcher = $eventDispatcher;
 		$this->timeFactory = $timeFactory;
@@ -210,6 +212,12 @@ public function flush(): void {
 				]);
 			}
 		}
+
+		foreach ($accounts as $account) {
+			if ($account !== null) {
+				$this->protocolFactory->releaseClients($account);
+			}
+		}
 	}
 
 	public function convertDraft(LocalMessage $draftMessage, int $sendAt): LocalMessage {

tests/Integration/Service/OutboxServiceIntegrationTest.php

@@ -19,6 +19,7 @@
 use OCA\Mail\Db\MailAccount;
 use OCA\Mail\Db\MailboxMapper;
 use OCA\Mail\Db\MessageMapper;
+use OCA\Mail\Protocol\ProtocolFactory;
 use OCA\Mail\Send\Chain;
 use OCA\Mail\Service\AccountService;
 use OCA\Mail\Service\Attachment\AttachmentService;
@@ -119,7 +120,8 @@ protected function setUp(): void {
 			$this->accountService,
 			$this->timeFactory,
 			$this->createMock(LoggerInterface::class),
-			$this->chain
+			$this->chain,
+			Server::get(ProtocolFactory::class),
 		);
 	}
 

tests/Unit/BackgroundJob/SyncJobTest.php

@@ -14,7 +14,10 @@
 use OC\BackgroundJob\JobList;
 use OCA\Mail\Account;
 use OCA\Mail\BackgroundJob\SyncJob;
+use OCA\Mail\Contracts\IMailboxConnector;
+use OCA\Mail\Contracts\IMessageConnector;
 use OCA\Mail\Db\MailAccount;
+use OCA\Mail\Exception\ServiceException;
 use OCP\AppFramework\Db\DoesNotExistException;
 use OCP\IConfig;
 use OCP\IUser;
@@ -130,6 +133,56 @@ public function testUserDoesntExist(): void {
 		$this->job->start($this->createMock(JobList::class));
 	}
 
+	private function mockSyncableAccount(): Account {
+		$mailAccount = new MailAccount();
+		$mailAccount->setProtocol(MailAccount::PROTOCOL_JMAP);
+		$account = $this->createMock(Account::class);
+		$account->method('getId')->willReturn(123);
+		$account->method('getUserId')->willReturn('user123');
+		$account->method('getMailAccount')->willReturn($mailAccount);
+		$this->serviceMock->getParameter('accountService')
+			->method('findById')
+			->with(123)
+			->willReturn($account);
+		$user = $this->createConfiguredMock(IUser::class, [
+			'isEnabled' => true,
+		]);
+		$this->serviceMock->getParameter('userManager')
+			->method('get')
+			->with('user123')
+			->willReturn($user);
+		return $account;
+	}
+
+	public function testReleasesClientsAfterSync(): void {
+		$account = $this->mockSyncableAccount();
+		$protocolFactory = $this->serviceMock->getParameter('protocolFactory');
+		$protocolFactory->method('mailboxConnector')
+			->willReturn($this->createMock(IMailboxConnector::class));
+		$protocolFactory->method('messageConnector')
+			->willReturn($this->createMock(IMessageConnector::class));
+		$protocolFactory->expects(self::once())
+			->method('releaseClients')
+			->with($account);
+
+		$this->job->start($this->createMock(JobList::class));
+	}
+
+	public function testReleasesClientsWhenSyncFails(): void {
+		$account = $this->mockSyncableAccount();
+		$mailboxConnector = $this->createMock(IMailboxConnector::class);
+		$mailboxConnector->method('syncAll')
+			->willThrowException(new ServiceException('Could not connect to JMAP server'));
+		$protocolFactory = $this->serviceMock->getParameter('protocolFactory');
+		$protocolFactory->method('mailboxConnector')
+			->willReturn($mailboxConnector);
+		$protocolFactory->expects(self::once())
+			->method('releaseClients')
+			->with($account);
+
+		$this->job->start($this->createMock(JobList::class));
+	}
+
 	public function testDisabledJob(): void {
 		$config = $this->createMock(IConfig::class);