nextcloud / server

apps/files_external/lib/Service/ImportLegacyStoragesService.php

Indentation +18 added lines, -18 removed lines

@@ -24,25 +24,25 @@
 namespace OCA\Files_External\Service;
 
 class ImportLegacyStoragesService extends LegacyStoragesService {
-	private $data;
+    private $data;
 
-	/**
-	 * @param BackendService $backendService
-	 */
-	public function __construct(BackendService $backendService) {
-		$this->backendService = $backendService;
-	}
+    /**
+     * @param BackendService $backendService
+     */
+    public function __construct(BackendService $backendService) {
+        $this->backendService = $backendService;
+    }
 
-	public function setData($data) {
-		$this->data = $data;
-	}
+    public function setData($data) {
+        $this->data = $data;
+    }
 
-	/**
-	 * Read legacy config data
-	 *
-	 * @return array list of mount configs
-	 */
-	protected function readLegacyConfig() {
-		return $this->data;
-	}
+    /**
+     * Read legacy config data
+     *
+     * @return array list of mount configs
+     */
+    protected function readLegacyConfig() {
+        return $this->data;
+    }
 }

apps/files_external/lib/Service/UserGlobalStoragesService.php

Indentation +163 added lines, -163 removed lines

@@ -34,167 +34,167 @@
  */
 class UserGlobalStoragesService extends GlobalStoragesService {
 
-	use UserTrait;
-
-	/** @var IGroupManager */
-	protected $groupManager;
-
-	/**
-	 * @param BackendService $backendService
-	 * @param DBConfigService $dbConfig
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 * @param IUserMountCache $userMountCache
-	 */
-	public function __construct(
-		BackendService $backendService,
-		DBConfigService $dbConfig,
-		IUserSession $userSession,
-		IGroupManager $groupManager,
-		IUserMountCache $userMountCache
-	) {
-		parent::__construct($backendService, $dbConfig, $userMountCache);
-		$this->userSession = $userSession;
-		$this->groupManager = $groupManager;
-	}
-
-	/**
-	 * Replace config hash ID with real IDs, for migrating legacy storages
-	 *
-	 * @param StorageConfig[] $storages Storages with real IDs
-	 * @param StorageConfig[] $storagesWithConfigHash Storages with config hash IDs
-	 */
-	protected function setRealStorageIds(array &$storages, array $storagesWithConfigHash) {
-		// as a read-only view, storage IDs don't need to be real
-		foreach ($storagesWithConfigHash as $storage) {
-			$storages[$storage->getId()] = $storage;
-		}
-	}
-
-	protected function readDBConfig() {
-		$userMounts = $this->dbConfig->getAdminMountsFor(DBConfigService::APPLICABLE_TYPE_USER, $this->getUser()->getUID());
-		$globalMounts = $this->dbConfig->getAdminMountsFor(DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		$groups = $this->groupManager->getUserGroupIds($this->getUser());
-		if (is_array($groups) && count($groups) !== 0) {
-			$groupMounts = $this->dbConfig->getAdminMountsForMultiple(DBConfigService::APPLICABLE_TYPE_GROUP, $groups);
-		} else {
-			$groupMounts = [];
-		}
-		return array_merge($userMounts, $groupMounts, $globalMounts);
-	}
-
-	public function addStorage(StorageConfig $newStorage) {
-		throw new \DomainException('UserGlobalStoragesService writing disallowed');
-	}
-
-	public function updateStorage(StorageConfig $updatedStorage) {
-		throw new \DomainException('UserGlobalStoragesService writing disallowed');
-	}
-
-	/**
-	 * @param integer $id
-	 */
-	public function removeStorage($id) {
-		throw new \DomainException('UserGlobalStoragesService writing disallowed');
-	}
-
-	/**
-	 * Get unique storages, in case two are defined with the same mountpoint
-	 * Higher priority storages take precedence
-	 *
-	 * @return StorageConfig[]
-	 */
-	public function getUniqueStorages() {
-		$storages = $this->getStorages();
-
-		$storagesByMountpoint = [];
-		foreach ($storages as $storage) {
-			$storagesByMountpoint[$storage->getMountPoint()][] = $storage;
-		}
-
-		$result = [];
-		foreach ($storagesByMountpoint as $storageList) {
-			$storage = array_reduce($storageList, function ($carry, $item) {
-				if (isset($carry)) {
-					$carryPriorityType = $this->getPriorityType($carry);
-					$itemPriorityType = $this->getPriorityType($item);
-					if ($carryPriorityType > $itemPriorityType) {
-						return $carry;
-					} elseif ($carryPriorityType === $itemPriorityType) {
-						if ($carry->getPriority() > $item->getPriority()) {
-							return $carry;
-						}
-					}
-				}
-				return $item;
-			});
-			$result[$storage->getID()] = $storage;
-		}
-
-		return $result;
-	}
-
-	/**
-	 * Get a priority 'type', where a bigger number means higher priority
-	 * user applicable > group applicable > 'all'
-	 *
-	 * @param StorageConfig $storage
-	 * @return int
-	 */
-	protected function getPriorityType(StorageConfig $storage) {
-		$applicableUsers = $storage->getApplicableUsers();
-		$applicableGroups = $storage->getApplicableGroups();
-
-		if ($applicableUsers && $applicableUsers[0] !== 'all') {
-			return 2;
-		}
-		if ($applicableGroups) {
-			return 1;
-		}
-		return 0;
-	}
-
-	protected function isApplicable(StorageConfig $config) {
-		$applicableUsers = $config->getApplicableUsers();
-		$applicableGroups = $config->getApplicableGroups();
-
-		if (count($applicableUsers) === 0 && count($applicableGroups) === 0) {
-			return true;
-		}
-		if (in_array($this->getUser()->getUID(), $applicableUsers, true)) {
-			return true;
-		}
-		$groupIds = $this->groupManager->getUserGroupIds($this->getUser());
-		foreach ($groupIds as $groupId) {
-			if (in_array($groupId, $applicableGroups, true)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-
-	/**
-	 * Gets all storages for the user, admin, personal, global, etc
-	 *
-	 * @return StorageConfig[] array of storage configs
-	 */
-	public function getAllStoragesForUser() {
-		if (is_null($this->getUser())) {
-			return [];
-		}
-		$groupIds = $this->groupManager->getUserGroupIds($this->getUser());
-		$mounts = $this->dbConfig->getMountsForUser($this->getUser()->getUID(), $groupIds);
-		$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);
-
-		$storages = array_combine($keys, $configs);
-		return array_filter($storages, [$this, 'validateStorage']);
-	}
+    use UserTrait;
+
+    /** @var IGroupManager */
+    protected $groupManager;
+
+    /**
+     * @param BackendService $backendService
+     * @param DBConfigService $dbConfig
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     * @param IUserMountCache $userMountCache
+     */
+    public function __construct(
+        BackendService $backendService,
+        DBConfigService $dbConfig,
+        IUserSession $userSession,
+        IGroupManager $groupManager,
+        IUserMountCache $userMountCache
+    ) {
+        parent::__construct($backendService, $dbConfig, $userMountCache);
+        $this->userSession = $userSession;
+        $this->groupManager = $groupManager;
+    }
+
+    /**
+     * Replace config hash ID with real IDs, for migrating legacy storages
+     *
+     * @param StorageConfig[] $storages Storages with real IDs
+     * @param StorageConfig[] $storagesWithConfigHash Storages with config hash IDs
+     */
+    protected function setRealStorageIds(array &$storages, array $storagesWithConfigHash) {
+        // as a read-only view, storage IDs don't need to be real
+        foreach ($storagesWithConfigHash as $storage) {
+            $storages[$storage->getId()] = $storage;
+        }
+    }
+
+    protected function readDBConfig() {
+        $userMounts = $this->dbConfig->getAdminMountsFor(DBConfigService::APPLICABLE_TYPE_USER, $this->getUser()->getUID());
+        $globalMounts = $this->dbConfig->getAdminMountsFor(DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        $groups = $this->groupManager->getUserGroupIds($this->getUser());
+        if (is_array($groups) && count($groups) !== 0) {
+            $groupMounts = $this->dbConfig->getAdminMountsForMultiple(DBConfigService::APPLICABLE_TYPE_GROUP, $groups);
+        } else {
+            $groupMounts = [];
+        }
+        return array_merge($userMounts, $groupMounts, $globalMounts);
+    }
+
+    public function addStorage(StorageConfig $newStorage) {
+        throw new \DomainException('UserGlobalStoragesService writing disallowed');
+    }
+
+    public function updateStorage(StorageConfig $updatedStorage) {
+        throw new \DomainException('UserGlobalStoragesService writing disallowed');
+    }
+
+    /**
+     * @param integer $id
+     */
+    public function removeStorage($id) {
+        throw new \DomainException('UserGlobalStoragesService writing disallowed');
+    }
+
+    /**
+     * Get unique storages, in case two are defined with the same mountpoint
+     * Higher priority storages take precedence
+     *
+     * @return StorageConfig[]
+     */
+    public function getUniqueStorages() {
+        $storages = $this->getStorages();
+
+        $storagesByMountpoint = [];
+        foreach ($storages as $storage) {
+            $storagesByMountpoint[$storage->getMountPoint()][] = $storage;
+        }
+
+        $result = [];
+        foreach ($storagesByMountpoint as $storageList) {
+            $storage = array_reduce($storageList, function ($carry, $item) {
+                if (isset($carry)) {
+                    $carryPriorityType = $this->getPriorityType($carry);
+                    $itemPriorityType = $this->getPriorityType($item);
+                    if ($carryPriorityType > $itemPriorityType) {
+                        return $carry;
+                    } elseif ($carryPriorityType === $itemPriorityType) {
+                        if ($carry->getPriority() > $item->getPriority()) {
+                            return $carry;
+                        }
+                    }
+                }
+                return $item;
+            });
+            $result[$storage->getID()] = $storage;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get a priority 'type', where a bigger number means higher priority
+     * user applicable > group applicable > 'all'
+     *
+     * @param StorageConfig $storage
+     * @return int
+     */
+    protected function getPriorityType(StorageConfig $storage) {
+        $applicableUsers = $storage->getApplicableUsers();
+        $applicableGroups = $storage->getApplicableGroups();
+
+        if ($applicableUsers && $applicableUsers[0] !== 'all') {
+            return 2;
+        }
+        if ($applicableGroups) {
+            return 1;
+        }
+        return 0;
+    }
+
+    protected function isApplicable(StorageConfig $config) {
+        $applicableUsers = $config->getApplicableUsers();
+        $applicableGroups = $config->getApplicableGroups();
+
+        if (count($applicableUsers) === 0 && count($applicableGroups) === 0) {
+            return true;
+        }
+        if (in_array($this->getUser()->getUID(), $applicableUsers, true)) {
+            return true;
+        }
+        $groupIds = $this->groupManager->getUserGroupIds($this->getUser());
+        foreach ($groupIds as $groupId) {
+            if (in_array($groupId, $applicableGroups, true)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    /**
+     * Gets all storages for the user, admin, personal, global, etc
+     *
+     * @return StorageConfig[] array of storage configs
+     */
+    public function getAllStoragesForUser() {
+        if (is_null($this->getUser())) {
+            return [];
+        }
+        $groupIds = $this->groupManager->getUserGroupIds($this->getUser());
+        $mounts = $this->dbConfig->getMountsForUser($this->getUser()->getUID(), $groupIds);
+        $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);
+
+        $storages = array_combine($keys, $configs);
+        return array_filter($storages, [$this, 'validateStorage']);
+    }
 }

apps/files_external/lib/Service/BackendService.php

Indentation +245 added lines, -245 removed lines

@@ -35,249 +35,249 @@
  */
 class BackendService {
 
-	/** Visibility constants for VisibilityTrait */
-	const VISIBILITY_NONE = 0;
-	const VISIBILITY_PERSONAL = 1;
-	const VISIBILITY_ADMIN = 2;
-	//const VISIBILITY_ALIENS = 4;
-
-	const VISIBILITY_DEFAULT = 3; // PERSONAL | ADMIN
-
-	/** Priority constants for PriorityTrait */
-	const PRIORITY_DEFAULT = 100;
-
-	/** @var IConfig */
-	protected $config;
-
-	/** @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 = [];
-
-	/**
-	 * @param IConfig $config
-	 */
-	public function __construct(
-		IConfig $config
-	) {
-		$this->config = $config;
-
-		// Load config values
-		if ($this->config->getAppValue('files_external', 'allow_user_mounting', 'yes') !== 'yes') {
-			$this->userMountingAllowed = false;
-		}
-		$this->userMountingBackends = explode(',',
-			$this->config->getAppValue('files_external', '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 loadBackendProviders() {
-		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() {
-		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) {
-			return !($backend->checkDependencies());
-		});
-	}
-
-	/**
-	 * @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
-	}
+    /** Visibility constants for VisibilityTrait */
+    const VISIBILITY_NONE = 0;
+    const VISIBILITY_PERSONAL = 1;
+    const VISIBILITY_ADMIN = 2;
+    //const VISIBILITY_ALIENS = 4;
+
+    const VISIBILITY_DEFAULT = 3; // PERSONAL | ADMIN
+
+    /** Priority constants for PriorityTrait */
+    const PRIORITY_DEFAULT = 100;
+
+    /** @var IConfig */
+    protected $config;
+
+    /** @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 = [];
+
+    /**
+     * @param IConfig $config
+     */
+    public function __construct(
+        IConfig $config
+    ) {
+        $this->config = $config;
+
+        // Load config values
+        if ($this->config->getAppValue('files_external', 'allow_user_mounting', 'yes') !== 'yes') {
+            $this->userMountingAllowed = false;
+        }
+        $this->userMountingBackends = explode(',',
+            $this->config->getAppValue('files_external', '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 loadBackendProviders() {
+        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() {
+        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) {
+            return !($backend->checkDependencies());
+        });
+    }
+
+    /**
+     * @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
+    }
 }

apps/files_external/lib/Service/GlobalStoragesService.php

Indentation +147 added lines, -147 removed lines

@@ -35,151 +35,151 @@
  * Service class to manage global external storages
  */
 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(),
-				\OC_Mount_Config::MOUNT_TYPE_USER,
-				['all']
-			);
-			return;
-		}
-
-		$this->triggerApplicableHooks(
-			$signal,
-			$storage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_USER,
-			$applicableUsers
-		);
-		$this->triggerApplicableHooks(
-			$signal,
-			$storage->getMountPoint(),
-			\OC_Mount_Config::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(),
-				\OC_Mount_Config::MOUNT_TYPE_USER,
-				['all']
-			);
-		}
-
-		// trigger delete for removed users
-		$this->triggerApplicableHooks(
-			Filesystem::signal_delete_mount,
-			$oldStorage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_USER,
-			$userDeletions
-		);
-
-		// trigger delete for removed groups
-		$this->triggerApplicableHooks(
-			Filesystem::signal_delete_mount,
-			$oldStorage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_GROUP,
-			$groupDeletions
-		);
-
-		// and now add the new users
-		$this->triggerApplicableHooks(
-			Filesystem::signal_create_mount,
-			$newStorage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_USER,
-			$userAdditions
-		);
-
-		// and now add the new groups
-		$this->triggerApplicableHooks(
-			Filesystem::signal_create_mount,
-			$newStorage->getMountPoint(),
-			\OC_Mount_Config::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(),
-				\OC_Mount_Config::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 array 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(),
+                \OC_Mount_Config::MOUNT_TYPE_USER,
+                ['all']
+            );
+            return;
+        }
+
+        $this->triggerApplicableHooks(
+            $signal,
+            $storage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_USER,
+            $applicableUsers
+        );
+        $this->triggerApplicableHooks(
+            $signal,
+            $storage->getMountPoint(),
+            \OC_Mount_Config::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(),
+                \OC_Mount_Config::MOUNT_TYPE_USER,
+                ['all']
+            );
+        }
+
+        // trigger delete for removed users
+        $this->triggerApplicableHooks(
+            Filesystem::signal_delete_mount,
+            $oldStorage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_USER,
+            $userDeletions
+        );
+
+        // trigger delete for removed groups
+        $this->triggerApplicableHooks(
+            Filesystem::signal_delete_mount,
+            $oldStorage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_GROUP,
+            $groupDeletions
+        );
+
+        // and now add the new users
+        $this->triggerApplicableHooks(
+            Filesystem::signal_create_mount,
+            $newStorage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_USER,
+            $userAdditions
+        );
+
+        // and now add the new groups
+        $this->triggerApplicableHooks(
+            Filesystem::signal_create_mount,
+            $newStorage->getMountPoint(),
+            \OC_Mount_Config::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(),
+                \OC_Mount_Config::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 array 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/files_external/lib/Service/UserLegacyStoragesService.php

Indentation +22 added lines, -22 removed lines

@@ -29,28 +29,28 @@
  * Read user defined mounts from the legacy mount.json
  */
 class UserLegacyStoragesService extends LegacyStoragesService {
-	/**
-	 * @var IUserSession
-	 */
-	private $userSession;
+    /**
+     * @var IUserSession
+     */
+    private $userSession;
 
-	/**
-	 * @param BackendService $backendService
-	 * @param IUserSession $userSession
-	 */
-	public function __construct(BackendService $backendService, IUserSession $userSession) {
-		$this->backendService = $backendService;
-		$this->userSession = $userSession;
-	}
+    /**
+     * @param BackendService $backendService
+     * @param IUserSession $userSession
+     */
+    public function __construct(BackendService $backendService, IUserSession $userSession) {
+        $this->backendService = $backendService;
+        $this->userSession = $userSession;
+    }
 
-	/**
-	 * Read legacy config data
-	 *
-	 * @return array list of storage configs
-	 */
-	protected function readLegacyConfig() {
-		// read user config
-		$user = $this->userSession->getUser()->getUID();
-		return \OC_Mount_Config::readData($user);
-	}
+    /**
+     * Read legacy config data
+     *
+     * @return array list of storage configs
+     */
+    protected function readLegacyConfig() {
+        // read user config
+        $user = $this->userSession->getUser()->getUID();
+        return \OC_Mount_Config::readData($user);
+    }
 }

apps/files_external/lib/Service/LegacyStoragesService.php

Indentation +175 added lines, -175 removed lines

@@ -30,183 +30,183 @@
  * 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 === \OC_Mount_Config::MOUNT_TYPE_USER) {
-			$applicableUsers = $storageConfig->getApplicableUsers();
-			if ($applicable !== 'all') {
-				$applicableUsers[] = $applicable;
-				$storageConfig->setApplicableUsers($applicableUsers);
-			}
-		} else if ($mountType === \OC_Mount_Config::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 === \OC_Mount_Config::MOUNT_TYPE_USER) {
+            $applicableUsers = $storageConfig->getApplicableUsers();
+            if ($applicable !== 'all') {
+                $applicableUsers[] = $applicable;
+                $storageConfig->setApplicableUsers($applicableUsers);
+            }
+        } else if ($mountType === \OC_Mount_Config::MOUNT_TYPE_GROUP) {
+            $applicableGroups = $storageConfig->getApplicableGroups();
+            $applicableGroups[] = $applicable;
+            $storageConfig->setApplicableGroups($applicableGroups);
+        }
+        return $storageConfig;
+    }
 
-	/**
-	 * Read the external storages 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
-						\OCP\Util::writeLog(
-							'files_external',
-							'Could not parse mount point "' . $rootMountPath . '"',
-							\OCP\Util::ERROR
-						);
-						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'] = \OC_Mount_Config::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 = \OC_Mount_Config::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
-						\OCP\Util::writeLog(
-							'files_external',
-							'Could not load storage: "' . $e->getMessage() . '"',
-							\OCP\Util::ERROR
-						);
-					}
-				}
-			}
-		}
+    /**
+     * Read the external storages 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
+                        \OCP\Util::writeLog(
+                            'files_external',
+                            'Could not parse mount point "' . $rootMountPath . '"',
+                            \OCP\Util::ERROR
+                        );
+                        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'] = \OC_Mount_Config::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 = \OC_Mount_Config::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
+                        \OCP\Util::writeLog(
+                            'files_external',
+                            'Could not load storage: "' . $e->getMessage() . '"',
+                            \OCP\Util::ERROR
+                        );
+                    }
+                }
+            }
+        }
 
-		// 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/UserTrait.php

Indentation +37 added lines, -37 removed lines

@@ -30,46 +30,46 @@
  */
 trait UserTrait {
 
-	/** @var IUserSession */
-	protected $userSession;
+    /** @var IUserSession */
+    protected $userSession;
 
-	/**
-	 * User override
-	 *
-	 * @var IUser|null
-	 */
-	private $user = null;
+    /**
+     * User override
+     *
+     * @var IUser|null
+     */
+    private $user = null;
 
-	/**
-	 * @return IUser|null
-	 */
-	protected function getUser() {
-		if ($this->user) {
-			return $this->user;
-		}
-		return $this->userSession->getUser();
-	}
+    /**
+     * @return IUser|null
+     */
+    protected function getUser() {
+        if ($this->user) {
+            return $this->user;
+        }
+        return $this->userSession->getUser();
+    }
 
-	/**
-	 * Override the user from the session
-	 * Unset with ->resetUser() when finished!
-	 *
-	 * @param IUser
-	 * @return self
-	 */
-	public function setUser(IUser $user) {
-		$this->user = $user;
-		return $this;
-	}
+    /**
+     * Override the user from the session
+     * Unset with ->resetUser() when finished!
+     *
+     * @param IUser
+     * @return self
+     */
+    public function setUser(IUser $user) {
+        $this->user = $user;
+        return $this;
+    }
 
-	/**
-	 * Reset the user override
-	 *
-	 * @return self
-	 */
-	public function resetUser() {
-		$this->user = null;
-		return $this;
-	}
+    /**
+     * Reset the user override
+     *
+     * @return self
+     */
+    public function resetUser() {
+        $this->user = null;
+        return $this;
+    }
 }
 

apps/files_external/lib/Service/UserStoragesService.php

Indentation +91 added lines, -91 removed lines

@@ -40,105 +40,105 @@
  * (aka personal storages)
  */
 class UserStoragesService extends StoragesService {
-	use UserTrait;
+    use UserTrait;
 
-	/**
-	 * Create a user storages service
-	 *
-	 * @param BackendService $backendService
-	 * @param DBConfigService $dbConfig
-	 * @param IUserSession $userSession user session
-	 * @param IUserMountCache $userMountCache
-	 */
-	public function __construct(
-		BackendService $backendService,
-		DBConfigService $dbConfig,
-		IUserSession $userSession,
-		IUserMountCache $userMountCache
-	) {
-		$this->userSession = $userSession;
-		parent::__construct($backendService, $dbConfig, $userMountCache);
-	}
+    /**
+     * Create a user storages service
+     *
+     * @param BackendService $backendService
+     * @param DBConfigService $dbConfig
+     * @param IUserSession $userSession user session
+     * @param IUserMountCache $userMountCache
+     */
+    public function __construct(
+        BackendService $backendService,
+        DBConfigService $dbConfig,
+        IUserSession $userSession,
+        IUserMountCache $userMountCache
+    ) {
+        $this->userSession = $userSession;
+        parent::__construct($backendService, $dbConfig, $userMountCache);
+    }
 
-	protected function readDBConfig() {
-		return $this->dbConfig->getUserMountsFor(DBConfigService::APPLICABLE_TYPE_USER, $this->getUser()->getUID());
-	}
+    protected function readDBConfig() {
+        return $this->dbConfig->getUserMountsFor(DBConfigService::APPLICABLE_TYPE_USER, $this->getUser()->getUID());
+    }
 
-	/**
-	 * 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) {
-		$user = $this->getUser()->getUID();
+    /**
+     * 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) {
+        $user = $this->getUser()->getUID();
 
-		// trigger hook for the current user
-		$this->triggerApplicableHooks(
-			$signal,
-			$storage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_USER,
-			[$user]
-		);
-	}
+        // trigger hook for the current user
+        $this->triggerApplicableHooks(
+            $signal,
+            $storage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_USER,
+            [$user]
+        );
+    }
 
-	/**
-	 * 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
-	 */
-	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);
-		}
-	}
+    /**
+     * 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
+     */
+    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);
+        }
+    }
 
-	protected function getType() {
-		return DBConfigService::MOUNT_TYPE_PERSONAl;
-	}
+    protected function getType() {
+        return DBConfigService::MOUNT_TYPE_PERSONAl;
+    }
 
-	/**
-	 * Add new storage to the configuration
-	 *
-	 * @param StorageConfig $newStorage storage attributes
-	 *
-	 * @return StorageConfig storage config, with added id
-	 */
-	public function addStorage(StorageConfig $newStorage) {
-		$newStorage->setApplicableUsers([$this->getUser()->getUID()]);
-		$config = parent::addStorage($newStorage);
-		return $config;
-	}
+    /**
+     * Add new storage to the configuration
+     *
+     * @param StorageConfig $newStorage storage attributes
+     *
+     * @return StorageConfig storage config, with added id
+     */
+    public function addStorage(StorageConfig $newStorage) {
+        $newStorage->setApplicableUsers([$this->getUser()->getUID()]);
+        $config = parent::addStorage($newStorage);
+        return $config;
+    }
 
-	/**
-	 * 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) {
-		$updatedStorage->setApplicableUsers([$this->getUser()->getUID()]);
-		return parent::updateStorage($updatedStorage);
-	}
+    /**
+     * 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) {
+        $updatedStorage->setApplicableUsers([$this->getUser()->getUID()]);
+        return parent::updateStorage($updatedStorage);
+    }
 
-	/**
-	 * Get the visibility type for this controller, used in validation
-	 *
-	 * @return string BackendService::VISIBILITY_* constants
-	 */
-	public function getVisibilityType() {
-		return BackendService::VISIBILITY_PERSONAL;
-	}
+    /**
+     * Get the visibility type for this controller, used in validation
+     *
+     * @return string BackendService::VISIBILITY_* constants
+     */
+    public function getVisibilityType() {
+        return BackendService::VISIBILITY_PERSONAL;
+    }
 
-	protected function isApplicable(StorageConfig $config) {
-		return ($config->getApplicableUsers() === [$this->getUser()->getUID()]) && $config->getType() === StorageConfig::MOUNT_TYPE_PERSONAl;
-	}
+    protected function isApplicable(StorageConfig $config) {
+        return ($config->getApplicableUsers() === [$this->getUser()->getUID()]) && $config->getType() === StorageConfig::MOUNT_TYPE_PERSONAl;
+    }
 }

apps/files_external/lib/Config/ConfigAdapter.php

Indentation +139 added lines, -139 removed lines

@@ -45,143 +45,143 @@
  */
 class ConfigAdapter implements IMountProvider {
 
-	/** @var UserStoragesService */
-	private $userStoragesService;
-
-	/** @var UserGlobalStoragesService */
-	private $userGlobalStoragesService;
-	/** @var StorageMigrator  */
-	private $migrator;
-
-	/**
-	 * @param UserStoragesService $userStoragesService
-	 * @param UserGlobalStoragesService $userGlobalStoragesService
-	 * @param StorageMigrator $migrator
-	 */
-	public function __construct(
-		UserStoragesService $userStoragesService,
-		UserGlobalStoragesService $userGlobalStoragesService,
-		StorageMigrator $migrator
-	) {
-		$this->userStoragesService = $userStoragesService;
-		$this->userGlobalStoragesService = $userGlobalStoragesService;
-		$this->migrator = $migrator;
-	}
-
-	/**
-	 * Process storage ready for mounting
-	 *
-	 * @param StorageConfig $storage
-	 * @param IUser $user
-	 */
-	private function prepareStorageConfig(StorageConfig &$storage, IUser $user) {
-		foreach ($storage->getBackendOptions() as $option => $value) {
-			$storage->setBackendOption($option, \OC_Mount_Config::setUserVars(
-				$user->getUID(), $value
-			));
-		}
-
-		$objectStore = $storage->getBackendOption('objectstore');
-		if ($objectStore) {
-			$objectClass = $objectStore['class'];
-			if (!is_subclass_of($objectClass, '\OCP\Files\ObjectStore\IObjectStore')) {
-				throw new \InvalidArgumentException('Invalid object store');
-			}
-			$storage->setBackendOption('objectstore', new $objectClass($objectStore));
-		}
-
-		$storage->getAuthMechanism()->manipulateStorageConfig($storage, $user);
-		$storage->getBackend()->manipulateStorageConfig($storage, $user);
-	}
-
-	/**
-	 * Construct the storage implementation
-	 *
-	 * @param StorageConfig $storageConfig
-	 * @return Storage
-	 */
-	private function constructStorage(StorageConfig $storageConfig) {
-		$class = $storageConfig->getBackend()->getStorageClass();
-		$storage = new $class($storageConfig->getBackendOptions());
-
-		// auth mechanism should fire first
-		$storage = $storageConfig->getBackend()->wrapStorage($storage);
-		$storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
-
-		return $storage;
-	}
-
-	/**
-	 * Get all mountpoints applicable for the user
-	 *
-	 * @param \OCP\IUser $user
-	 * @param \OCP\Files\Storage\IStorageFactory $loader
-	 * @return \OCP\Files\Mount\IMountPoint[]
-	 */
-	public function getMountsForUser(IUser $user, IStorageFactory $loader) {
-		$this->migrator->migrateUser($user);
-
-		$this->userStoragesService->setUser($user);
-		$this->userGlobalStoragesService->setUser($user);
-
-		$storageConfigs = $this->userGlobalStoragesService->getAllStoragesForUser();
-
-		$storages = array_map(function(StorageConfig $storageConfig) use ($user) {
-			try {
-				$this->prepareStorageConfig($storageConfig, $user);
-				return $this->constructStorage($storageConfig);
-			} catch (\Exception $e) {
-				// propagate exception into filesystem
-				return new FailedStorage(['exception' => $e]);
-			}
-		}, $storageConfigs);
-
-
-		\OC\Files\Cache\Storage::getGlobalCache()->loadForStorageIds(array_map(function(Storage\IStorage $storage) {
-			return $storage->getId();
-		}, $storages));
-
-		$availableStorages = array_map(function (Storage\IStorage $storage, StorageConfig $storageConfig) {
-			try {
-				$availability = $storage->getAvailability();
-				if (!$availability['available'] && !Availability::shouldRecheck($availability)) {
-					$storage = new FailedStorage([
-						'exception' => new StorageNotAvailableException('Storage with mount id ' . $storageConfig->getId() . ' is not available')
-					]);
-				}
-			} catch (\Exception $e) {
-				// propagate exception into filesystem
-				$storage = new FailedStorage(['exception' => $e]);
-			}
-			return $storage;
-		}, $storages, $storageConfigs);
-
-		$mounts = array_map(function(StorageConfig $storageConfig, Storage\IStorage $storage) use ($user, $loader) {
-			if ($storageConfig->getType() === StorageConfig::MOUNT_TYPE_PERSONAl) {
-				return new PersonalMount(
-					$this->userStoragesService,
-					$storageConfig->getId(),
-					$storage,
-					'/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
-					null,
-					$loader,
-					$storageConfig->getMountOptions()
-				);
-			} else {
-				return new MountPoint(
-					$storage,
-					'/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
-					null,
-					$loader,
-					$storageConfig->getMountOptions(),
-					$storageConfig->getId()
-				);
-			}
-		}, $storageConfigs, $availableStorages);
-
-		$this->userStoragesService->resetUser();
-		$this->userGlobalStoragesService->resetUser();
-
-		return $mounts;
-	}
+    /** @var UserStoragesService */
+    private $userStoragesService;
+
+    /** @var UserGlobalStoragesService */
+    private $userGlobalStoragesService;
+    /** @var StorageMigrator  */
+    private $migrator;
+
+    /**
+     * @param UserStoragesService $userStoragesService
+     * @param UserGlobalStoragesService $userGlobalStoragesService
+     * @param StorageMigrator $migrator
+     */
+    public function __construct(
+        UserStoragesService $userStoragesService,
+        UserGlobalStoragesService $userGlobalStoragesService,
+        StorageMigrator $migrator
+    ) {
+        $this->userStoragesService = $userStoragesService;
+        $this->userGlobalStoragesService = $userGlobalStoragesService;
+        $this->migrator = $migrator;
+    }
+
+    /**
+     * Process storage ready for mounting
+     *
+     * @param StorageConfig $storage
+     * @param IUser $user
+     */
+    private function prepareStorageConfig(StorageConfig &$storage, IUser $user) {
+        foreach ($storage->getBackendOptions() as $option => $value) {
+            $storage->setBackendOption($option, \OC_Mount_Config::setUserVars(
+                $user->getUID(), $value
+            ));
+        }
+
+        $objectStore = $storage->getBackendOption('objectstore');
+        if ($objectStore) {
+            $objectClass = $objectStore['class'];
+            if (!is_subclass_of($objectClass, '\OCP\Files\ObjectStore\IObjectStore')) {
+                throw new \InvalidArgumentException('Invalid object store');
+            }
+            $storage->setBackendOption('objectstore', new $objectClass($objectStore));
+        }
+
+        $storage->getAuthMechanism()->manipulateStorageConfig($storage, $user);
+        $storage->getBackend()->manipulateStorageConfig($storage, $user);
+    }
+
+    /**
+     * Construct the storage implementation
+     *
+     * @param StorageConfig $storageConfig
+     * @return Storage
+     */
+    private function constructStorage(StorageConfig $storageConfig) {
+        $class = $storageConfig->getBackend()->getStorageClass();
+        $storage = new $class($storageConfig->getBackendOptions());
+
+        // auth mechanism should fire first
+        $storage = $storageConfig->getBackend()->wrapStorage($storage);
+        $storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
+
+        return $storage;
+    }
+
+    /**
+     * Get all mountpoints applicable for the user
+     *
+     * @param \OCP\IUser $user
+     * @param \OCP\Files\Storage\IStorageFactory $loader
+     * @return \OCP\Files\Mount\IMountPoint[]
+     */
+    public function getMountsForUser(IUser $user, IStorageFactory $loader) {
+        $this->migrator->migrateUser($user);
+
+        $this->userStoragesService->setUser($user);
+        $this->userGlobalStoragesService->setUser($user);
+
+        $storageConfigs = $this->userGlobalStoragesService->getAllStoragesForUser();
+
+        $storages = array_map(function(StorageConfig $storageConfig) use ($user) {
+            try {
+                $this->prepareStorageConfig($storageConfig, $user);
+                return $this->constructStorage($storageConfig);
+            } catch (\Exception $e) {
+                // propagate exception into filesystem
+                return new FailedStorage(['exception' => $e]);
+            }
+        }, $storageConfigs);
+
+
+        \OC\Files\Cache\Storage::getGlobalCache()->loadForStorageIds(array_map(function(Storage\IStorage $storage) {
+            return $storage->getId();
+        }, $storages));
+
+        $availableStorages = array_map(function (Storage\IStorage $storage, StorageConfig $storageConfig) {
+            try {
+                $availability = $storage->getAvailability();
+                if (!$availability['available'] && !Availability::shouldRecheck($availability)) {
+                    $storage = new FailedStorage([
+                        'exception' => new StorageNotAvailableException('Storage with mount id ' . $storageConfig->getId() . ' is not available')
+                    ]);
+                }
+            } catch (\Exception $e) {
+                // propagate exception into filesystem
+                $storage = new FailedStorage(['exception' => $e]);
+            }
+            return $storage;
+        }, $storages, $storageConfigs);
+
+        $mounts = array_map(function(StorageConfig $storageConfig, Storage\IStorage $storage) use ($user, $loader) {
+            if ($storageConfig->getType() === StorageConfig::MOUNT_TYPE_PERSONAl) {
+                return new PersonalMount(
+                    $this->userStoragesService,
+                    $storageConfig->getId(),
+                    $storage,
+                    '/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
+                    null,
+                    $loader,
+                    $storageConfig->getMountOptions()
+                );
+            } else {
+                return new MountPoint(
+                    $storage,
+                    '/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
+                    null,
+                    $loader,
+                    $storageConfig->getMountOptions(),
+                    $storageConfig->getId()
+                );
+            }
+        }, $storageConfigs, $availableStorages);
+
+        $this->userStoragesService->resetUser();
+        $this->userGlobalStoragesService->resetUser();
+
+        return $mounts;
+    }
 }