nextcloud / server

apps/files_external/appinfo/app.php

Indentation +8 added lines, -8 removed lines

@@ -37,14 +37,14 @@
 $appContainer = \OCA\Files_External\MountConfig::$app->getContainer();
 
 \OCA\Files\App::getNavigationManager()->add(function () {
-	$l = \OC::$server->getL10N('files_external');
-	return [
-		'id' => 'extstoragemounts',
-		'appname' => 'files_external',
-		'script' => 'list.php',
-		'order' => 30,
-		'name' => $l->t('External storage'),
-	];
+    $l = \OC::$server->getL10N('files_external');
+    return [
+        'id' => 'extstoragemounts',
+        'appname' => 'files_external',
+        'script' => 'list.php',
+        'order' => 30,
+        'name' => $l->t('External storage'),
+    ];
 });
 
 $mountProvider = $appContainer->query(ConfigAdapter::class);

apps/files_external/templates/settings.php

Spacing +5 added lines, -5 removed lines

@@ -100,9 +100,9 @@ 
 	<h2><?php p($l->t('No external storage configured or you don\'t have the permission to configure them')); ?></h2>
 </div>
 
-<form data-can-create="<?php echo $canCreateMounts?'true':'false' ?>" id="files_external" class="section" data-encryption-enabled="<?php echo $_['encryptionEnabled']?'true': 'false'; ?>">
+<form data-can-create="<?php echo $canCreateMounts ? 'true' : 'false' ?>" id="files_external" class="section" data-encryption-enabled="<?php echo $_['encryptionEnabled'] ? 'true' : 'false'; ?>">
 	<h2 class="inlineblock" data-anchor-name="external-storage"><?php p($l->t('External storage')); ?></h2>
-	<a target="_blank" rel="noreferrer" class="icon-info" title="<?php p($l->t('Open documentation'));?>" href="<?php p(link_to_docs('admin-external-storage')); ?>"></a>
+	<a target="_blank" rel="noreferrer" class="icon-info" title="<?php p($l->t('Open documentation')); ?>" href="<?php p(link_to_docs('admin-external-storage')); ?>"></a>
 	<p class="settings-hint"><?php p($l->t('External storage enables you to mount external storage services and devices as secondary Nextcloud storage devices. You may also allow users to mount their own external storage services.')); ?></p>
 	<?php if (isset($_['dependencies']) and ($_['dependencies'] !== '') and $canCreateMounts) {
 	print_unescaped(''.$_['dependencies'].'');
@@ -142,10 +142,10 @@ 
 							<?php p($l->t('Add storage')); ?>
 						</option>
 						<?php
-							$sortedBackends = array_filter($_['backends'], function ($backend) use ($_) {
+							$sortedBackends = array_filter($_['backends'], function($backend) use ($_) {
 								return $backend->isVisibleFor($_['visibilityType']);
 							});
-							uasort($sortedBackends, function ($a, $b) {
+							uasort($sortedBackends, function($a, $b) {
 								return strcasecmp($a->getText(), $b->getText());
 							});
 						?>
@@ -184,7 +184,7 @@ 
 
 		<p id="userMountingBackends"<?php if (!$_['allowUserMounting']): ?> class="hidden"<?php endif; ?>>
 			<?php
-				$userBackends = array_filter($_['backends'], function ($backend) {
+				$userBackends = array_filter($_['backends'], function($backend) {
 					return $backend->isAllowedVisibleFor(BackendService::VISIBILITY_PERSONAL);
 				});
 			?>

apps/files_external/lib/Settings/Section.php

Indentation +46 added lines, -46 removed lines

@@ -29,55 +29,55 @@
 use OCP\Settings\IIconSection;
 
 class Section implements IIconSection {
-	/** @var IL10N */
-	private $l;
-	/** @var IURLGenerator */
-	private $url;
+    /** @var IL10N */
+    private $l;
+    /** @var IURLGenerator */
+    private $url;
 
-	/**
-	 * @param IURLGenerator $url
-	 * @param IL10N $l
-	 */
-	public function __construct(IURLGenerator $url, IL10N $l) {
-		$this->url = $url;
-		$this->l = $l;
-	}
+    /**
+     * @param IURLGenerator $url
+     * @param IL10N $l
+     */
+    public function __construct(IURLGenerator $url, IL10N $l) {
+        $this->url = $url;
+        $this->l = $l;
+    }
 
-	/**
-	 * returns the ID of the section. It is supposed to be a lower case string,
-	 * e.g. 'ldap'
-	 *
-	 * @returns string
-	 */
-	public function getID() {
-		return 'externalstorages';
-	}
+    /**
+     * returns the ID of the section. It is supposed to be a lower case string,
+     * e.g. 'ldap'
+     *
+     * @returns string
+     */
+    public function getID() {
+        return 'externalstorages';
+    }
 
-	/**
-	 * returns the translated name as it should be displayed, e.g. 'LDAP / AD
-	 * integration'. Use the L10N service to translate it.
-	 *
-	 * @return string
-	 */
-	public function getName() {
-		return $this->l->t('External storage');
-	}
+    /**
+     * returns the translated name as it should be displayed, e.g. 'LDAP / AD
+     * integration'. Use the L10N service to translate it.
+     *
+     * @return string
+     */
+    public function getName() {
+        return $this->l->t('External storage');
+    }
 
-	/**
-	 * @return int whether the form should be rather on the top or bottom of
-	 * the settings navigation. The sections are arranged in ascending order of
-	 * the priority values. It is required to return a value between 0 and 99.
-	 *
-	 * E.g.: 70
-	 */
-	public function getPriority() {
-		return 10;
-	}
+    /**
+     * @return int whether the form should be rather on the top or bottom of
+     * the settings navigation. The sections are arranged in ascending order of
+     * the priority values. It is required to return a value between 0 and 99.
+     *
+     * E.g.: 70
+     */
+    public function getPriority() {
+        return 10;
+    }
 
-	/**
-	 * {@inheritdoc}
-	 */
-	public function getIcon() {
-		return $this->url->imagePath('files_external', 'app-dark.svg');
-	}
+    /**
+     * {@inheritdoc}
+     */
+    public function getIcon() {
+        return $this->url->imagePath('files_external', 'app-dark.svg');
+    }
 }

apps/files_external/lib/Service/LegacyStoragesService.php

Indentation +171 added lines, -171 removed lines

@@ -33,179 +33,179 @@
  * Read mount config from legacy mount.json
  */
 abstract class LegacyStoragesService {
-	/** @var BackendService */
-	protected $backendService;
+    /** @var BackendService */
+    protected $backendService;
 
-	/**
-	 * Read legacy config data
-	 *
-	 * @return array list of mount configs
-	 */
-	abstract protected function readLegacyConfig();
+    /**
+     * Read legacy config data
+     *
+     * @return array list of mount configs
+     */
+    abstract protected function readLegacyConfig();
 
-	/**
-	 * Copy legacy storage options into the given storage config object.
-	 *
-	 * @param StorageConfig $storageConfig storage config to populate
-	 * @param string $mountType mount type
-	 * @param string $applicable applicable user or group
-	 * @param array $storageOptions legacy storage options
-	 *
-	 * @return StorageConfig populated storage config
-	 */
-	protected function populateStorageConfigWithLegacyOptions(
-		&$storageConfig,
-		$mountType,
-		$applicable,
-		$storageOptions
-	) {
-		$backend = $this->backendService->getBackend($storageOptions['backend']);
-		if (!$backend) {
-			throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']);
-		}
-		$storageConfig->setBackend($backend);
-		if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') {
-			$authMechanism = $this->backendService->getAuthMechanism($storageOptions['authMechanism']);
-		} else {
-			$authMechanism = $backend->getLegacyAuthMechanism($storageOptions);
-			$storageOptions['authMechanism'] = 'null'; // to make error handling easier
-		}
-		if (!$authMechanism) {
-			throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']);
-		}
-		$storageConfig->setAuthMechanism($authMechanism);
-		$storageConfig->setBackendOptions($storageOptions['options']);
-		if (isset($storageOptions['mountOptions'])) {
-			$storageConfig->setMountOptions($storageOptions['mountOptions']);
-		}
-		if (!isset($storageOptions['priority'])) {
-			$storageOptions['priority'] = $backend->getPriority();
-		}
-		$storageConfig->setPriority($storageOptions['priority']);
-		if ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_USER) {
-			$applicableUsers = $storageConfig->getApplicableUsers();
-			if ($applicable !== 'all') {
-				$applicableUsers[] = $applicable;
-				$storageConfig->setApplicableUsers($applicableUsers);
-			}
-		} elseif ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP) {
-			$applicableGroups = $storageConfig->getApplicableGroups();
-			$applicableGroups[] = $applicable;
-			$storageConfig->setApplicableGroups($applicableGroups);
-		}
-		return $storageConfig;
-	}
+    /**
+     * Copy legacy storage options into the given storage config object.
+     *
+     * @param StorageConfig $storageConfig storage config to populate
+     * @param string $mountType mount type
+     * @param string $applicable applicable user or group
+     * @param array $storageOptions legacy storage options
+     *
+     * @return StorageConfig populated storage config
+     */
+    protected function populateStorageConfigWithLegacyOptions(
+        &$storageConfig,
+        $mountType,
+        $applicable,
+        $storageOptions
+    ) {
+        $backend = $this->backendService->getBackend($storageOptions['backend']);
+        if (!$backend) {
+            throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']);
+        }
+        $storageConfig->setBackend($backend);
+        if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') {
+            $authMechanism = $this->backendService->getAuthMechanism($storageOptions['authMechanism']);
+        } else {
+            $authMechanism = $backend->getLegacyAuthMechanism($storageOptions);
+            $storageOptions['authMechanism'] = 'null'; // to make error handling easier
+        }
+        if (!$authMechanism) {
+            throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']);
+        }
+        $storageConfig->setAuthMechanism($authMechanism);
+        $storageConfig->setBackendOptions($storageOptions['options']);
+        if (isset($storageOptions['mountOptions'])) {
+            $storageConfig->setMountOptions($storageOptions['mountOptions']);
+        }
+        if (!isset($storageOptions['priority'])) {
+            $storageOptions['priority'] = $backend->getPriority();
+        }
+        $storageConfig->setPriority($storageOptions['priority']);
+        if ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_USER) {
+            $applicableUsers = $storageConfig->getApplicableUsers();
+            if ($applicable !== 'all') {
+                $applicableUsers[] = $applicable;
+                $storageConfig->setApplicableUsers($applicableUsers);
+            }
+        } elseif ($mountType === \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP) {
+            $applicableGroups = $storageConfig->getApplicableGroups();
+            $applicableGroups[] = $applicable;
+            $storageConfig->setApplicableGroups($applicableGroups);
+        }
+        return $storageConfig;
+    }
 
-	/**
-	 * Read the external storage config
-	 *
-	 * @return StorageConfig[] map of storage id to storage config
-	 */
-	public function getAllStorages() {
-		$mountPoints = $this->readLegacyConfig();
-		/**
-		 * Here is the how the horribly messy mount point array looks like
-		 * from the mount.json file:
-		 *
-		 * $storageOptions = $mountPoints[$mountType][$applicable][$mountPath]
-		 *
-		 * - $mountType is either "user" or "group"
-		 * - $applicable is the name of a user or group (or the current user for personal mounts)
-		 * - $mountPath is the mount point path (where the storage must be mounted)
-		 * - $storageOptions is a map of storage options:
-		 *     - "priority": storage priority
-		 *     - "backend": backend identifier
-		 *     - "class": LEGACY backend class name
-		 *     - "options": backend-specific options
-		 *     - "authMechanism": authentication mechanism identifier
-		 *     - "mountOptions": mount-specific options (ex: disable previews, scanner, etc)
-		 */
-		// group by storage id
-		/** @var StorageConfig[] $storages */
-		$storages = [];
-		// for storages without id (legacy), group by config hash for
-		// later processing
-		$storagesWithConfigHash = [];
-		foreach ($mountPoints as $mountType => $applicables) {
-			foreach ($applicables as $applicable => $mountPaths) {
-				foreach ($mountPaths as $rootMountPath => $storageOptions) {
-					$currentStorage = null;
-					/**
-					 * Flag whether the config that was read already has an id.
-					 * If not, it will use a config hash instead and generate
-					 * a proper id later
-					 *
-					 * @var boolean
-					 */
-					$hasId = false;
-					// the root mount point is in the format "/$user/files/the/mount/point"
-					// we remove the "/$user/files" prefix
-					$parts = explode('/', ltrim($rootMountPath, '/'), 3);
-					if (count($parts) < 3) {
-						// something went wrong, skip
-						\OC::$server->getLogger()->error('Could not parse mount point "' . $rootMountPath . '"', ['app' => 'files_external']);
-						continue;
-					}
-					$relativeMountPath = rtrim($parts[2], '/');
-					// note: we cannot do this after the loop because the decrypted config
-					// options might be needed for the config hash
-					$storageOptions['options'] = \OCA\Files_External\MountConfig::decryptPasswords($storageOptions['options']);
-					if (!isset($storageOptions['backend'])) {
-						$storageOptions['backend'] = $storageOptions['class']; // legacy compat
-					}
-					if (!isset($storageOptions['authMechanism'])) {
-						$storageOptions['authMechanism'] = null; // ensure config hash works
-					}
-					if (isset($storageOptions['id'])) {
-						$configId = (int)$storageOptions['id'];
-						if (isset($storages[$configId])) {
-							$currentStorage = $storages[$configId];
-						}
-						$hasId = true;
-					} else {
-						// missing id in legacy config, need to generate
-						// but at this point we don't know the max-id, so use
-						// first group it by config hash
-						$storageOptions['mountpoint'] = $rootMountPath;
-						$configId = \OCA\Files_External\MountConfig::makeConfigHash($storageOptions);
-						if (isset($storagesWithConfigHash[$configId])) {
-							$currentStorage = $storagesWithConfigHash[$configId];
-						}
-					}
-					if (is_null($currentStorage)) {
-						// create new
-						$currentStorage = new StorageConfig($configId);
-						$currentStorage->setMountPoint($relativeMountPath);
-					}
-					try {
-						$this->populateStorageConfigWithLegacyOptions(
-							$currentStorage,
-							$mountType,
-							$applicable,
-							$storageOptions
-						);
-						if ($hasId) {
-							$storages[$configId] = $currentStorage;
-						} else {
-							$storagesWithConfigHash[$configId] = $currentStorage;
-						}
-					} catch (\UnexpectedValueException $e) {
-						// don't die if a storage backend doesn't exist
-						\OC::$server->getLogger()->logException($e, [
-							'message' => 'Could not load storage.',
-							'level' => ILogger::ERROR,
-							'app' => 'files_external',
-						]);
-					}
-				}
-			}
-		}
+    /**
+     * Read the external storage config
+     *
+     * @return StorageConfig[] map of storage id to storage config
+     */
+    public function getAllStorages() {
+        $mountPoints = $this->readLegacyConfig();
+        /**
+         * Here is the how the horribly messy mount point array looks like
+         * from the mount.json file:
+         *
+         * $storageOptions = $mountPoints[$mountType][$applicable][$mountPath]
+         *
+         * - $mountType is either "user" or "group"
+         * - $applicable is the name of a user or group (or the current user for personal mounts)
+         * - $mountPath is the mount point path (where the storage must be mounted)
+         * - $storageOptions is a map of storage options:
+         *     - "priority": storage priority
+         *     - "backend": backend identifier
+         *     - "class": LEGACY backend class name
+         *     - "options": backend-specific options
+         *     - "authMechanism": authentication mechanism identifier
+         *     - "mountOptions": mount-specific options (ex: disable previews, scanner, etc)
+         */
+        // group by storage id
+        /** @var StorageConfig[] $storages */
+        $storages = [];
+        // for storages without id (legacy), group by config hash for
+        // later processing
+        $storagesWithConfigHash = [];
+        foreach ($mountPoints as $mountType => $applicables) {
+            foreach ($applicables as $applicable => $mountPaths) {
+                foreach ($mountPaths as $rootMountPath => $storageOptions) {
+                    $currentStorage = null;
+                    /**
+                     * Flag whether the config that was read already has an id.
+                     * If not, it will use a config hash instead and generate
+                     * a proper id later
+                     *
+                     * @var boolean
+                     */
+                    $hasId = false;
+                    // the root mount point is in the format "/$user/files/the/mount/point"
+                    // we remove the "/$user/files" prefix
+                    $parts = explode('/', ltrim($rootMountPath, '/'), 3);
+                    if (count($parts) < 3) {
+                        // something went wrong, skip
+                        \OC::$server->getLogger()->error('Could not parse mount point "' . $rootMountPath . '"', ['app' => 'files_external']);
+                        continue;
+                    }
+                    $relativeMountPath = rtrim($parts[2], '/');
+                    // note: we cannot do this after the loop because the decrypted config
+                    // options might be needed for the config hash
+                    $storageOptions['options'] = \OCA\Files_External\MountConfig::decryptPasswords($storageOptions['options']);
+                    if (!isset($storageOptions['backend'])) {
+                        $storageOptions['backend'] = $storageOptions['class']; // legacy compat
+                    }
+                    if (!isset($storageOptions['authMechanism'])) {
+                        $storageOptions['authMechanism'] = null; // ensure config hash works
+                    }
+                    if (isset($storageOptions['id'])) {
+                        $configId = (int)$storageOptions['id'];
+                        if (isset($storages[$configId])) {
+                            $currentStorage = $storages[$configId];
+                        }
+                        $hasId = true;
+                    } else {
+                        // missing id in legacy config, need to generate
+                        // but at this point we don't know the max-id, so use
+                        // first group it by config hash
+                        $storageOptions['mountpoint'] = $rootMountPath;
+                        $configId = \OCA\Files_External\MountConfig::makeConfigHash($storageOptions);
+                        if (isset($storagesWithConfigHash[$configId])) {
+                            $currentStorage = $storagesWithConfigHash[$configId];
+                        }
+                    }
+                    if (is_null($currentStorage)) {
+                        // create new
+                        $currentStorage = new StorageConfig($configId);
+                        $currentStorage->setMountPoint($relativeMountPath);
+                    }
+                    try {
+                        $this->populateStorageConfigWithLegacyOptions(
+                            $currentStorage,
+                            $mountType,
+                            $applicable,
+                            $storageOptions
+                        );
+                        if ($hasId) {
+                            $storages[$configId] = $currentStorage;
+                        } else {
+                            $storagesWithConfigHash[$configId] = $currentStorage;
+                        }
+                    } catch (\UnexpectedValueException $e) {
+                        // don't die if a storage backend doesn't exist
+                        \OC::$server->getLogger()->logException($e, [
+                            'message' => 'Could not load storage.',
+                            'level' => ILogger::ERROR,
+                            'app' => 'files_external',
+                        ]);
+                    }
+                }
+            }
+        }
 
-		// convert parameter values
-		foreach ($storages as $storage) {
-			$storage->getBackend()->validateStorageDefinition($storage);
-			$storage->getAuthMechanism()->validateStorageDefinition($storage);
-		}
-		return $storages;
-	}
+        // convert parameter values
+        foreach ($storages as $storage) {
+            $storage->getBackend()->validateStorageDefinition($storage);
+            $storage->getAuthMechanism()->validateStorageDefinition($storage);
+        }
+        return $storages;
+    }
 }

apps/files_external/lib/Service/StoragesService.php

Indentation +454 added lines, -454 removed lines

@@ -49,458 +49,458 @@
  */
 abstract class StoragesService {
 
-	/** @var BackendService */
-	protected $backendService;
-
-	/**
-	 * @var DBConfigService
-	 */
-	protected $dbConfig;
-
-	/**
-	 * @var IUserMountCache
-	 */
-	protected $userMountCache;
-
-	/**
-	 * @param BackendService $backendService
-	 * @param DBConfigService $dbConfigService
-	 * @param IUserMountCache $userMountCache
-	 */
-	public function __construct(BackendService $backendService, DBConfigService $dbConfigService, IUserMountCache $userMountCache) {
-		$this->backendService = $backendService;
-		$this->dbConfig = $dbConfigService;
-		$this->userMountCache = $userMountCache;
-	}
-
-	protected function readDBConfig() {
-		return $this->dbConfig->getAdminMounts();
-	}
-
-	protected function getStorageConfigFromDBMount(array $mount) {
-		$applicableUsers = array_filter($mount['applicable'], function ($applicable) {
-			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_USER;
-		});
-		$applicableUsers = array_map(function ($applicable) {
-			return $applicable['value'];
-		}, $applicableUsers);
-
-		$applicableGroups = array_filter($mount['applicable'], function ($applicable) {
-			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_GROUP;
-		});
-		$applicableGroups = array_map(function ($applicable) {
-			return $applicable['value'];
-		}, $applicableGroups);
-
-		try {
-			$config = $this->createStorage(
-				$mount['mount_point'],
-				$mount['storage_backend'],
-				$mount['auth_backend'],
-				$mount['config'],
-				$mount['options'],
-				array_values($applicableUsers),
-				array_values($applicableGroups),
-				$mount['priority']
-			);
-			$config->setType($mount['type']);
-			$config->setId((int)$mount['mount_id']);
-			return $config;
-		} catch (\UnexpectedValueException $e) {
-			// don't die if a storage backend doesn't exist
-			\OC::$server->getLogger()->logException($e, [
-				'message' => 'Could not load storage.',
-				'level' => ILogger::ERROR,
-				'app' => 'files_external',
-			]);
-			return null;
-		} catch (\InvalidArgumentException $e) {
-			\OC::$server->getLogger()->logException($e, [
-				'message' => 'Could not load storage.',
-				'level' => ILogger::ERROR,
-				'app' => 'files_external',
-			]);
-			return null;
-		}
-	}
-
-	/**
-	 * Read the external storage config
-	 *
-	 * @return array map of storage id to storage config
-	 */
-	protected function readConfig() {
-		$mounts = $this->readDBConfig();
-		$configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
-		$configs = array_filter($configs, function ($config) {
-			return $config instanceof StorageConfig;
-		});
-
-		$keys = array_map(function (StorageConfig $config) {
-			return $config->getId();
-		}, $configs);
-
-		return array_combine($keys, $configs);
-	}
-
-	/**
-	 * Get a storage with status
-	 *
-	 * @param int $id storage id
-	 *
-	 * @return StorageConfig
-	 * @throws NotFoundException if the storage with the given id was not found
-	 */
-	public function getStorage($id) {
-		$mount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($mount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-
-		$config = $this->getStorageConfigFromDBMount($mount);
-		if ($this->isApplicable($config)) {
-			return $config;
-		} else {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-	}
-
-	/**
-	 * Check whether this storage service should provide access to a storage
-	 *
-	 * @param StorageConfig $config
-	 * @return bool
-	 */
-	abstract protected function isApplicable(StorageConfig $config);
-
-	/**
-	 * Gets all storages, valid or not
-	 *
-	 * @return StorageConfig[] array of storage configs
-	 */
-	public function getAllStorages() {
-		return $this->readConfig();
-	}
-
-	/**
-	 * Gets all valid storages
-	 *
-	 * @return StorageConfig[]
-	 */
-	public function getStorages() {
-		return array_filter($this->getAllStorages(), [$this, 'validateStorage']);
-	}
-
-	/**
-	 * Validate storage
-	 * FIXME: De-duplicate with StoragesController::validate()
-	 *
-	 * @param StorageConfig $storage
-	 * @return bool
-	 */
-	protected function validateStorage(StorageConfig $storage) {
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-
-		if (!$backend->isVisibleFor($this->getVisibilityType())) {
-			// not permitted to use backend
-			return false;
-		}
-		if (!$authMechanism->isVisibleFor($this->getVisibilityType())) {
-			// not permitted to use auth mechanism
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Get the visibility type for this controller, used in validation
-	 *
-	 * @return string BackendService::VISIBILITY_* constants
-	 */
-	abstract public function getVisibilityType();
-
-	/**
-	 * @return integer
-	 */
-	protected function getType() {
-		return DBConfigService::MOUNT_TYPE_ADMIN;
-	}
-
-	/**
-	 * Add new storage to the configuration
-	 *
-	 * @param StorageConfig $newStorage storage attributes
-	 *
-	 * @return StorageConfig storage config, with added id
-	 */
-	public function addStorage(StorageConfig $newStorage) {
-		$allStorages = $this->readConfig();
-
-		$configId = $this->dbConfig->addMount(
-			$newStorage->getMountPoint(),
-			$newStorage->getBackend()->getIdentifier(),
-			$newStorage->getAuthMechanism()->getIdentifier(),
-			$newStorage->getPriority(),
-			$this->getType()
-		);
-
-		$newStorage->setId($configId);
-
-		foreach ($newStorage->getApplicableUsers() as $user) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($newStorage->getApplicableGroups() as $group) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-		foreach ($newStorage->getBackendOptions() as $key => $value) {
-			$this->dbConfig->setConfig($configId, $key, $value);
-		}
-		foreach ($newStorage->getMountOptions() as $key => $value) {
-			$this->dbConfig->setOption($configId, $key, $value);
-		}
-
-		if (count($newStorage->getApplicableUsers()) === 0 && count($newStorage->getApplicableGroups()) === 0) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		}
-
-		// add new storage
-		$allStorages[$configId] = $newStorage;
-
-		$this->triggerHooks($newStorage, Filesystem::signal_create_mount);
-
-		$newStorage->setStatus(StorageNotAvailableException::STATUS_SUCCESS);
-		return $newStorage;
-	}
-
-	/**
-	 * Create a storage from its parameters
-	 *
-	 * @param string $mountPoint storage mount point
-	 * @param string $backendIdentifier backend identifier
-	 * @param string $authMechanismIdentifier authentication mechanism identifier
-	 * @param array $backendOptions backend-specific options
-	 * @param array|null $mountOptions mount-specific options
-	 * @param array|null $applicableUsers users for which to mount the storage
-	 * @param array|null $applicableGroups groups for which to mount the storage
-	 * @param int|null $priority priority
-	 *
-	 * @return StorageConfig
-	 */
-	public function createStorage(
-		$mountPoint,
-		$backendIdentifier,
-		$authMechanismIdentifier,
-		$backendOptions,
-		$mountOptions = null,
-		$applicableUsers = null,
-		$applicableGroups = null,
-		$priority = null
-	) {
-		$backend = $this->backendService->getBackend($backendIdentifier);
-		if (!$backend) {
-			$backend = new InvalidBackend($backendIdentifier);
-		}
-		$authMechanism = $this->backendService->getAuthMechanism($authMechanismIdentifier);
-		if (!$authMechanism) {
-			$authMechanism = new InvalidAuth($authMechanismIdentifier);
-		}
-		$newStorage = new StorageConfig();
-		$newStorage->setMountPoint($mountPoint);
-		$newStorage->setBackend($backend);
-		$newStorage->setAuthMechanism($authMechanism);
-		$newStorage->setBackendOptions($backendOptions);
-		if (isset($mountOptions)) {
-			$newStorage->setMountOptions($mountOptions);
-		}
-		if (isset($applicableUsers)) {
-			$newStorage->setApplicableUsers($applicableUsers);
-		}
-		if (isset($applicableGroups)) {
-			$newStorage->setApplicableGroups($applicableGroups);
-		}
-		if (isset($priority)) {
-			$newStorage->setPriority($priority);
-		}
-
-		return $newStorage;
-	}
-
-	/**
-	 * Triggers the given hook signal for all the applicables given
-	 *
-	 * @param string $signal signal
-	 * @param string $mountPoint hook mount pount param
-	 * @param string $mountType hook mount type param
-	 * @param array $applicableArray array of applicable users/groups for which to trigger the hook
-	 */
-	protected function triggerApplicableHooks($signal, $mountPoint, $mountType, $applicableArray) {
-		foreach ($applicableArray as $applicable) {
-			\OCP\Util::emitHook(
-				Filesystem::CLASSNAME,
-				$signal,
-				[
-					Filesystem::signal_param_path => $mountPoint,
-					Filesystem::signal_param_mount_type => $mountType,
-					Filesystem::signal_param_users => $applicable,
-				]
-			);
-		}
-	}
-
-	/**
-	 * Triggers $signal for all applicable users of the given
-	 * storage
-	 *
-	 * @param StorageConfig $storage storage data
-	 * @param string $signal signal to trigger
-	 */
-	abstract protected function triggerHooks(StorageConfig $storage, $signal);
-
-	/**
-	 * Triggers signal_create_mount or signal_delete_mount to
-	 * accommodate for additions/deletions in applicableUsers
-	 * and applicableGroups fields.
-	 *
-	 * @param StorageConfig $oldStorage old storage data
-	 * @param StorageConfig $newStorage new storage data
-	 */
-	abstract protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage);
-
-	/**
-	 * Update storage to the configuration
-	 *
-	 * @param StorageConfig $updatedStorage storage attributes
-	 *
-	 * @return StorageConfig storage config
-	 * @throws NotFoundException if the given storage does not exist in the config
-	 */
-	public function updateStorage(StorageConfig $updatedStorage) {
-		$id = $updatedStorage->getId();
-
-		$existingMount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found while updating storage');
-		}
-
-		$oldStorage = $this->getStorageConfigFromDBMount($existingMount);
-
-		if ($oldStorage->getBackend() instanceof InvalidBackend) {
-			throw new NotFoundException('Storage with id "' . $id . '" cannot be edited due to missing backend');
-		}
-
-		$removedUsers = array_diff($oldStorage->getApplicableUsers(), $updatedStorage->getApplicableUsers());
-		$removedGroups = array_diff($oldStorage->getApplicableGroups(), $updatedStorage->getApplicableGroups());
-		$addedUsers = array_diff($updatedStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
-		$addedGroups = array_diff($updatedStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
-
-		$oldUserCount = count($oldStorage->getApplicableUsers());
-		$oldGroupCount = count($oldStorage->getApplicableGroups());
-		$newUserCount = count($updatedStorage->getApplicableUsers());
-		$newGroupCount = count($updatedStorage->getApplicableGroups());
-		$wasGlobal = ($oldUserCount + $oldGroupCount) === 0;
-		$isGlobal = ($newUserCount + $newGroupCount) === 0;
-
-		foreach ($removedUsers as $user) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($removedGroups as $group) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-		foreach ($addedUsers as $user) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($addedGroups as $group) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-
-		if ($wasGlobal && !$isGlobal) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		} elseif (!$wasGlobal && $isGlobal) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		}
-
-		$changedConfig = array_diff_assoc($updatedStorage->getBackendOptions(), $oldStorage->getBackendOptions());
-		$changedOptions = array_diff_assoc($updatedStorage->getMountOptions(), $oldStorage->getMountOptions());
-
-		foreach ($changedConfig as $key => $value) {
-			if ($value !== DefinitionParameter::UNMODIFIED_PLACEHOLDER) {
-				$this->dbConfig->setConfig($id, $key, $value);
-			}
-		}
-		foreach ($changedOptions as $key => $value) {
-			$this->dbConfig->setOption($id, $key, $value);
-		}
-
-		if ($updatedStorage->getMountPoint() !== $oldStorage->getMountPoint()) {
-			$this->dbConfig->setMountPoint($id, $updatedStorage->getMountPoint());
-		}
-
-		if ($updatedStorage->getAuthMechanism()->getIdentifier() !== $oldStorage->getAuthMechanism()->getIdentifier()) {
-			$this->dbConfig->setAuthBackend($id, $updatedStorage->getAuthMechanism()->getIdentifier());
-		}
-
-		$this->triggerChangeHooks($oldStorage, $updatedStorage);
-
-		if (($wasGlobal && !$isGlobal) || count($removedGroups) > 0) { // to expensive to properly handle these on the fly
-			$this->userMountCache->remoteStorageMounts($this->getStorageId($updatedStorage));
-		} else {
-			$storageId = $this->getStorageId($updatedStorage);
-			foreach ($removedUsers as $userId) {
-				$this->userMountCache->removeUserStorageMount($storageId, $userId);
-			}
-		}
-
-		return $this->getStorage($id);
-	}
-
-	/**
-	 * Delete the storage with the given id.
-	 *
-	 * @param int $id storage id
-	 *
-	 * @throws NotFoundException if no storage was found with the given id
-	 */
-	public function removeStorage($id) {
-		$existingMount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-
-		$this->dbConfig->removeMount($id);
-
-		$deletedStorage = $this->getStorageConfigFromDBMount($existingMount);
-		$this->triggerHooks($deletedStorage, Filesystem::signal_delete_mount);
-
-		// delete oc_storages entries and oc_filecache
-		\OC\Files\Cache\Storage::cleanByMountId($id);
-	}
-
-	/**
-	 * Construct the storage implementation
-	 *
-	 * @param StorageConfig $storageConfig
-	 * @return int
-	 */
-	private function getStorageId(StorageConfig $storageConfig) {
-		try {
-			$class = $storageConfig->getBackend()->getStorageClass();
-			/** @var \OC\Files\Storage\Storage $storage */
-			$storage = new $class($storageConfig->getBackendOptions());
-
-			// auth mechanism should fire first
-			$storage = $storageConfig->getBackend()->wrapStorage($storage);
-			$storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
-
-			return $storage->getStorageCache()->getNumericId();
-		} catch (\Exception $e) {
-			return -1;
-		}
-	}
+    /** @var BackendService */
+    protected $backendService;
+
+    /**
+     * @var DBConfigService
+     */
+    protected $dbConfig;
+
+    /**
+     * @var IUserMountCache
+     */
+    protected $userMountCache;
+
+    /**
+     * @param BackendService $backendService
+     * @param DBConfigService $dbConfigService
+     * @param IUserMountCache $userMountCache
+     */
+    public function __construct(BackendService $backendService, DBConfigService $dbConfigService, IUserMountCache $userMountCache) {
+        $this->backendService = $backendService;
+        $this->dbConfig = $dbConfigService;
+        $this->userMountCache = $userMountCache;
+    }
+
+    protected function readDBConfig() {
+        return $this->dbConfig->getAdminMounts();
+    }
+
+    protected function getStorageConfigFromDBMount(array $mount) {
+        $applicableUsers = array_filter($mount['applicable'], function ($applicable) {
+            return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_USER;
+        });
+        $applicableUsers = array_map(function ($applicable) {
+            return $applicable['value'];
+        }, $applicableUsers);
+
+        $applicableGroups = array_filter($mount['applicable'], function ($applicable) {
+            return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_GROUP;
+        });
+        $applicableGroups = array_map(function ($applicable) {
+            return $applicable['value'];
+        }, $applicableGroups);
+
+        try {
+            $config = $this->createStorage(
+                $mount['mount_point'],
+                $mount['storage_backend'],
+                $mount['auth_backend'],
+                $mount['config'],
+                $mount['options'],
+                array_values($applicableUsers),
+                array_values($applicableGroups),
+                $mount['priority']
+            );
+            $config->setType($mount['type']);
+            $config->setId((int)$mount['mount_id']);
+            return $config;
+        } catch (\UnexpectedValueException $e) {
+            // don't die if a storage backend doesn't exist
+            \OC::$server->getLogger()->logException($e, [
+                'message' => 'Could not load storage.',
+                'level' => ILogger::ERROR,
+                'app' => 'files_external',
+            ]);
+            return null;
+        } catch (\InvalidArgumentException $e) {
+            \OC::$server->getLogger()->logException($e, [
+                'message' => 'Could not load storage.',
+                'level' => ILogger::ERROR,
+                'app' => 'files_external',
+            ]);
+            return null;
+        }
+    }
+
+    /**
+     * Read the external storage config
+     *
+     * @return array map of storage id to storage config
+     */
+    protected function readConfig() {
+        $mounts = $this->readDBConfig();
+        $configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
+        $configs = array_filter($configs, function ($config) {
+            return $config instanceof StorageConfig;
+        });
+
+        $keys = array_map(function (StorageConfig $config) {
+            return $config->getId();
+        }, $configs);
+
+        return array_combine($keys, $configs);
+    }
+
+    /**
+     * Get a storage with status
+     *
+     * @param int $id storage id
+     *
+     * @return StorageConfig
+     * @throws NotFoundException if the storage with the given id was not found
+     */
+    public function getStorage($id) {
+        $mount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($mount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+
+        $config = $this->getStorageConfigFromDBMount($mount);
+        if ($this->isApplicable($config)) {
+            return $config;
+        } else {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+    }
+
+    /**
+     * Check whether this storage service should provide access to a storage
+     *
+     * @param StorageConfig $config
+     * @return bool
+     */
+    abstract protected function isApplicable(StorageConfig $config);
+
+    /**
+     * Gets all storages, valid or not
+     *
+     * @return StorageConfig[] array of storage configs
+     */
+    public function getAllStorages() {
+        return $this->readConfig();
+    }
+
+    /**
+     * Gets all valid storages
+     *
+     * @return StorageConfig[]
+     */
+    public function getStorages() {
+        return array_filter($this->getAllStorages(), [$this, 'validateStorage']);
+    }
+
+    /**
+     * Validate storage
+     * FIXME: De-duplicate with StoragesController::validate()
+     *
+     * @param StorageConfig $storage
+     * @return bool
+     */
+    protected function validateStorage(StorageConfig $storage) {
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+
+        if (!$backend->isVisibleFor($this->getVisibilityType())) {
+            // not permitted to use backend
+            return false;
+        }
+        if (!$authMechanism->isVisibleFor($this->getVisibilityType())) {
+            // not permitted to use auth mechanism
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Get the visibility type for this controller, used in validation
+     *
+     * @return string BackendService::VISIBILITY_* constants
+     */
+    abstract public function getVisibilityType();
+
+    /**
+     * @return integer
+     */
+    protected function getType() {
+        return DBConfigService::MOUNT_TYPE_ADMIN;
+    }
+
+    /**
+     * Add new storage to the configuration
+     *
+     * @param StorageConfig $newStorage storage attributes
+     *
+     * @return StorageConfig storage config, with added id
+     */
+    public function addStorage(StorageConfig $newStorage) {
+        $allStorages = $this->readConfig();
+
+        $configId = $this->dbConfig->addMount(
+            $newStorage->getMountPoint(),
+            $newStorage->getBackend()->getIdentifier(),
+            $newStorage->getAuthMechanism()->getIdentifier(),
+            $newStorage->getPriority(),
+            $this->getType()
+        );
+
+        $newStorage->setId($configId);
+
+        foreach ($newStorage->getApplicableUsers() as $user) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($newStorage->getApplicableGroups() as $group) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+        foreach ($newStorage->getBackendOptions() as $key => $value) {
+            $this->dbConfig->setConfig($configId, $key, $value);
+        }
+        foreach ($newStorage->getMountOptions() as $key => $value) {
+            $this->dbConfig->setOption($configId, $key, $value);
+        }
+
+        if (count($newStorage->getApplicableUsers()) === 0 && count($newStorage->getApplicableGroups()) === 0) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        }
+
+        // add new storage
+        $allStorages[$configId] = $newStorage;
+
+        $this->triggerHooks($newStorage, Filesystem::signal_create_mount);
+
+        $newStorage->setStatus(StorageNotAvailableException::STATUS_SUCCESS);
+        return $newStorage;
+    }
+
+    /**
+     * Create a storage from its parameters
+     *
+     * @param string $mountPoint storage mount point
+     * @param string $backendIdentifier backend identifier
+     * @param string $authMechanismIdentifier authentication mechanism identifier
+     * @param array $backendOptions backend-specific options
+     * @param array|null $mountOptions mount-specific options
+     * @param array|null $applicableUsers users for which to mount the storage
+     * @param array|null $applicableGroups groups for which to mount the storage
+     * @param int|null $priority priority
+     *
+     * @return StorageConfig
+     */
+    public function createStorage(
+        $mountPoint,
+        $backendIdentifier,
+        $authMechanismIdentifier,
+        $backendOptions,
+        $mountOptions = null,
+        $applicableUsers = null,
+        $applicableGroups = null,
+        $priority = null
+    ) {
+        $backend = $this->backendService->getBackend($backendIdentifier);
+        if (!$backend) {
+            $backend = new InvalidBackend($backendIdentifier);
+        }
+        $authMechanism = $this->backendService->getAuthMechanism($authMechanismIdentifier);
+        if (!$authMechanism) {
+            $authMechanism = new InvalidAuth($authMechanismIdentifier);
+        }
+        $newStorage = new StorageConfig();
+        $newStorage->setMountPoint($mountPoint);
+        $newStorage->setBackend($backend);
+        $newStorage->setAuthMechanism($authMechanism);
+        $newStorage->setBackendOptions($backendOptions);
+        if (isset($mountOptions)) {
+            $newStorage->setMountOptions($mountOptions);
+        }
+        if (isset($applicableUsers)) {
+            $newStorage->setApplicableUsers($applicableUsers);
+        }
+        if (isset($applicableGroups)) {
+            $newStorage->setApplicableGroups($applicableGroups);
+        }
+        if (isset($priority)) {
+            $newStorage->setPriority($priority);
+        }
+
+        return $newStorage;
+    }
+
+    /**
+     * Triggers the given hook signal for all the applicables given
+     *
+     * @param string $signal signal
+     * @param string $mountPoint hook mount pount param
+     * @param string $mountType hook mount type param
+     * @param array $applicableArray array of applicable users/groups for which to trigger the hook
+     */
+    protected function triggerApplicableHooks($signal, $mountPoint, $mountType, $applicableArray) {
+        foreach ($applicableArray as $applicable) {
+            \OCP\Util::emitHook(
+                Filesystem::CLASSNAME,
+                $signal,
+                [
+                    Filesystem::signal_param_path => $mountPoint,
+                    Filesystem::signal_param_mount_type => $mountType,
+                    Filesystem::signal_param_users => $applicable,
+                ]
+            );
+        }
+    }
+
+    /**
+     * Triggers $signal for all applicable users of the given
+     * storage
+     *
+     * @param StorageConfig $storage storage data
+     * @param string $signal signal to trigger
+     */
+    abstract protected function triggerHooks(StorageConfig $storage, $signal);
+
+    /**
+     * Triggers signal_create_mount or signal_delete_mount to
+     * accommodate for additions/deletions in applicableUsers
+     * and applicableGroups fields.
+     *
+     * @param StorageConfig $oldStorage old storage data
+     * @param StorageConfig $newStorage new storage data
+     */
+    abstract protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage);
+
+    /**
+     * Update storage to the configuration
+     *
+     * @param StorageConfig $updatedStorage storage attributes
+     *
+     * @return StorageConfig storage config
+     * @throws NotFoundException if the given storage does not exist in the config
+     */
+    public function updateStorage(StorageConfig $updatedStorage) {
+        $id = $updatedStorage->getId();
+
+        $existingMount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($existingMount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found while updating storage');
+        }
+
+        $oldStorage = $this->getStorageConfigFromDBMount($existingMount);
+
+        if ($oldStorage->getBackend() instanceof InvalidBackend) {
+            throw new NotFoundException('Storage with id "' . $id . '" cannot be edited due to missing backend');
+        }
+
+        $removedUsers = array_diff($oldStorage->getApplicableUsers(), $updatedStorage->getApplicableUsers());
+        $removedGroups = array_diff($oldStorage->getApplicableGroups(), $updatedStorage->getApplicableGroups());
+        $addedUsers = array_diff($updatedStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
+        $addedGroups = array_diff($updatedStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
+
+        $oldUserCount = count($oldStorage->getApplicableUsers());
+        $oldGroupCount = count($oldStorage->getApplicableGroups());
+        $newUserCount = count($updatedStorage->getApplicableUsers());
+        $newGroupCount = count($updatedStorage->getApplicableGroups());
+        $wasGlobal = ($oldUserCount + $oldGroupCount) === 0;
+        $isGlobal = ($newUserCount + $newGroupCount) === 0;
+
+        foreach ($removedUsers as $user) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($removedGroups as $group) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+        foreach ($addedUsers as $user) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($addedGroups as $group) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+
+        if ($wasGlobal && !$isGlobal) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        } elseif (!$wasGlobal && $isGlobal) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        }
+
+        $changedConfig = array_diff_assoc($updatedStorage->getBackendOptions(), $oldStorage->getBackendOptions());
+        $changedOptions = array_diff_assoc($updatedStorage->getMountOptions(), $oldStorage->getMountOptions());
+
+        foreach ($changedConfig as $key => $value) {
+            if ($value !== DefinitionParameter::UNMODIFIED_PLACEHOLDER) {
+                $this->dbConfig->setConfig($id, $key, $value);
+            }
+        }
+        foreach ($changedOptions as $key => $value) {
+            $this->dbConfig->setOption($id, $key, $value);
+        }
+
+        if ($updatedStorage->getMountPoint() !== $oldStorage->getMountPoint()) {
+            $this->dbConfig->setMountPoint($id, $updatedStorage->getMountPoint());
+        }
+
+        if ($updatedStorage->getAuthMechanism()->getIdentifier() !== $oldStorage->getAuthMechanism()->getIdentifier()) {
+            $this->dbConfig->setAuthBackend($id, $updatedStorage->getAuthMechanism()->getIdentifier());
+        }
+
+        $this->triggerChangeHooks($oldStorage, $updatedStorage);
+
+        if (($wasGlobal && !$isGlobal) || count($removedGroups) > 0) { // to expensive to properly handle these on the fly
+            $this->userMountCache->remoteStorageMounts($this->getStorageId($updatedStorage));
+        } else {
+            $storageId = $this->getStorageId($updatedStorage);
+            foreach ($removedUsers as $userId) {
+                $this->userMountCache->removeUserStorageMount($storageId, $userId);
+            }
+        }
+
+        return $this->getStorage($id);
+    }
+
+    /**
+     * Delete the storage with the given id.
+     *
+     * @param int $id storage id
+     *
+     * @throws NotFoundException if no storage was found with the given id
+     */
+    public function removeStorage($id) {
+        $existingMount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($existingMount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+
+        $this->dbConfig->removeMount($id);
+
+        $deletedStorage = $this->getStorageConfigFromDBMount($existingMount);
+        $this->triggerHooks($deletedStorage, Filesystem::signal_delete_mount);
+
+        // delete oc_storages entries and oc_filecache
+        \OC\Files\Cache\Storage::cleanByMountId($id);
+    }
+
+    /**
+     * Construct the storage implementation
+     *
+     * @param StorageConfig $storageConfig
+     * @return int
+     */
+    private function getStorageId(StorageConfig $storageConfig) {
+        try {
+            $class = $storageConfig->getBackend()->getStorageClass();
+            /** @var \OC\Files\Storage\Storage $storage */
+            $storage = new $class($storageConfig->getBackendOptions());
+
+            // auth mechanism should fire first
+            $storage = $storageConfig->getBackend()->wrapStorage($storage);
+            $storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
+
+            return $storage->getStorageCache()->getNumericId();
+        } catch (\Exception $e) {
+            return -1;
+        }
+    }
 }

apps/files_external/lib/Service/GlobalStoragesService.php

Indentation +147 added lines, -147 removed lines

@@ -36,151 +36,151 @@
  * Service class to manage global external storage
  */
 class GlobalStoragesService extends StoragesService {
-	/**
-	 * Triggers $signal for all applicable users of the given
-	 * storage
-	 *
-	 * @param StorageConfig $storage storage data
-	 * @param string $signal signal to trigger
-	 */
-	protected function triggerHooks(StorageConfig $storage, $signal) {
-		// FIXME: Use as expression in empty once PHP 5.4 support is dropped
-		$applicableUsers = $storage->getApplicableUsers();
-		$applicableGroups = $storage->getApplicableGroups();
-		if (empty($applicableUsers) && empty($applicableGroups)) {
-			// raise for user "all"
-			$this->triggerApplicableHooks(
-				$signal,
-				$storage->getMountPoint(),
-				\OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
-				['all']
-			);
-			return;
-		}
-
-		$this->triggerApplicableHooks(
-			$signal,
-			$storage->getMountPoint(),
-			\OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
-			$applicableUsers
-		);
-		$this->triggerApplicableHooks(
-			$signal,
-			$storage->getMountPoint(),
-			\OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
-			$applicableGroups
-		);
-	}
-
-	/**
-	 * Triggers signal_create_mount or signal_delete_mount to
-	 * accommodate for additions/deletions in applicableUsers
-	 * and applicableGroups fields.
-	 *
-	 * @param StorageConfig $oldStorage old storage config
-	 * @param StorageConfig $newStorage new storage config
-	 */
-	protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage) {
-		// if mount point changed, it's like a deletion + creation
-		if ($oldStorage->getMountPoint() !== $newStorage->getMountPoint()) {
-			$this->triggerHooks($oldStorage, Filesystem::signal_delete_mount);
-			$this->triggerHooks($newStorage, Filesystem::signal_create_mount);
-			return;
-		}
-
-		$userAdditions = array_diff($newStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
-		$userDeletions = array_diff($oldStorage->getApplicableUsers(), $newStorage->getApplicableUsers());
-		$groupAdditions = array_diff($newStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
-		$groupDeletions = array_diff($oldStorage->getApplicableGroups(), $newStorage->getApplicableGroups());
-
-		// FIXME: Use as expression in empty once PHP 5.4 support is dropped
-		// if no applicable were set, raise a signal for "all"
-		$oldApplicableUsers = $oldStorage->getApplicableUsers();
-		$oldApplicableGroups = $oldStorage->getApplicableGroups();
-		if (empty($oldApplicableUsers) && empty($oldApplicableGroups)) {
-			$this->triggerApplicableHooks(
-				Filesystem::signal_delete_mount,
-				$oldStorage->getMountPoint(),
-				\OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
-				['all']
-			);
-		}
-
-		// trigger delete for removed users
-		$this->triggerApplicableHooks(
-			Filesystem::signal_delete_mount,
-			$oldStorage->getMountPoint(),
-			\OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
-			$userDeletions
-		);
-
-		// trigger delete for removed groups
-		$this->triggerApplicableHooks(
-			Filesystem::signal_delete_mount,
-			$oldStorage->getMountPoint(),
-			\OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
-			$groupDeletions
-		);
-
-		// and now add the new users
-		$this->triggerApplicableHooks(
-			Filesystem::signal_create_mount,
-			$newStorage->getMountPoint(),
-			\OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
-			$userAdditions
-		);
-
-		// and now add the new groups
-		$this->triggerApplicableHooks(
-			Filesystem::signal_create_mount,
-			$newStorage->getMountPoint(),
-			\OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
-			$groupAdditions
-		);
-
-		// FIXME: Use as expression in empty once PHP 5.4 support is dropped
-		// if no applicable, raise a signal for "all"
-		$newApplicableUsers = $newStorage->getApplicableUsers();
-		$newApplicableGroups = $newStorage->getApplicableGroups();
-		if (empty($newApplicableUsers) && empty($newApplicableGroups)) {
-			$this->triggerApplicableHooks(
-				Filesystem::signal_create_mount,
-				$newStorage->getMountPoint(),
-				\OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
-				['all']
-			);
-		}
-	}
-
-	/**
-	 * Get the visibility type for this controller, used in validation
-	 *
-	 * @return string BackendService::VISIBILITY_* constants
-	 */
-	public function getVisibilityType() {
-		return BackendService::VISIBILITY_ADMIN;
-	}
-
-	protected function isApplicable(StorageConfig $config) {
-		return true;
-	}
-
-	/**
-	 * Get all configured admin and personal mounts
-	 *
-	 * @return StorageConfig[] map of storage id to storage config
-	 */
-	public function getStorageForAllUsers() {
-		$mounts = $this->dbConfig->getAllMounts();
-		$configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
-		$configs = array_filter($configs, function ($config) {
-			return $config instanceof StorageConfig;
-		});
-
-		$keys = array_map(function (StorageConfig $config) {
-			return $config->getId();
-		}, $configs);
-
-		return array_combine($keys, $configs);
-	}
+    /**
+     * Triggers $signal for all applicable users of the given
+     * storage
+     *
+     * @param StorageConfig $storage storage data
+     * @param string $signal signal to trigger
+     */
+    protected function triggerHooks(StorageConfig $storage, $signal) {
+        // FIXME: Use as expression in empty once PHP 5.4 support is dropped
+        $applicableUsers = $storage->getApplicableUsers();
+        $applicableGroups = $storage->getApplicableGroups();
+        if (empty($applicableUsers) && empty($applicableGroups)) {
+            // raise for user "all"
+            $this->triggerApplicableHooks(
+                $signal,
+                $storage->getMountPoint(),
+                \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+                ['all']
+            );
+            return;
+        }
+
+        $this->triggerApplicableHooks(
+            $signal,
+            $storage->getMountPoint(),
+            \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+            $applicableUsers
+        );
+        $this->triggerApplicableHooks(
+            $signal,
+            $storage->getMountPoint(),
+            \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+            $applicableGroups
+        );
+    }
+
+    /**
+     * Triggers signal_create_mount or signal_delete_mount to
+     * accommodate for additions/deletions in applicableUsers
+     * and applicableGroups fields.
+     *
+     * @param StorageConfig $oldStorage old storage config
+     * @param StorageConfig $newStorage new storage config
+     */
+    protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage) {
+        // if mount point changed, it's like a deletion + creation
+        if ($oldStorage->getMountPoint() !== $newStorage->getMountPoint()) {
+            $this->triggerHooks($oldStorage, Filesystem::signal_delete_mount);
+            $this->triggerHooks($newStorage, Filesystem::signal_create_mount);
+            return;
+        }
+
+        $userAdditions = array_diff($newStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
+        $userDeletions = array_diff($oldStorage->getApplicableUsers(), $newStorage->getApplicableUsers());
+        $groupAdditions = array_diff($newStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
+        $groupDeletions = array_diff($oldStorage->getApplicableGroups(), $newStorage->getApplicableGroups());
+
+        // FIXME: Use as expression in empty once PHP 5.4 support is dropped
+        // if no applicable were set, raise a signal for "all"
+        $oldApplicableUsers = $oldStorage->getApplicableUsers();
+        $oldApplicableGroups = $oldStorage->getApplicableGroups();
+        if (empty($oldApplicableUsers) && empty($oldApplicableGroups)) {
+            $this->triggerApplicableHooks(
+                Filesystem::signal_delete_mount,
+                $oldStorage->getMountPoint(),
+                \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+                ['all']
+            );
+        }
+
+        // trigger delete for removed users
+        $this->triggerApplicableHooks(
+            Filesystem::signal_delete_mount,
+            $oldStorage->getMountPoint(),
+            \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+            $userDeletions
+        );
+
+        // trigger delete for removed groups
+        $this->triggerApplicableHooks(
+            Filesystem::signal_delete_mount,
+            $oldStorage->getMountPoint(),
+            \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+            $groupDeletions
+        );
+
+        // and now add the new users
+        $this->triggerApplicableHooks(
+            Filesystem::signal_create_mount,
+            $newStorage->getMountPoint(),
+            \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+            $userAdditions
+        );
+
+        // and now add the new groups
+        $this->triggerApplicableHooks(
+            Filesystem::signal_create_mount,
+            $newStorage->getMountPoint(),
+            \OCA\Files_External\MountConfig::MOUNT_TYPE_GROUP,
+            $groupAdditions
+        );
+
+        // FIXME: Use as expression in empty once PHP 5.4 support is dropped
+        // if no applicable, raise a signal for "all"
+        $newApplicableUsers = $newStorage->getApplicableUsers();
+        $newApplicableGroups = $newStorage->getApplicableGroups();
+        if (empty($newApplicableUsers) && empty($newApplicableGroups)) {
+            $this->triggerApplicableHooks(
+                Filesystem::signal_create_mount,
+                $newStorage->getMountPoint(),
+                \OCA\Files_External\MountConfig::MOUNT_TYPE_USER,
+                ['all']
+            );
+        }
+    }
+
+    /**
+     * Get the visibility type for this controller, used in validation
+     *
+     * @return string BackendService::VISIBILITY_* constants
+     */
+    public function getVisibilityType() {
+        return BackendService::VISIBILITY_ADMIN;
+    }
+
+    protected function isApplicable(StorageConfig $config) {
+        return true;
+    }
+
+    /**
+     * Get all configured admin and personal mounts
+     *
+     * @return StorageConfig[] map of storage id to storage config
+     */
+    public function getStorageForAllUsers() {
+        $mounts = $this->dbConfig->getAllMounts();
+        $configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
+        $configs = array_filter($configs, function ($config) {
+            return $config instanceof StorageConfig;
+        });
+
+        $keys = array_map(function (StorageConfig $config) {
+            return $config->getId();
+        }, $configs);
+
+        return array_combine($keys, $configs);
+    }
 }

apps/workflowengine/lib/Check/FileName.php

Indentation +53 added lines, -53 removed lines

@@ -31,63 +31,63 @@
 use OCP\WorkflowEngine\IFileCheck;
 
 class FileName extends AbstractStringCheck implements IFileCheck {
-	use TFileCheck;
+    use TFileCheck;
 
-	/** @var IRequest */
-	protected $request;
-	/** @var IMountManager */
-	private $mountManager;
+    /** @var IRequest */
+    protected $request;
+    /** @var IMountManager */
+    private $mountManager;
 
-	/**
-	 * @param IL10N $l
-	 * @param IRequest $request
-	 */
-	public function __construct(IL10N $l, IRequest $request, IMountManager $mountManager) {
-		parent::__construct($l);
-		$this->request = $request;
-		$this->mountManager = $mountManager;
-	}
+    /**
+     * @param IL10N $l
+     * @param IRequest $request
+     */
+    public function __construct(IL10N $l, IRequest $request, IMountManager $mountManager) {
+        parent::__construct($l);
+        $this->request = $request;
+        $this->mountManager = $mountManager;
+    }
 
-	/**
-	 * @return string
-	 */
-	protected function getActualValue(): string {
-		$fileName = $this->path === null ? '' : basename($this->path);
-		if ($fileName === '' && (!$this->storage->isLocal() || $this->storage->instanceOfStorage(Local::class))) {
-			// Return the mountpoint name of external storage that are not mounted as user home
-			$mountPoints = $this->mountManager->findByStorageId($this->storage->getId());
-			if (empty($mountPoints) || $mountPoints[0]->getMountType() !== 'external') {
-				return $fileName;
-			}
-			$mountPointPath = rtrim($mountPoints[0]->getMountPoint(), '/');
-			$mountPointPieces = explode('/', $mountPointPath);
-			$mountPointName = array_pop($mountPointPieces);
-			if (!empty($mountPointName) && $mountPointName !== 'files' && count($mountPointPieces) !== 2) {
-				return $mountPointName;
-			}
-		}
-		return $fileName;
-	}
+    /**
+     * @return string
+     */
+    protected function getActualValue(): string {
+        $fileName = $this->path === null ? '' : basename($this->path);
+        if ($fileName === '' && (!$this->storage->isLocal() || $this->storage->instanceOfStorage(Local::class))) {
+            // Return the mountpoint name of external storage that are not mounted as user home
+            $mountPoints = $this->mountManager->findByStorageId($this->storage->getId());
+            if (empty($mountPoints) || $mountPoints[0]->getMountType() !== 'external') {
+                return $fileName;
+            }
+            $mountPointPath = rtrim($mountPoints[0]->getMountPoint(), '/');
+            $mountPointPieces = explode('/', $mountPointPath);
+            $mountPointName = array_pop($mountPointPieces);
+            if (!empty($mountPointName) && $mountPointName !== 'files' && count($mountPointPieces) !== 2) {
+                return $mountPointName;
+            }
+        }
+        return $fileName;
+    }
 
-	/**
-	 * @param string $operator
-	 * @param string $checkValue
-	 * @param string $actualValue
-	 * @return bool
-	 */
-	protected function executeStringCheck($operator, $checkValue, $actualValue): bool {
-		if ($operator === 'is' || $operator === '!is') {
-			$checkValue = mb_strtolower($checkValue);
-			$actualValue = mb_strtolower($actualValue);
-		}
-		return parent::executeStringCheck($operator, $checkValue, $actualValue);
-	}
+    /**
+     * @param string $operator
+     * @param string $checkValue
+     * @param string $actualValue
+     * @return bool
+     */
+    protected function executeStringCheck($operator, $checkValue, $actualValue): bool {
+        if ($operator === 'is' || $operator === '!is') {
+            $checkValue = mb_strtolower($checkValue);
+            $actualValue = mb_strtolower($actualValue);
+        }
+        return parent::executeStringCheck($operator, $checkValue, $actualValue);
+    }
 
-	public function supportedEntities(): array {
-		return [ File::class ];
-	}
+    public function supportedEntities(): array {
+        return [ File::class ];
+    }
 
-	public function isAvailableForScope(int $scope): bool {
-		return true;
-	}
+    public function isAvailableForScope(int $scope): bool {
+        return true;
+    }
 }

apps/files_sharing/lib/External/Mount.php

Indentation +44 added lines, -44 removed lines

@@ -30,53 +30,53 @@
 
 class Mount extends MountPoint implements MoveableMount {
 
-	/**
-	 * @var \OCA\Files_Sharing\External\Manager
-	 */
-	protected $manager;
+    /**
+     * @var \OCA\Files_Sharing\External\Manager
+     */
+    protected $manager;
 
-	/**
-	 * @param string|\OC\Files\Storage\Storage $storage
-	 * @param string $mountpoint
-	 * @param array $options
-	 * @param \OCA\Files_Sharing\External\Manager $manager
-	 * @param \OC\Files\Storage\StorageFactory $loader
-	 */
-	public function __construct($storage, $mountpoint, $options, $manager, $loader = null) {
-		parent::__construct($storage, $mountpoint, $options, $loader);
-		$this->manager = $manager;
-	}
+    /**
+     * @param string|\OC\Files\Storage\Storage $storage
+     * @param string $mountpoint
+     * @param array $options
+     * @param \OCA\Files_Sharing\External\Manager $manager
+     * @param \OC\Files\Storage\StorageFactory $loader
+     */
+    public function __construct($storage, $mountpoint, $options, $manager, $loader = null) {
+        parent::__construct($storage, $mountpoint, $options, $loader);
+        $this->manager = $manager;
+    }
 
-	/**
-	 * Move the mount point to $target
-	 *
-	 * @param string $target the target mount point
-	 * @return bool
-	 */
-	public function moveMount($target) {
-		$result = $this->manager->setMountPoint($this->mountPoint, $target);
-		$this->setMountPoint($target);
+    /**
+     * Move the mount point to $target
+     *
+     * @param string $target the target mount point
+     * @return bool
+     */
+    public function moveMount($target) {
+        $result = $this->manager->setMountPoint($this->mountPoint, $target);
+        $this->setMountPoint($target);
 
-		return $result;
-	}
+        return $result;
+    }
 
-	/**
-	 * Remove the mount points
-	 *
-	 * @return mixed
-	 * @return bool
-	 */
-	public function removeMount() {
-		return $this->manager->removeShare($this->mountPoint);
-	}
+    /**
+     * Remove the mount points
+     *
+     * @return mixed
+     * @return bool
+     */
+    public function removeMount() {
+        return $this->manager->removeShare($this->mountPoint);
+    }
 
-	/**
-	 * Get the type of mount point, used to distinguish things like shares and external storage
-	 * in the web interface
-	 *
-	 * @return string
-	 */
-	public function getMountType() {
-		return 'shared';
-	}
+    /**
+     * Get the type of mount point, used to distinguish things like shares and external storage
+     * in the web interface
+     *
+     * @return string
+     */
+    public function getMountType() {
+        return 'shared';
+    }
 }

lib/public/Files/Mount/IMountPoint.php

Indentation +88 added lines, -88 removed lines

@@ -29,103 +29,103 @@
  */
 interface IMountPoint {
 
-	/**
-	 * get complete path to the mount point
-	 *
-	 * @return string
-	 * @since 8.0.0
-	 */
-	public function getMountPoint();
+    /**
+     * get complete path to the mount point
+     *
+     * @return string
+     * @since 8.0.0
+     */
+    public function getMountPoint();
 
-	/**
-	 * Set the mountpoint
-	 *
-	 * @param string $mountPoint new mount point
-	 * @since 8.0.0
-	 */
-	public function setMountPoint($mountPoint);
+    /**
+     * Set the mountpoint
+     *
+     * @param string $mountPoint new mount point
+     * @since 8.0.0
+     */
+    public function setMountPoint($mountPoint);
 
-	/**
-	 * Get the storage that is mounted
-	 *
-	 * @return \OC\Files\Storage\Storage|null
-	 * @since 8.0.0
-	 */
-	public function getStorage();
+    /**
+     * Get the storage that is mounted
+     *
+     * @return \OC\Files\Storage\Storage|null
+     * @since 8.0.0
+     */
+    public function getStorage();
 
-	/**
-	 * Get the id of the storages
-	 *
-	 * @return string
-	 * @since 8.0.0
-	 */
-	public function getStorageId();
+    /**
+     * Get the id of the storages
+     *
+     * @return string
+     * @since 8.0.0
+     */
+    public function getStorageId();
 
-	/**
-	 * Get the id of the storages
-	 *
-	 * @return int
-	 * @since 9.1.0
-	 */
-	public function getNumericStorageId();
+    /**
+     * Get the id of the storages
+     *
+     * @return int
+     * @since 9.1.0
+     */
+    public function getNumericStorageId();
 
-	/**
-	 * Get the path relative to the mountpoint
-	 *
-	 * @param string $path absolute path to a file or folder
-	 * @return string
-	 * @since 8.0.0
-	 */
-	public function getInternalPath($path);
+    /**
+     * Get the path relative to the mountpoint
+     *
+     * @param string $path absolute path to a file or folder
+     * @return string
+     * @since 8.0.0
+     */
+    public function getInternalPath($path);
 
-	/**
-	 * Apply a storage wrapper to the mounted storage
-	 *
-	 * @param callable $wrapper
-	 * @since 8.0.0
-	 */
-	public function wrapStorage($wrapper);
+    /**
+     * Apply a storage wrapper to the mounted storage
+     *
+     * @param callable $wrapper
+     * @since 8.0.0
+     */
+    public function wrapStorage($wrapper);
 
-	/**
-	 * Get a mount option
-	 *
-	 * @param string $name Name of the mount option to get
-	 * @param mixed $default Default value for the mount option
-	 * @return mixed
-	 * @since 8.0.0
-	 */
-	public function getOption($name, $default);
+    /**
+     * Get a mount option
+     *
+     * @param string $name Name of the mount option to get
+     * @param mixed $default Default value for the mount option
+     * @return mixed
+     * @since 8.0.0
+     */
+    public function getOption($name, $default);
 
-	/**
-	 * Get all options for the mount
-	 *
-	 * @return array
-	 * @since 8.1.0
-	 */
-	public function getOptions();
+    /**
+     * Get all options for the mount
+     *
+     * @return array
+     * @since 8.1.0
+     */
+    public function getOptions();
 
-	/**
-	 * Get the file id of the root of the storage
-	 *
-	 * @return int
-	 * @since 9.1.0
-	 */
-	public function getStorageRootId();
+    /**
+     * Get the file id of the root of the storage
+     *
+     * @return int
+     * @since 9.1.0
+     */
+    public function getStorageRootId();
 
-	/**
-	 * Get the id of the configured mount
-	 *
-	 * @return int|null mount id or null if not applicable
-	 * @since 9.1.0
-	 */
-	public function getMountId();
+    /**
+     * Get the id of the configured mount
+     *
+     * @return int|null mount id or null if not applicable
+     * @since 9.1.0
+     */
+    public function getMountId();
 
-	/**
-	 * Get the type of mount point, used to distinguish things like shares and external storage
-	 * in the web interface
-	 *
-	 * @return string
-	 * @since 12.0.0
-	 */
-	public function getMountType();
+    /**
+     * Get the type of mount point, used to distinguish things like shares and external storage
+     * in the web interface
+     *
+     * @return string
+     * @since 12.0.0
+     */
+    public function getMountType();
 }