370 lines
8.8 KiB
PHP
370 lines
8.8 KiB
PHP
<?php
|
|
|
|
namespace Friendica\Addon\webdav_storage\src;
|
|
|
|
use Exception;
|
|
use Friendica\Core\Config\IConfig;
|
|
use Friendica\Core\L10n;
|
|
use Friendica\Model\Storage\IWritableStorage;
|
|
use Friendica\Model\Storage\ReferenceStorageException;
|
|
use Friendica\Model\Storage\StorageException;
|
|
use Friendica\Network\HTTPClientOptions;
|
|
use Friendica\Network\IHTTPClient;
|
|
use Friendica\Util\Strings;
|
|
use Psr\Log\LoggerInterface;
|
|
|
|
/**
|
|
* A WebDav Backend Storage class
|
|
*/
|
|
class WebDav implements IWritableStorage
|
|
{
|
|
const NAME = 'WebDav';
|
|
|
|
/** @var L10n */
|
|
private $l10n;
|
|
|
|
/** @var IConfig */
|
|
private $config;
|
|
|
|
/** @var string */
|
|
private $url;
|
|
|
|
/** @var IHTTPClient */
|
|
private $client;
|
|
|
|
/** @var LoggerInterface */
|
|
private $logger;
|
|
|
|
/** @var array */
|
|
private $authOptions;
|
|
|
|
public function __construct(L10n $l10n, IConfig $config, IHTTPClient $client, LoggerInterface $logger)
|
|
{
|
|
$this->l10n = $l10n;
|
|
$this->config = $config;
|
|
$this->client = $client;
|
|
$this->logger = $logger;
|
|
|
|
$this->authOptions = null;
|
|
|
|
if (!empty($this->config->get('webdav', 'username'))) {
|
|
$this->authOptions = [
|
|
$this->config->get('webdav', 'username'),
|
|
(string)$this->config->get('webdav', 'password', ''),
|
|
$this->config->get('webdav', 'auth_type', 'basic')
|
|
];
|
|
}
|
|
|
|
$this->url = $this->config->get('webdav', 'url');
|
|
}
|
|
|
|
|
|
/**
|
|
* Split data ref and return file path
|
|
*
|
|
* @param string $reference Data reference
|
|
*
|
|
* @return string[]
|
|
*/
|
|
private function pathForRef(string $reference): array
|
|
{
|
|
$fold1 = substr($reference, 0, 2);
|
|
$fold2 = substr($reference, 2, 2);
|
|
$file = substr($reference, 4);
|
|
|
|
return [$this->encodePath(implode('/', [$fold1, $fold2, $file])), implode('/', [$fold1, $fold2]), $file];
|
|
}
|
|
|
|
/**
|
|
* URL encodes the given path but keeps the slashes
|
|
*
|
|
* @param string $path to encode
|
|
*
|
|
* @return string encoded path
|
|
*/
|
|
protected function encodePath(string $path): string
|
|
{
|
|
// slashes need to stay
|
|
return str_replace('%2F', '/', rawurlencode($path));
|
|
}
|
|
|
|
/**
|
|
* Checks if the URL exists
|
|
*
|
|
* @param string $uri the URL to check
|
|
*
|
|
* @return bool true in case the file/folder exists
|
|
*/
|
|
protected function exists(string $uri): bool
|
|
{
|
|
return $this->client->head($uri, [HTTPClientOptions::AUTH => $this->authOptions])->getReturnCode() == 200;
|
|
}
|
|
|
|
/**
|
|
* Checks if a folder has items left
|
|
*
|
|
* @param string $uri the URL to check
|
|
*
|
|
* @return bool true in case there are items left in the folder
|
|
*/
|
|
protected function hasItems(string $uri): bool
|
|
{
|
|
$dom = new \DOMDocument('1.0', 'UTF-8');
|
|
$dom->formatOutput = true;
|
|
$root = $dom->createElementNS('DAV:', 'd:propfind');
|
|
$prop = $dom->createElement('d:allprop');
|
|
|
|
$dom->appendChild($root)->appendChild($prop);
|
|
|
|
$opts = [
|
|
HTTPClientOptions::AUTH => $this->authOptions,
|
|
HTTPClientOptions::HEADERS => ['Depth' => 1, 'Prefer' => 'return-minimal', 'Content-Type' => 'application/xml'],
|
|
HTTPClientOptions::BODY => $dom->saveXML(),
|
|
];
|
|
|
|
$response = $this->client->request('propfind', $uri, $opts);
|
|
|
|
$responseDoc = new \DOMDocument();
|
|
$responseDoc->loadXML($response->getBody());
|
|
$responseDoc->formatOutput = true;
|
|
|
|
$xpath = new \DOMXPath($responseDoc);
|
|
$xpath->registerNamespace('d', 'DAV');
|
|
$result = $xpath->query('//d:multistatus/d:response');
|
|
|
|
// returns at least its own directory, so >1
|
|
return $result !== false && count($result) > 1;
|
|
}
|
|
|
|
/**
|
|
* Creates a DAV-collection (= folder) for the given uri
|
|
*
|
|
* @param string $uri The uri for creating a DAV-collection
|
|
*
|
|
* @return bool true in case the creation was successful (not immutable!)
|
|
*/
|
|
protected function mkcol(string $uri): bool
|
|
{
|
|
return $this->client->request('mkcol', $uri, [HTTPClientOptions::AUTH => $this->authOptions])
|
|
->getReturnCode() == 200;
|
|
}
|
|
|
|
/**
|
|
* Checks if the given path exists and if not creates it
|
|
*
|
|
* @param string $fullPath the full path (the folder structure after the hostname)
|
|
*/
|
|
protected function checkAndCreatePath(string $fullPath): void
|
|
{
|
|
$finalUrl = $this->url . '/' . trim($fullPath, '/');
|
|
|
|
if ($this->exists($finalUrl)) {
|
|
return;
|
|
}
|
|
|
|
$pathParts = explode('/', trim($fullPath, '/'));
|
|
$path = '';
|
|
|
|
foreach ($pathParts as $part) {
|
|
$path .= '/' . $part;
|
|
$partUrl = $this->url . $path;
|
|
if (!$this->exists($partUrl)) {
|
|
$this->mkcol($partUrl);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks recursively, if paths are empty and deletes them
|
|
*
|
|
* @param string $fullPath the full path (the folder structure after the hostname)
|
|
*
|
|
* @throws StorageException In case a directory cannot get deleted
|
|
*/
|
|
protected function checkAndDeletePath(string $fullPath): void
|
|
{
|
|
$pathParts = explode('/', trim($fullPath, '/'));
|
|
$partURL = '/' . implode('/', $pathParts);
|
|
|
|
foreach ($pathParts as $pathPart) {
|
|
$checkUrl = $this->url . $partURL;
|
|
if (!empty($partURL) && !$this->hasItems($checkUrl)) {
|
|
$response = $this->client->request('delete', $checkUrl, [HTTPClientOptions::AUTH => $this->authOptions]);
|
|
|
|
if (!$response->isSuccess()) {
|
|
if ($response->getReturnCode() == "404") {
|
|
$this->logger->warning('Directory already deleted.', ['uri' => $checkUrl]);
|
|
} else {
|
|
throw new StorageException(sprintf('Unpredicted error for %s: %s', $checkUrl, $response->getError()), $response->getReturnCode());
|
|
}
|
|
}
|
|
}
|
|
|
|
$partURL = substr($partURL, 0, -strlen('/' . $pathPart));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public function get(string $reference): string
|
|
{
|
|
$file = $this->pathForRef($reference);
|
|
|
|
$response = $this->client->request('get', $this->url . '/' . $file[0], [HTTPClientOptions::AUTH => $this->authOptions]);
|
|
|
|
if (!$response->isSuccess()) {
|
|
throw new ReferenceStorageException(sprintf('Invalid reference %s', $reference));
|
|
}
|
|
|
|
return $response->getBody();
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public function put(string $data, string $reference = ""): string
|
|
{
|
|
if ($reference === '') {
|
|
try {
|
|
$reference = Strings::getRandomHex();
|
|
} catch (Exception $exception) {
|
|
throw new StorageException('Webdav storage failed to generate a random hex', $exception->getCode(), $exception);
|
|
}
|
|
}
|
|
$file = $this->pathForRef($reference);
|
|
|
|
$this->checkAndCreatePath($file[1]);
|
|
|
|
$opts = [
|
|
HTTPClientOptions::BODY => $data,
|
|
HTTPClientOptions::AUTH => $this->authOptions,
|
|
];
|
|
|
|
$this->client->request('put', $this->url . '/' . $file[0], $opts);
|
|
|
|
return $reference;
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public function delete(string $reference)
|
|
{
|
|
$file = $this->pathForRef($reference);
|
|
|
|
$response = $this->client->request('delete', $this->url . '/' . $file[0], [HTTPClientOptions::AUTH => $this->authOptions]);
|
|
|
|
if (!$response->isSuccess()) {
|
|
throw new ReferenceStorageException(sprintf('Invalid reference %s', $reference));
|
|
}
|
|
|
|
$this->checkAndDeletePath($file[1]);
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function getOptions(): array
|
|
{
|
|
$auths = [
|
|
'' => 'None',
|
|
'basic' => 'Basic',
|
|
'digest' => 'Digest',
|
|
];
|
|
|
|
return [
|
|
'url' => [
|
|
'input',
|
|
$this->l10n->t('URL'),
|
|
$this->url,
|
|
$this->l10n->t('URL to the Webdav endpoint, where files can be saved'),
|
|
true
|
|
],
|
|
'username' => [
|
|
'input',
|
|
$this->l10n->t('Username'),
|
|
$this->config->get('webdav', 'username', ''),
|
|
$this->l10n->t('Username to authenticate to the Webdav endpoint')
|
|
],
|
|
'password' => [
|
|
'password',
|
|
$this->l10n->t('Password'),
|
|
$this->config->get('webdav', 'username', ''),
|
|
$this->l10n->t('Password to authenticate to the Webdav endpoint')
|
|
],
|
|
'auth_type' => [
|
|
'select',
|
|
$this->l10n->t('Authentication type'),
|
|
$this->config->get('webdav', 'auth_type', ''),
|
|
$this->l10n->t('authentication type to the Webdav endpoint'),
|
|
$auths,
|
|
]
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function saveOptions(array $data): array
|
|
{
|
|
$url = $data['url'] ?? '';
|
|
$username = $data['username'] ?? '';
|
|
$password = $data['password'] ?? '';
|
|
|
|
$auths = [
|
|
'' => 'None',
|
|
'basic' => 'Basic',
|
|
'digest' => 'Digest',
|
|
];
|
|
|
|
$authType = $data['auth_type'] ?? '';
|
|
if (!key_exists($authType, $auths)) {
|
|
return [
|
|
'auth_type' => $this->l10n->t('Authentication type is invalid.'),
|
|
];
|
|
}
|
|
|
|
$options = null;
|
|
|
|
if (!empty($username)) {
|
|
$options = [
|
|
$username,
|
|
$password,
|
|
$authType
|
|
];
|
|
}
|
|
|
|
if (!$this->client->head($url, [HTTPClientOptions::AUTH => $options])->isSuccess()) {
|
|
return [
|
|
'url' => $this->l10n->t('url is either invalid or not reachable'),
|
|
];
|
|
}
|
|
|
|
$this->config->set('webdav', 'url', $url);
|
|
$this->config->set('webdav', 'username', $username);
|
|
$this->config->set('webdav', 'password', $password);
|
|
$this->config->set('webdav', 'auth_type', $authType);
|
|
|
|
$this->url = $url;
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public function __toString()
|
|
{
|
|
return self::getName();
|
|
}
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
public static function getName(): string
|
|
{
|
|
return self::NAME;
|
|
}
|
|
}
|