protected function manipulateStorageConfig(StorageConfig $storage) { /** @var AuthMechanism */ $authMechanism = $storage->getAuthMechanism(); $authMechanism->manipulateStorageConfig($storage, $this->userSession->getUser()); /** @var Backend */ $backend = $storage->getBackend(); $backend->manipulateStorageConfig($storage, $this->userSession->getUser()); }
/** * 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; }
private function manipulateStorageConfig(StorageConfig $storage) { /** @var AuthMechanism */ $authMechanism = $storage->getAuthMechanism(); $authMechanism->manipulateStorageConfig($storage); /** @var Backend */ $backend = $storage->getBackend(); $backend->manipulateStorageConfig($storage); }
/** * Convert a StorageConfig to the legacy mountPoints array format * There's a lot of extra information in here, to satisfy all of the legacy functions * * @param StorageConfig $storage * @param bool $isPersonal * @return array */ private static function prepareMountPointEntry(StorageConfig $storage, $isPersonal) { $mountEntry = []; $mountEntry['mountpoint'] = substr($storage->getMountPoint(), 1); // remove leading slash $mountEntry['class'] = $storage->getBackend()->getIdentifier(); $mountEntry['backend'] = $storage->getBackend()->getText(); $mountEntry['authMechanism'] = $storage->getAuthMechanism()->getIdentifier(); $mountEntry['personal'] = $isPersonal; $mountEntry['options'] = self::decryptPasswords($storage->getBackendOptions()); $mountEntry['mountOptions'] = $storage->getMountOptions(); $mountEntry['priority'] = $storage->getPriority(); $mountEntry['applicable'] = ['groups' => $storage->getApplicableGroups(), 'users' => $storage->getApplicableUsers()]; // if mountpoint is applicable to all users the old API expects ['all'] if (empty($mountEntry['applicable']['groups']) && empty($mountEntry['applicable']['users'])) { $mountEntry['applicable']['users'] = ['all']; } $mountEntry['id'] = $storage->getId(); return $mountEntry; }
/** * 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; }
/** * 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; }
/** * 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; } }
/** * Check whether the given storage is available / valid. * * Note that this operation can be time consuming depending * on whether the remote storage is available or not. * * @param StorageConfig $storage storage configuration */ protected function updateStorageStatus(StorageConfig &$storage) { try { /** @var AuthMechanism */ $authMechanism = $storage->getAuthMechanism(); $authMechanism->manipulateStorageConfig($storage); /** @var Backend */ $backend = $storage->getBackend(); $backend->manipulateStorageConfig($storage); // update status (can be time-consuming) $storage->setStatus(\OC_Mount_Config::getBackendStatus($backend->getStorageClass(), $storage->getBackendOptions(), false)); } catch (InsufficientDataForMeaningfulAnswerException $e) { $storage->setStatus(\OC_Mount_Config::STATUS_INDETERMINATE, $this->l10n->t('Insufficient data: %s', [$e->getMessage()])); } catch (StorageNotAvailableException $e) { $storage->setStatus(\OC_Mount_Config::STATUS_ERROR, $e->getMessage()); } catch (\Exception $e) { // FIXME: convert storage exceptions to StorageNotAvailableException $storage->setStatus(\OC_Mount_Config::STATUS_ERROR, get_class($e) . ': ' . $e->getMessage()); } }
/** * Remove sensitive data from a StorageConfig before returning it to the user * * @param StorageConfig $storage */ protected function sanitizeStorage(StorageConfig $storage) { $storage->setBackendOptions([]); $storage->setMountOptions([]); if ($storage->getAuthMechanism() instanceof IUserProvided) { try { $storage->getAuthMechanism()->manipulateStorageConfig($storage, $this->userSession->getUser()); } catch (InsufficientDataForMeaningfulAnswerException $e) { // not configured yet } } }
/** * 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); $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($oldStorage->getApplicableUsers()); $newGroupCount = count($oldStorage->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); } else { if (!$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) { $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); return $this->getStorage($id); }
/** * Convert a StorageConfig to the legacy mountPoints array format * There's a lot of extra information in here, to satisfy all of the legacy functions * * @param StorageConfig $storage * @param bool $isPersonal * @return array */ private static function prepareMountPointEntry(StorageConfig $storage, $isPersonal) { $mountEntry = []; $mountEntry['mountpoint'] = substr($storage->getMountPoint(), 1); // remove leading slash $mountEntry['class'] = $storage->getBackend()->getIdentifier(); $mountEntry['backend'] = $storage->getBackend()->getText(); $mountEntry['authMechanism'] = $storage->getAuthMechanism()->getIdentifier(); $mountEntry['personal'] = $isPersonal; $mountEntry['options'] = self::decryptPasswords($storage->getBackendOptions()); $mountEntry['mountOptions'] = $storage->getMountOptions(); $mountEntry['priority'] = $storage->getPriority(); $mountEntry['applicable'] = ['groups' => $storage->getApplicableGroups(), 'users' => $storage->getApplicableUsers()]; $mountEntry['id'] = $storage->getId(); // $mountEntry['storage_id'] = null; // we don't store this! return $mountEntry; }
/** * Check whether the given storage is available / valid. * * Note that this operation can be time consuming depending * on whether the remote storage is available or not. * * @param StorageConfig $storage storage configuration */ protected function updateStorageStatus(StorageConfig &$storage) { try { /** @var AuthMechanism */ $authMechanism = $storage->getAuthMechanism(); $authMechanism->manipulateStorageConfig($storage); /** @var Backend */ $backend = $storage->getBackend(); $backend->manipulateStorageConfig($storage); // update status (can be time-consuming) $storage->setStatus(\OC_Mount_Config::getBackendStatus($backend->getStorageClass(), $storage->getBackendOptions(), false)); } catch (InsufficientDataForMeaningfulAnswerException $e) { $storage->setStatus(\OC_Mount_Config::STATUS_INDETERMINATE); } catch (StorageNotAvailableException $e) { $storage->setStatus(\OC_Mount_Config::STATUS_ERROR); } }