def sync_from_webdav(url, username, password):
client = Client({
"webdav_hostname": url,
"webdav_login": username,
"webdav_password": password,
"webdav_root": ROOT_DIR,
})
try:
logger.info(f"Sync files from {url}{ROOT_DIR}{SYNC_DIR}")
# download files to temporary directory to avoid `/opt/gluu/jetty/oxauth/custom`
# getting deleted
client.download(SYNC_DIR, TMP_DIR)
# copy all downloaded files to /opt/gluu/jetty/oxauth/custom
for subdir, _, files in os.walk(TMP_DIR):
for file_ in files:
src = os.path.join(subdir, file_)
dest = src.replace(TMP_DIR, SYNC_DIR)
if not os.path.exists(os.path.dirname(dest)):
os.makedirs(os.path.dirname(dest))
# logger.info(f"Copying {src} to {dest}")
shutil.copyfile(src, dest)
except (RemoteResourceNotFound, NoConnection) as exc:
logger.warning(
f"Unable to sync files from {url}{ROOT_DIR}{SYNC_DIR}; reason={exc}"
)
class webDavService:
def __init__(self):
self.conf = config()
log = logger()
self.path = os.path.dirname(os.path.realpath(sys.argv[0]))
self.confwebdav = log.getlogger('webdav')
self.options = {}
self.client = None
def loadBaseInfo(self):
url = self.conf.decrypt(self.conf.getOption('webDav', 'url'))
if url.endswith("/"):
url = url[0:-1]
self.options = {
'webdav_hostname': url,
'webdav_login': self.conf.decrypt(self.conf.getOption('webDav', 'username')),
'webdav_password': self.conf.decrypt(self.conf.getOption('webDav', 'password')),
# 'webdav_root': '/dav/',
'disable_check': True,
}
self.client = Client(self.options)
def creatDir(self):
try:
self.client.mkdir("tomato_db")
except Exception as e:
self.confwebdav.error(e)
pass
def clean(self):
try:
self.client.clean("tomato_db/tomato.db")
except Exception as e:
self.confwebdav.error(e)
pass
def upload(self, file):
try:
self.loadBaseInfo()
self.creatDir()
self.clean()
self.client.upload(remote_path="tomato_db/tomato.db",
local_path=self.path + file)
except Exception as e:
self.confwebdav.error(e)
pass
def download(self, file):
try:
self.loadBaseInfo()
self.client.download(remote_path="tomato_db/tomato.db",
local_path=self.path + file)
except Exception as e:
self.confwebdav.error(e)
pass
def fetch(options=options):
client = Client(options)
if not client.check("/server"):
client.mkdir("/server")
lst=client.list("/server")[1::]
cnt=0
for i in lst:
cnt+=1
print("Index:",cnt," Time:",parse_time(i))
index=int(input("Please select the file you want to restore:"))%len(lst)
client.download("/server/"+lst[index-1],"./dat/")
print(parse_time(lst[index-1]),"has been restored")
def fetch(options=options):
client = Client(options)
if not client.check("/blocks"):
client.mkdir("/blocks")
lst = client.list("/blocks")[1::]
cnt = 0
for i in lst:
cnt += 1
print("Index:", cnt, i)
index = int(
input("Please select the block you want to install:")) % len(lst)
client.download("/blocks/" + lst[index - 1], "./blocks/" + lst[index - 1])
# print(parse_time(lst[index-1]),"has been restored")
print(lst[index - 1], "has been installed successfully")
class CardDavImporter:
def __init__(self, web_dav_host, web_dav_login, web_dav_password,
card_dav_path):
self.web_dav_host = web_dav_host
self.web_dav_login = web_dav_login
self.web_dav_password = web_dav_password
self.card_dav_path = card_dav_path
self.client: Client = None
def connect(self):
options = {
'webdav_hostname': self.web_dav_host,
'webdav_login': self.web_dav_login,
'webdav_password': self.web_dav_password,
'webdav_override_methods': {
'check': 'GET'
}
}
self.client = Client(options)
def download_contacts(self):
if not self.client:
raise Exception("You have to connect first")
local_path = os.getcwd() + "/tmp"
if os.path.exists(local_path):
shutil.rmtree(local_path)
os.makedirs(local_path)
for resource_name in self.client.list(self.card_dav_path):
_remote_path = "{parent}/{name}".format(parent=self.card_dav_path,
name=resource_name)
_local_path = os.path.join(local_path, resource_name)
if not _remote_path.endswith(".vcf"):
continue
try:
print("Downloading " + _remote_path)
self.client.download(local_path=_local_path,
remote_path=_remote_path)
except WebDavException as ex:
print("Could not download " + resource_name)
class ClientTestCase(TestCase):
remote_path_file = 'test_dir/test.txt'
remote_path_file2 = 'test_dir2/test.txt'
remote_path_dir = 'test_dir'
remote_path_dir2 = 'test_dir2'
local_base_dir = 'tests/'
local_file = 'test.txt'
local_file_path = local_base_dir + 'test.txt'
local_path_dir = local_base_dir + 'res/test_dir'
def setUp(self):
options = {
'webdav_hostname': 'https://webdav.yandex.ru',
'webdav_login': '******',
'webdav_password': '******'
}
self.client = Client(options)
if path.exists(path=self.local_path_dir):
shutil.rmtree(path=self.local_path_dir)
def tearDown(self):
if path.exists(path=self.local_path_dir):
shutil.rmtree(path=self.local_path_dir)
if self.client.check(remote_path=self.remote_path_dir):
self.client.clean(remote_path=self.remote_path_dir)
if self.client.check(remote_path=self.remote_path_dir2):
self.client.clean(remote_path=self.remote_path_dir2)
def test_list(self):
self._prepare_for_downloading()
file_list = self.client.list()
self.assertIsNotNone(file_list, 'List of files should not be None')
self.assertGreater(file_list.__len__(), 0,
'Expected that amount of files more then 0')
def test_free(self):
self.assertGreater(
self.client.free(), 0,
'Expected that free space on WebDAV server is more then 0 bytes')
def test_check(self):
self.assertTrue(self.client.check(),
'Expected that root directory is exist')
def test_mkdir(self):
if self.client.check(remote_path=self.remote_path_dir):
self.client.clean(remote_path=self.remote_path_dir)
self.client.mkdir(remote_path=self.remote_path_dir)
self.assertTrue(self.client.check(remote_path=self.remote_path_dir),
'Expected the directory is created.')
@unittest.skip(
"Yandex brakes response for file it contains property resourcetype as collection but it should "
"be empty for file")
def test_download_to(self):
self._prepare_for_downloading()
buff = BytesIO()
self.client.download_from(buff=buff, remote_path=self.remote_path_file)
self.assertEquals(buff.getvalue(),
'test content for testing of webdav client')
@unittest.skip(
"Yandex brakes response for file it contains property resourcetype as collection but it should "
"be empty for file")
def test_download(self):
self._prepare_for_downloading()
self.client.download(local_path=self.local_path_dir,
remote_path=self.remote_path_dir)
self.assertTrue(path.exists(self.local_path_dir),
'Expected the directory is downloaded.')
self.assertTrue(path.isdir(self.local_path_dir),
'Expected this is a directory.')
self.assertTrue(
path.exists(self.local_path_dir + os.path.sep + self.local_file),
'Expected the file is downloaded')
self.assertTrue(
path.isfile(self.local_path_dir + os.path.sep +
self.local_path_file), 'Expected this is a file')
@unittest.skip(
"Yandex brakes response for file it contains property resourcetype as collection but it should "
"be empty for file")
def test_download_sync(self):
self._prepare_for_downloading()
os.mkdir(self.local_path_dir)
def callback():
self.assertTrue(
path.exists(self.local_path_dir + os.path.sep +
self.local_file),
'Expected the file is downloaded')
self.assertTrue(
path.isfile(self.local_path_dir + os.path.sep +
self.local_file), 'Expected this is a file')
self.client.download_sync(local_path=self.local_path_dir +
os.path.sep + self.local_file,
remote_path=self.remote_path_file,
callback=callback)
self.assertTrue(
path.exists(self.local_path_dir + os.path.sep + self.local_file),
'Expected the file has already been downloaded')
@unittest.skip(
"Yandex brakes response for file it contains property resourcetype as collection but it should "
"be empty for file")
def test_download_async(self):
self._prepare_for_downloading()
os.mkdir(self.local_path_dir)
def callback():
self.assertTrue(
path.exists(self.local_path_dir + os.path.sep +
self.local_file),
'Expected the file is downloaded')
self.assertTrue(
path.isfile(self.local_path_dir + os.path.sep +
self.local_file), 'Expected this is a file')
self.client.download_async(local_path=self.local_path_dir +
os.path.sep + self.local_file,
remote_path=self.remote_path_file,
callback=callback)
self.assertFalse(
path.exists(self.local_path_dir + os.path.sep + self.local_file),
'Expected the file has not been downloaded yet')
def test_upload_from(self):
self._prepare_for_uploading()
buff = StringIO(u'test content for testing of webdav client')
self.client.upload_to(buff=buff, remote_path=self.remote_path_file)
self.assertTrue(self.client.check(self.remote_path_file),
'Expected the file is uploaded.')
def test_upload(self):
self._prepare_for_uploading()
self.client.upload(remote_path=self.remote_path_file,
local_path=self.local_path_dir)
self.assertTrue(self.client.check(self.remote_path_dir),
'Expected the directory is created.')
self.assertTrue(self.client.check(self.remote_path_file),
'Expected the file is uploaded.')
def test_upload_file(self):
self._prepare_for_uploading()
self.client.upload_file(remote_path=self.remote_path_file,
local_path=self.local_file_path)
self.assertTrue(self.client.check(remote_path=self.remote_path_file),
'Expected the file is uploaded.')
def test_upload_sync(self):
self._prepare_for_uploading()
def callback():
self.assertTrue(self.client.check(self.remote_path_dir),
'Expected the directory is created.')
self.assertTrue(self.client.check(self.remote_path_file),
'Expected the file is uploaded.')
self.client.upload(remote_path=self.remote_path_file,
local_path=self.local_path_dir)
def test_upload_async(self):
self._prepare_for_uploading()
def callback():
self.assertTrue(self.client.check(self.remote_path_dir),
'Expected the directory is created.')
self.assertTrue(self.client.check(self.remote_path_file),
'Expected the file is uploaded.')
self.client.upload(remote_path=self.remote_path_file,
local_path=self.local_path_dir)
def test_copy(self):
self._prepare_for_downloading()
self.client.mkdir(remote_path=self.remote_path_dir2)
self.client.copy(remote_path_from=self.remote_path_file,
remote_path_to=self.remote_path_file2)
self.assertTrue(self.client.check(remote_path=self.remote_path_file2))
def test_move(self):
self._prepare_for_downloading()
self.client.mkdir(remote_path=self.remote_path_dir2)
self.client.move(remote_path_from=self.remote_path_file,
remote_path_to=self.remote_path_file2)
self.assertFalse(self.client.check(remote_path=self.remote_path_file))
self.assertTrue(self.client.check(remote_path=self.remote_path_file2))
def test_clean(self):
self._prepare_for_downloading()
self.client.clean(remote_path=self.remote_path_dir)
self.assertFalse(self.client.check(remote_path=self.remote_path_file))
self.assertFalse(self.client.check(remote_path=self.remote_path_dir))
def test_info(self):
self._prepare_for_downloading()
result = self.client.info(remote_path=self.remote_path_file)
self.assertEquals(result['name'], 'test.txt')
self.assertEquals(result['size'], '41')
self.assertTrue('created' in result)
self.assertTrue('modified' in result)
def test_directory_is_dir(self):
self._prepare_for_downloading()
self.assertTrue(self.client.is_dir(self.remote_path_dir),
'Should return True for directory')
def test_file_is_not_dir(self):
self._prepare_for_downloading()
self.assertFalse(self.client.is_dir(self.remote_path_file),
'Should return False for file')
def test_get_property_of_non_exist(self):
self._prepare_for_downloading()
result = self.client.get_property(remote_path=self.remote_path_file,
option={'name': 'aProperty'})
self.assertEquals(
result, None, 'For not found property should return value as None')
def test_set_property(self):
self._prepare_for_downloading()
self.client.set_property(remote_path=self.remote_path_file,
option={
'namespace': 'test',
'name': 'aProperty',
'value': 'aValue'
})
result = self.client.get_property(remote_path=self.remote_path_file,
option={
'namespace': 'test',
'name': 'aProperty'
})
self.assertEquals(result, 'aValue', 'Property value should be set')
def test_set_property_batch(self):
self._prepare_for_downloading()
self.client.set_property_batch(remote_path=self.remote_path_file,
option=[{
'namespace': 'test',
'name': 'aProperty',
'value': 'aValue'
}, {
'namespace': 'test',
'name': 'aProperty2',
'value': 'aValue2'
}])
result = self.client.get_property(remote_path=self.remote_path_file,
option={
'namespace': 'test',
'name': 'aProperty'
})
self.assertEquals(result, 'aValue',
'First property value should be set')
result = self.client.get_property(remote_path=self.remote_path_file,
option={
'namespace': 'test',
'name': 'aProperty2'
})
self.assertEquals(result, 'aValue2',
'Second property value should be set')
def _prepare_for_downloading(self):
if not self.client.check(remote_path=self.remote_path_dir):
self.client.mkdir(remote_path=self.remote_path_dir)
if not self.client.check(remote_path=self.remote_path_file):
self.client.upload_file(remote_path=self.remote_path_file,
local_path=self.local_file_path)
if not path.exists(self.local_path_dir):
os.makedirs(self.local_path_dir)
def _prepare_for_uploading(self):
if not self.client.check(remote_path=self.remote_path_dir):
self.client.mkdir(remote_path=self.remote_path_dir)
if not path.exists(path=self.local_path_dir):
os.makedirs(self.local_path_dir)
if not path.exists(path=self.local_path_dir + os.sep +
self.local_file):
shutil.copy(src=self.local_file_path,
dst=self.local_path_dir + os.sep + self.local_file)
