nextcloud / server

apps/files_external/lib/Lib/MissingDependency.php

Indentation +36 added lines, -36 removed lines

@@ -11,40 +11,40 @@
  */
 class MissingDependency {
 
-	/** @var string|null Custom message */
-	private ?string $message = null;
-	private bool $optional = false;
-
-	/**
-	 * @param string $dependency
-	 */
-	public function __construct(
-		private readonly string $dependency,
-	) {
-	}
-
-	public function getDependency(): string {
-		return $this->dependency;
-	}
-
-	public function getMessage(): ?string {
-		return $this->message;
-	}
-
-	/**
-	 * @param string $message
-	 * @return self
-	 */
-	public function setMessage($message) {
-		$this->message = $message;
-		return $this;
-	}
-
-	public function isOptional(): bool {
-		return $this->optional;
-	}
-
-	public function setOptional(bool $optional): void {
-		$this->optional = $optional;
-	}
+    /** @var string|null Custom message */
+    private ?string $message = null;
+    private bool $optional = false;
+
+    /**
+     * @param string $dependency
+     */
+    public function __construct(
+        private readonly string $dependency,
+    ) {
+    }
+
+    public function getDependency(): string {
+        return $this->dependency;
+    }
+
+    public function getMessage(): ?string {
+        return $this->message;
+    }
+
+    /**
+     * @param string $message
+     * @return self
+     */
+    public function setMessage($message) {
+        $this->message = $message;
+        return $this;
+    }
+
+    public function isOptional(): bool {
+        return $this->optional;
+    }
+
+    public function setOptional(bool $optional): void {
+        $this->optional = $optional;
+    }
 }

apps/files_external/lib/Lib/Backend/SMB.php

Indentation +110 added lines, -110 removed lines

@@ -24,119 +24,119 @@
 use OCP\IUser;
 
 class SMB extends Backend {
-	public function __construct(IL10N $l, Password $legacyAuth) {
-		$this
-			->setIdentifier('smb')
-			->addIdentifierAlias('\OC\Files\Storage\SMB')// legacy compat
-			->setStorageClass('\OCA\Files_External\Lib\Storage\SMB')
-			->setText($l->t('SMB/CIFS'))
-			->addParameters([
-				new DefinitionParameter('host', $l->t('Host')),
-				new DefinitionParameter('share', $l->t('Share')),
-				(new DefinitionParameter('root', $l->t('Remote subfolder')))
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-				(new DefinitionParameter('domain', $l->t('Domain')))
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-				(new DefinitionParameter('show_hidden', $l->t('Show hidden files')))
-					->setType(DefinitionParameter::VALUE_BOOLEAN)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-				(new DefinitionParameter('case_sensitive', $l->t('Case sensitive file system')))
-					->setType(DefinitionParameter::VALUE_BOOLEAN)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL)
-					->setDefaultValue(true)
-					->setTooltip($l->t('Disabling it will allow to use a case insensitive file system, but comes with a performance penalty')),
-				(new DefinitionParameter('check_acl', $l->t('Verify ACL access when listing files')))
-					->setType(DefinitionParameter::VALUE_BOOLEAN)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL)
-					->setTooltip($l->t("Check the ACL's of each file or folder inside a directory to filter out items where the account has no read permissions, comes with a performance penalty")),
-				(new DefinitionParameter('timeout', $l->t('Timeout')))
-					->setType(DefinitionParameter::VALUE_TEXT)
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-			])
-			->addAuthScheme(AuthMechanism::SCHEME_PASSWORD)
-			->addAuthScheme(AuthMechanism::SCHEME_SMB)
-			->setLegacyAuthMechanism($legacyAuth);
-	}
+    public function __construct(IL10N $l, Password $legacyAuth) {
+        $this
+            ->setIdentifier('smb')
+            ->addIdentifierAlias('\OC\Files\Storage\SMB')// legacy compat
+            ->setStorageClass('\OCA\Files_External\Lib\Storage\SMB')
+            ->setText($l->t('SMB/CIFS'))
+            ->addParameters([
+                new DefinitionParameter('host', $l->t('Host')),
+                new DefinitionParameter('share', $l->t('Share')),
+                (new DefinitionParameter('root', $l->t('Remote subfolder')))
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+                (new DefinitionParameter('domain', $l->t('Domain')))
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+                (new DefinitionParameter('show_hidden', $l->t('Show hidden files')))
+                    ->setType(DefinitionParameter::VALUE_BOOLEAN)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+                (new DefinitionParameter('case_sensitive', $l->t('Case sensitive file system')))
+                    ->setType(DefinitionParameter::VALUE_BOOLEAN)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL)
+                    ->setDefaultValue(true)
+                    ->setTooltip($l->t('Disabling it will allow to use a case insensitive file system, but comes with a performance penalty')),
+                (new DefinitionParameter('check_acl', $l->t('Verify ACL access when listing files')))
+                    ->setType(DefinitionParameter::VALUE_BOOLEAN)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL)
+                    ->setTooltip($l->t("Check the ACL's of each file or folder inside a directory to filter out items where the account has no read permissions, comes with a performance penalty")),
+                (new DefinitionParameter('timeout', $l->t('Timeout')))
+                    ->setType(DefinitionParameter::VALUE_TEXT)
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+            ])
+            ->addAuthScheme(AuthMechanism::SCHEME_PASSWORD)
+            ->addAuthScheme(AuthMechanism::SCHEME_SMB)
+            ->setLegacyAuthMechanism($legacyAuth);
+    }
 
-	/**
-	 * @return void
-	 */
-	public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
-		$auth = $storage->getAuthMechanism();
-		if ($auth->getScheme() === AuthMechanism::SCHEME_PASSWORD) {
-			if (!is_string($storage->getBackendOption('user')) || !is_string($storage->getBackendOption('password'))) {
-				throw new \InvalidArgumentException('user or password is not set');
-			}
+    /**
+     * @return void
+     */
+    public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
+        $auth = $storage->getAuthMechanism();
+        if ($auth->getScheme() === AuthMechanism::SCHEME_PASSWORD) {
+            if (!is_string($storage->getBackendOption('user')) || !is_string($storage->getBackendOption('password'))) {
+                throw new \InvalidArgumentException('user or password is not set');
+            }
 
-			$smbAuth = new BasicAuth(
-				$storage->getBackendOption('user'),
-				$storage->getBackendOption('domain'),
-				$storage->getBackendOption('password')
-			);
-		} else {
-			switch ($auth->getIdentifier()) {
-				case 'smb::kerberos':
-					$smbAuth = new KerberosAuth();
-					break;
-				case 'smb::kerberosapache':
-					if (!$auth instanceof KerberosApacheAuthMechanism) {
-						throw new \InvalidArgumentException('invalid authentication backend');
-					}
-					$credentialsStore = $auth->getCredentialsStore();
-					$kerbAuth = new KerberosApacheAuth();
-					// check if a kerberos ticket is available, else fallback to session credentials
-					if ($kerbAuth->checkTicket()) {
-						$smbAuth = $kerbAuth;
-					} else {
-						try {
-							$credentials = $credentialsStore->getLoginCredentials();
-							$user = $credentials->getLoginName();
-							$pass = $credentials->getPassword();
-							preg_match('/(.*)@(.*)/', $user, $matches);
-							$realm = $storage->getBackendOption('default_realm');
-							if (empty($realm)) {
-								$realm = 'WORKGROUP';
-							}
-							if (count($matches) === 0) {
-								$username = $user;
-								$workgroup = $realm;
-							} else {
-								$username = $matches[1];
-								$workgroup = $matches[2];
-							}
-							$smbAuth = new BasicAuth(
-								$username,
-								$workgroup,
-								$pass
-							);
-						} catch (\Exception $e) {
-							throw new InsufficientDataForMeaningfulAnswerException('No session credentials saved');
-						}
-					}
+            $smbAuth = new BasicAuth(
+                $storage->getBackendOption('user'),
+                $storage->getBackendOption('domain'),
+                $storage->getBackendOption('password')
+            );
+        } else {
+            switch ($auth->getIdentifier()) {
+                case 'smb::kerberos':
+                    $smbAuth = new KerberosAuth();
+                    break;
+                case 'smb::kerberosapache':
+                    if (!$auth instanceof KerberosApacheAuthMechanism) {
+                        throw new \InvalidArgumentException('invalid authentication backend');
+                    }
+                    $credentialsStore = $auth->getCredentialsStore();
+                    $kerbAuth = new KerberosApacheAuth();
+                    // check if a kerberos ticket is available, else fallback to session credentials
+                    if ($kerbAuth->checkTicket()) {
+                        $smbAuth = $kerbAuth;
+                    } else {
+                        try {
+                            $credentials = $credentialsStore->getLoginCredentials();
+                            $user = $credentials->getLoginName();
+                            $pass = $credentials->getPassword();
+                            preg_match('/(.*)@(.*)/', $user, $matches);
+                            $realm = $storage->getBackendOption('default_realm');
+                            if (empty($realm)) {
+                                $realm = 'WORKGROUP';
+                            }
+                            if (count($matches) === 0) {
+                                $username = $user;
+                                $workgroup = $realm;
+                            } else {
+                                $username = $matches[1];
+                                $workgroup = $matches[2];
+                            }
+                            $smbAuth = new BasicAuth(
+                                $username,
+                                $workgroup,
+                                $pass
+                            );
+                        } catch (\Exception $e) {
+                            throw new InsufficientDataForMeaningfulAnswerException('No session credentials saved');
+                        }
+                    }
 
-					break;
-				default:
-					throw new \InvalidArgumentException('unknown authentication backend');
-			}
-		}
+                    break;
+                default:
+                    throw new \InvalidArgumentException('unknown authentication backend');
+            }
+        }
 
-		$storage->setBackendOption('auth', $smbAuth);
-	}
+        $storage->setBackendOption('auth', $smbAuth);
+    }
 
-	public function checkDependencies() {
-		$system = \OCP\Server::get(SystemBridge::class);
-		if (NativeServer::available($system)) {
-			return [];
-		} elseif (Server::available($system)) {
-			$missing = new MissingDependency('php-smbclient');
-			$missing->setOptional(true);
-			$missing->setMessage('The php-smbclient library provides improved compatibility and performance for SMB storages.');
-			return [$missing];
-		} else {
-			$missing = new MissingDependency('php-smbclient');
-			$missing->setMessage('Either the php-smbclient library (preferred) or the smbclient binary is required for SMB storages.');
-			return [$missing, new MissingDependency('smbclient')];
-		}
-	}
+    public function checkDependencies() {
+        $system = \OCP\Server::get(SystemBridge::class);
+        if (NativeServer::available($system)) {
+            return [];
+        } elseif (Server::available($system)) {
+            $missing = new MissingDependency('php-smbclient');
+            $missing->setOptional(true);
+            $missing->setMessage('The php-smbclient library provides improved compatibility and performance for SMB storages.');
+            return [$missing];
+        } else {
+            $missing = new MissingDependency('php-smbclient');
+            $missing->setMessage('Either the php-smbclient library (preferred) or the smbclient binary is required for SMB storages.');
+            return [$missing, new MissingDependency('smbclient')];
+        }
+    }
 }

apps/files_external/lib/Command/Dependencies.php

Indentation +42 added lines, -42 removed lines

@@ -11,46 +11,46 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Dependencies extends Base {
-	public function __construct(
-		private readonly BackendService $backendService,
-	) {
-		parent::__construct();
-	}
-
-	protected function configure(): void {
-		$this
-			->setName('files_external:dependencies')
-			->setDescription('Show information about the backend dependencies');
-		parent::configure();
-	}
-
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		$storageBackends = $this->backendService->getBackends();
-
-		$anyMissing = false;
-
-		foreach ($storageBackends as $backend) {
-			if ($backend->getDeprecateTo() !== null) {
-				continue;
-			}
-			$missingDependencies = $backend->checkDependencies();
-			if ($missingDependencies) {
-				$anyMissing = true;
-				$output->writeln($backend->getText() . ':');
-				foreach ($missingDependencies as $missingDependency) {
-					if ($missingDependency->getMessage()) {
-						$output->writeln(" - <comment>{$missingDependency->getDependency()}</comment>: {$missingDependency->getMessage()}");
-					} else {
-						$output->writeln(" - <comment>{$missingDependency->getDependency()}</comment>");
-					}
-				}
-			}
-		}
-
-		if (!$anyMissing) {
-			$output->writeln('<info>All dependencies are met</info>');
-		}
-
-		return self::SUCCESS;
-	}
+    public function __construct(
+        private readonly BackendService $backendService,
+    ) {
+        parent::__construct();
+    }
+
+    protected function configure(): void {
+        $this
+            ->setName('files_external:dependencies')
+            ->setDescription('Show information about the backend dependencies');
+        parent::configure();
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $storageBackends = $this->backendService->getBackends();
+
+        $anyMissing = false;
+
+        foreach ($storageBackends as $backend) {
+            if ($backend->getDeprecateTo() !== null) {
+                continue;
+            }
+            $missingDependencies = $backend->checkDependencies();
+            if ($missingDependencies) {
+                $anyMissing = true;
+                $output->writeln($backend->getText() . ':');
+                foreach ($missingDependencies as $missingDependency) {
+                    if ($missingDependency->getMessage()) {
+                        $output->writeln(" - <comment>{$missingDependency->getDependency()}</comment>: {$missingDependency->getMessage()}");
+                    } else {
+                        $output->writeln(" - <comment>{$missingDependency->getDependency()}</comment>");
+                    }
+                }
+            }
+        }
+
+        if (!$anyMissing) {
+            $output->writeln('<info>All dependencies are met</info>');
+        }
+
+        return self::SUCCESS;
+    }
 }

apps/files_external/lib/Service/BackendService.php

Indentation +315 added lines, -315 removed lines

@@ -23,319 +23,319 @@
  */
 class BackendService {
 
-	/** Visibility constants for VisibilityTrait */
-	public const VISIBILITY_NONE = 0;
-	public const VISIBILITY_PERSONAL = 1;
-	public const VISIBILITY_ADMIN = 2;
-	//const VISIBILITY_ALIENS = 4;
-
-	public const VISIBILITY_DEFAULT = 3; // PERSONAL | ADMIN
-
-	/** Priority constants for PriorityTrait */
-	public const PRIORITY_DEFAULT = 100;
-
-	/** @var bool */
-	private $userMountingAllowed = true;
-
-	/** @var string[] */
-	private $userMountingBackends = [];
-
-	/** @var Backend[] */
-	private $backends = [];
-
-	/** @var IBackendProvider[] */
-	private $backendProviders = [];
-
-	/** @var AuthMechanism[] */
-	private $authMechanisms = [];
-
-	/** @var IAuthMechanismProvider[] */
-	private $authMechanismProviders = [];
-
-	/** @var callable[] */
-	private $configHandlerLoaders = [];
-
-	private $configHandlers = [];
-
-	public function __construct(
-		protected IAppConfig $appConfig,
-	) {
-		// Load config values
-		$this->userMountingAllowed = $appConfig->getValueBool('files_external', ConfigLexicon::ALLOW_USER_MOUNTING);
-		$this->userMountingBackends = explode(',', $appConfig->getValueString('files_external', ConfigLexicon::USER_MOUNTING_BACKENDS));
-
-		// if no backend is in the list an empty string is in the array and user mounting is disabled
-		if ($this->userMountingBackends === ['']) {
-			$this->userMountingAllowed = false;
-		}
-	}
-
-	/**
-	 * Register a backend provider
-	 *
-	 * @since 9.1.0
-	 * @param IBackendProvider $provider
-	 */
-	public function registerBackendProvider(IBackendProvider $provider) {
-		$this->backendProviders[] = $provider;
-	}
-
-	private function callForRegistrations() {
-		static $eventSent = false;
-		if (!$eventSent) {
-			Server::get(IEventDispatcher::class)->dispatch(
-				'OCA\\Files_External::loadAdditionalBackends',
-				new GenericEvent()
-			);
-			$eventSent = true;
-		}
-	}
-
-	private function loadBackendProviders() {
-		$this->callForRegistrations();
-		foreach ($this->backendProviders as $provider) {
-			$this->registerBackends($provider->getBackends());
-		}
-		$this->backendProviders = [];
-	}
-
-	/**
-	 * Register an auth mechanism provider
-	 *
-	 * @since 9.1.0
-	 * @param IAuthMechanismProvider $provider
-	 */
-	public function registerAuthMechanismProvider(IAuthMechanismProvider $provider) {
-		$this->authMechanismProviders[] = $provider;
-	}
-
-	private function loadAuthMechanismProviders() {
-		$this->callForRegistrations();
-		foreach ($this->authMechanismProviders as $provider) {
-			$this->registerAuthMechanisms($provider->getAuthMechanisms());
-		}
-		$this->authMechanismProviders = [];
-	}
-
-	/**
-	 * Register a backend
-	 *
-	 * @deprecated 9.1.0 use registerBackendProvider()
-	 * @param Backend $backend
-	 */
-	public function registerBackend(Backend $backend) {
-		if (!$this->isAllowedUserBackend($backend)) {
-			$backend->removeVisibility(BackendService::VISIBILITY_PERSONAL);
-		}
-		foreach ($backend->getIdentifierAliases() as $alias) {
-			$this->backends[$alias] = $backend;
-		}
-	}
-
-	/**
-	 * @deprecated 9.1.0 use registerBackendProvider()
-	 * @param Backend[] $backends
-	 */
-	public function registerBackends(array $backends) {
-		foreach ($backends as $backend) {
-			$this->registerBackend($backend);
-		}
-	}
-	/**
-	 * Register an authentication mechanism
-	 *
-	 * @deprecated 9.1.0 use registerAuthMechanismProvider()
-	 * @param AuthMechanism $authMech
-	 */
-	public function registerAuthMechanism(AuthMechanism $authMech) {
-		if (!$this->isAllowedAuthMechanism($authMech)) {
-			$authMech->removeVisibility(BackendService::VISIBILITY_PERSONAL);
-		}
-		foreach ($authMech->getIdentifierAliases() as $alias) {
-			$this->authMechanisms[$alias] = $authMech;
-		}
-	}
-
-	/**
-	 * @deprecated 9.1.0 use registerAuthMechanismProvider()
-	 * @param AuthMechanism[] $mechanisms
-	 */
-	public function registerAuthMechanisms(array $mechanisms) {
-		foreach ($mechanisms as $mechanism) {
-			$this->registerAuthMechanism($mechanism);
-		}
-	}
-
-	/**
-	 * Get all backends
-	 *
-	 * @return Backend[]
-	 */
-	public function getBackends() {
-		$this->loadBackendProviders();
-		// only return real identifiers, no aliases
-		$backends = [];
-		foreach ($this->backends as $backend) {
-			$backends[$backend->getIdentifier()] = $backend;
-		}
-		return $backends;
-	}
-
-	/**
-	 * Get all available backends
-	 *
-	 * @return Backend[]
-	 */
-	public function getAvailableBackends() {
-		return array_filter($this->getBackends(), function ($backend) {
-			$missing = array_filter($backend->checkDependencies(), fn (MissingDependency $dependency) => !$dependency->isOptional());
-			return count($missing) === 0;
-		});
-	}
-
-	/**
-	 * @param string $identifier
-	 * @return Backend|null
-	 */
-	public function getBackend($identifier) {
-		$this->loadBackendProviders();
-		if (isset($this->backends[$identifier])) {
-			return $this->backends[$identifier];
-		}
-		return null;
-	}
-
-	/**
-	 * Get all authentication mechanisms
-	 *
-	 * @return AuthMechanism[]
-	 */
-	public function getAuthMechanisms() {
-		$this->loadAuthMechanismProviders();
-		// only return real identifiers, no aliases
-		$mechanisms = [];
-		foreach ($this->authMechanisms as $mechanism) {
-			$mechanisms[$mechanism->getIdentifier()] = $mechanism;
-		}
-		return $mechanisms;
-	}
-
-	/**
-	 * Get all authentication mechanisms for schemes
-	 *
-	 * @param string[] $schemes
-	 * @return AuthMechanism[]
-	 */
-	public function getAuthMechanismsByScheme(array $schemes) {
-		return array_filter($this->getAuthMechanisms(), function ($authMech) use ($schemes) {
-			return in_array($authMech->getScheme(), $schemes, true);
-		});
-	}
-
-	/**
-	 * @param string $identifier
-	 * @return AuthMechanism|null
-	 */
-	public function getAuthMechanism($identifier) {
-		$this->loadAuthMechanismProviders();
-		if (isset($this->authMechanisms[$identifier])) {
-			return $this->authMechanisms[$identifier];
-		}
-		return null;
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function isUserMountingAllowed() {
-		return $this->userMountingAllowed;
-	}
-
-	/**
-	 * Check a backend if a user is allowed to mount it
-	 *
-	 * @param Backend $backend
-	 * @return bool
-	 */
-	protected function isAllowedUserBackend(Backend $backend) {
-		if ($this->userMountingAllowed &&
-			array_intersect($backend->getIdentifierAliases(), $this->userMountingBackends)
-		) {
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Check an authentication mechanism if a user is allowed to use it
-	 *
-	 * @param AuthMechanism $authMechanism
-	 * @return bool
-	 */
-	protected function isAllowedAuthMechanism(AuthMechanism $authMechanism) {
-		return true; // not implemented
-	}
-
-	/**
-	 * registers a configuration handler
-	 *
-	 * The function of the provided $placeholder is mostly to act a sorting
-	 * criteria, so longer placeholders are replaced first. This avoids
-	 * "$user" overwriting parts of "$userMail" and "$userLang", for example.
-	 * The provided value should not contain the $ prefix, only a-z0-9 are
-	 * allowed. Upper case letters are lower cased, the replacement is case-
-	 * insensitive.
-	 *
-	 * The configHandlerLoader should just instantiate the handler on demand.
-	 * For now all handlers are instantiated when a mount is loaded, independent
-	 * of whether the placeholder is present or not. This may change in future.
-	 *
-	 * @since 16.0.0
-	 */
-	public function registerConfigHandler(string $placeholder, callable $configHandlerLoader) {
-		$placeholder = trim(strtolower($placeholder));
-		if (!(bool)\preg_match('/^[a-z0-9]*$/', $placeholder)) {
-			throw new \RuntimeException(sprintf(
-				'Invalid placeholder %s, only [a-z0-9] are allowed', $placeholder
-			));
-		}
-		if ($placeholder === '') {
-			throw new \RuntimeException('Invalid empty placeholder');
-		}
-		if (isset($this->configHandlerLoaders[$placeholder]) || isset($this->configHandlers[$placeholder])) {
-			throw new \RuntimeException(sprintf('A handler is already registered for %s', $placeholder));
-		}
-		$this->configHandlerLoaders[$placeholder] = $configHandlerLoader;
-	}
-
-	protected function loadConfigHandlers():void {
-		$this->callForRegistrations();
-		$newLoaded = false;
-		foreach ($this->configHandlerLoaders as $placeholder => $loader) {
-			$handler = $loader();
-			if (!$handler instanceof IConfigHandler) {
-				throw new \RuntimeException(sprintf(
-					'Handler for %s is not an instance of IConfigHandler', $placeholder
-				));
-			}
-			$this->configHandlers[$placeholder] = $handler;
-			$newLoaded = true;
-		}
-		$this->configHandlerLoaders = [];
-		if ($newLoaded) {
-			// ensure those with longest placeholders come first,
-			// to avoid substring matches
-			uksort($this->configHandlers, function ($phA, $phB) {
-				return strlen($phB) <=> strlen($phA);
-			});
-		}
-	}
-
-	/**
-	 * @since 16.0.0
-	 */
-	public function getConfigHandlers() {
-		$this->loadConfigHandlers();
-		return $this->configHandlers;
-	}
+    /** Visibility constants for VisibilityTrait */
+    public const VISIBILITY_NONE = 0;
+    public const VISIBILITY_PERSONAL = 1;
+    public const VISIBILITY_ADMIN = 2;
+    //const VISIBILITY_ALIENS = 4;
+
+    public const VISIBILITY_DEFAULT = 3; // PERSONAL | ADMIN
+
+    /** Priority constants for PriorityTrait */
+    public const PRIORITY_DEFAULT = 100;
+
+    /** @var bool */
+    private $userMountingAllowed = true;
+
+    /** @var string[] */
+    private $userMountingBackends = [];
+
+    /** @var Backend[] */
+    private $backends = [];
+
+    /** @var IBackendProvider[] */
+    private $backendProviders = [];
+
+    /** @var AuthMechanism[] */
+    private $authMechanisms = [];
+
+    /** @var IAuthMechanismProvider[] */
+    private $authMechanismProviders = [];
+
+    /** @var callable[] */
+    private $configHandlerLoaders = [];
+
+    private $configHandlers = [];
+
+    public function __construct(
+        protected IAppConfig $appConfig,
+    ) {
+        // Load config values
+        $this->userMountingAllowed = $appConfig->getValueBool('files_external', ConfigLexicon::ALLOW_USER_MOUNTING);
+        $this->userMountingBackends = explode(',', $appConfig->getValueString('files_external', ConfigLexicon::USER_MOUNTING_BACKENDS));
+
+        // if no backend is in the list an empty string is in the array and user mounting is disabled
+        if ($this->userMountingBackends === ['']) {
+            $this->userMountingAllowed = false;
+        }
+    }
+
+    /**
+     * Register a backend provider
+     *
+     * @since 9.1.0
+     * @param IBackendProvider $provider
+     */
+    public function registerBackendProvider(IBackendProvider $provider) {
+        $this->backendProviders[] = $provider;
+    }
+
+    private function callForRegistrations() {
+        static $eventSent = false;
+        if (!$eventSent) {
+            Server::get(IEventDispatcher::class)->dispatch(
+                'OCA\\Files_External::loadAdditionalBackends',
+                new GenericEvent()
+            );
+            $eventSent = true;
+        }
+    }
+
+    private function loadBackendProviders() {
+        $this->callForRegistrations();
+        foreach ($this->backendProviders as $provider) {
+            $this->registerBackends($provider->getBackends());
+        }
+        $this->backendProviders = [];
+    }
+
+    /**
+     * Register an auth mechanism provider
+     *
+     * @since 9.1.0
+     * @param IAuthMechanismProvider $provider
+     */
+    public function registerAuthMechanismProvider(IAuthMechanismProvider $provider) {
+        $this->authMechanismProviders[] = $provider;
+    }
+
+    private function loadAuthMechanismProviders() {
+        $this->callForRegistrations();
+        foreach ($this->authMechanismProviders as $provider) {
+            $this->registerAuthMechanisms($provider->getAuthMechanisms());
+        }
+        $this->authMechanismProviders = [];
+    }
+
+    /**
+     * Register a backend
+     *
+     * @deprecated 9.1.0 use registerBackendProvider()
+     * @param Backend $backend
+     */
+    public function registerBackend(Backend $backend) {
+        if (!$this->isAllowedUserBackend($backend)) {
+            $backend->removeVisibility(BackendService::VISIBILITY_PERSONAL);
+        }
+        foreach ($backend->getIdentifierAliases() as $alias) {
+            $this->backends[$alias] = $backend;
+        }
+    }
+
+    /**
+     * @deprecated 9.1.0 use registerBackendProvider()
+     * @param Backend[] $backends
+     */
+    public function registerBackends(array $backends) {
+        foreach ($backends as $backend) {
+            $this->registerBackend($backend);
+        }
+    }
+    /**
+     * Register an authentication mechanism
+     *
+     * @deprecated 9.1.0 use registerAuthMechanismProvider()
+     * @param AuthMechanism $authMech
+     */
+    public function registerAuthMechanism(AuthMechanism $authMech) {
+        if (!$this->isAllowedAuthMechanism($authMech)) {
+            $authMech->removeVisibility(BackendService::VISIBILITY_PERSONAL);
+        }
+        foreach ($authMech->getIdentifierAliases() as $alias) {
+            $this->authMechanisms[$alias] = $authMech;
+        }
+    }
+
+    /**
+     * @deprecated 9.1.0 use registerAuthMechanismProvider()
+     * @param AuthMechanism[] $mechanisms
+     */
+    public function registerAuthMechanisms(array $mechanisms) {
+        foreach ($mechanisms as $mechanism) {
+            $this->registerAuthMechanism($mechanism);
+        }
+    }
+
+    /**
+     * Get all backends
+     *
+     * @return Backend[]
+     */
+    public function getBackends() {
+        $this->loadBackendProviders();
+        // only return real identifiers, no aliases
+        $backends = [];
+        foreach ($this->backends as $backend) {
+            $backends[$backend->getIdentifier()] = $backend;
+        }
+        return $backends;
+    }
+
+    /**
+     * Get all available backends
+     *
+     * @return Backend[]
+     */
+    public function getAvailableBackends() {
+        return array_filter($this->getBackends(), function ($backend) {
+            $missing = array_filter($backend->checkDependencies(), fn (MissingDependency $dependency) => !$dependency->isOptional());
+            return count($missing) === 0;
+        });
+    }
+
+    /**
+     * @param string $identifier
+     * @return Backend|null
+     */
+    public function getBackend($identifier) {
+        $this->loadBackendProviders();
+        if (isset($this->backends[$identifier])) {
+            return $this->backends[$identifier];
+        }
+        return null;
+    }
+
+    /**
+     * Get all authentication mechanisms
+     *
+     * @return AuthMechanism[]
+     */
+    public function getAuthMechanisms() {
+        $this->loadAuthMechanismProviders();
+        // only return real identifiers, no aliases
+        $mechanisms = [];
+        foreach ($this->authMechanisms as $mechanism) {
+            $mechanisms[$mechanism->getIdentifier()] = $mechanism;
+        }
+        return $mechanisms;
+    }
+
+    /**
+     * Get all authentication mechanisms for schemes
+     *
+     * @param string[] $schemes
+     * @return AuthMechanism[]
+     */
+    public function getAuthMechanismsByScheme(array $schemes) {
+        return array_filter($this->getAuthMechanisms(), function ($authMech) use ($schemes) {
+            return in_array($authMech->getScheme(), $schemes, true);
+        });
+    }
+
+    /**
+     * @param string $identifier
+     * @return AuthMechanism|null
+     */
+    public function getAuthMechanism($identifier) {
+        $this->loadAuthMechanismProviders();
+        if (isset($this->authMechanisms[$identifier])) {
+            return $this->authMechanisms[$identifier];
+        }
+        return null;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isUserMountingAllowed() {
+        return $this->userMountingAllowed;
+    }
+
+    /**
+     * Check a backend if a user is allowed to mount it
+     *
+     * @param Backend $backend
+     * @return bool
+     */
+    protected function isAllowedUserBackend(Backend $backend) {
+        if ($this->userMountingAllowed &&
+            array_intersect($backend->getIdentifierAliases(), $this->userMountingBackends)
+        ) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Check an authentication mechanism if a user is allowed to use it
+     *
+     * @param AuthMechanism $authMechanism
+     * @return bool
+     */
+    protected function isAllowedAuthMechanism(AuthMechanism $authMechanism) {
+        return true; // not implemented
+    }
+
+    /**
+     * registers a configuration handler
+     *
+     * The function of the provided $placeholder is mostly to act a sorting
+     * criteria, so longer placeholders are replaced first. This avoids
+     * "$user" overwriting parts of "$userMail" and "$userLang", for example.
+     * The provided value should not contain the $ prefix, only a-z0-9 are
+     * allowed. Upper case letters are lower cased, the replacement is case-
+     * insensitive.
+     *
+     * The configHandlerLoader should just instantiate the handler on demand.
+     * For now all handlers are instantiated when a mount is loaded, independent
+     * of whether the placeholder is present or not. This may change in future.
+     *
+     * @since 16.0.0
+     */
+    public function registerConfigHandler(string $placeholder, callable $configHandlerLoader) {
+        $placeholder = trim(strtolower($placeholder));
+        if (!(bool)\preg_match('/^[a-z0-9]*$/', $placeholder)) {
+            throw new \RuntimeException(sprintf(
+                'Invalid placeholder %s, only [a-z0-9] are allowed', $placeholder
+            ));
+        }
+        if ($placeholder === '') {
+            throw new \RuntimeException('Invalid empty placeholder');
+        }
+        if (isset($this->configHandlerLoaders[$placeholder]) || isset($this->configHandlers[$placeholder])) {
+            throw new \RuntimeException(sprintf('A handler is already registered for %s', $placeholder));
+        }
+        $this->configHandlerLoaders[$placeholder] = $configHandlerLoader;
+    }
+
+    protected function loadConfigHandlers():void {
+        $this->callForRegistrations();
+        $newLoaded = false;
+        foreach ($this->configHandlerLoaders as $placeholder => $loader) {
+            $handler = $loader();
+            if (!$handler instanceof IConfigHandler) {
+                throw new \RuntimeException(sprintf(
+                    'Handler for %s is not an instance of IConfigHandler', $placeholder
+                ));
+            }
+            $this->configHandlers[$placeholder] = $handler;
+            $newLoaded = true;
+        }
+        $this->configHandlerLoaders = [];
+        if ($newLoaded) {
+            // ensure those with longest placeholders come first,
+            // to avoid substring matches
+            uksort($this->configHandlers, function ($phA, $phB) {
+                return strlen($phB) <=> strlen($phA);
+            });
+        }
+    }
+
+    /**
+     * @since 16.0.0
+     */
+    public function getConfigHandlers() {
+        $this->loadConfigHandlers();
+        return $this->configHandlers;
+    }
 }