def start_server():
launch_file_monitor()
provider = FilesystemProvider('workspace')
config = DEFAULT_CONFIG.copy()
config.update({
"mount_path": "/dav",
"provider_mapping": {
"/": provider
},
"user_mapping": {},
"verbose": 1,
})
dav_app = WsgiDAVApp(config)
cors_dav_app = CORS(dav_app,
headers="*",
methods="*",
maxage="180",
origin="*")
# CORS middleware doesn't like exc_info
filtered_dav_app = DAVFilterMiddleWare(cors_dav_app)
filtered_dav_app = GzipMiddleware(filtered_dav_app,
mime_types=[
'application/javascript',
'application/x-rapyd',
'application/xml', 'image/svg+xml',
'text/*'
])
app.wsgi_app = DispatcherMiddleware(app.wsgi_app,
{'/dav': filtered_dav_app})
socketio.run(app, host='0.0.0.0', port=54991)
def _makeWsgiDAVApp(self, withAuthentication):
self.rootpath = os.path.join(gettempdir(), "wsgidav-test")
if not os.path.exists(self.rootpath):
os.mkdir(self.rootpath)
provider = FilesystemProvider(self.rootpath)
# config = DEFAULT_CONFIG.copy()
# config.update({
config = {
"provider_mapping": {"/": provider},
# None: dc.simple_dc.SimpleDomainController(user_mapping)
"http_authenticator": {"domain_controller": None},
"simple_dc": {"user_mapping": {"*": True}}, # anonymous access
"verbose": 1,
"enable_loggers": [],
"property_manager": None, # None: no property manager
"lock_manager": True, # True: use lock_manager.LockManager
}
if withAuthentication:
config["http_authenticator"].update(
{
"accept_basic": True,
"accept_digest": False,
"default_to_digest": False,
}
)
config["simple_dc"]["user_mapping"] = {
"/": {"tester": {"password": "******", "description": "", "roles": []}}
}
return WsgiDAVApp(config)
def main():
root_path = gettempdir()
provider = FilesystemProvider(root_path)
config = {
"provider_mapping": {"/": provider},
"http_authenticator": {
"domain_controller": None # None: dc.simple_dc.SimpleDomainController(user_mapping)
},
"simple_dc": {"user_mapping": {"*": True}}, # anonymous access
"verbose": 1,
"enable_loggers": [],
"property_manager": True, # True: use property_manager.PropertyManager
"lock_manager": True, # True: use lock_manager.LockManager
}
app = WsgiDAVApp(config)
# For an example, use CherryPy
from cherrypy.wsgiserver import CherryPyWSGIServer
server = CherryPyWSGIServer(
bind_addr=(config["host"], config["port"]),
wsgi_app=app,
server_name="WsgiDAV/{} {}".format(__version__, CherryPyWSGIServer.version),
)
try:
server.start()
except KeyboardInterrupt:
print("Caught Ctrl-C, shutting down...")
finally:
server.stop()
def run(self):
print("WsgiDAVServerThread.run()...")
withAuthentication = True
self.rootpath = os.path.join(gettempdir(), "wsgidav-test")
if not os.path.exists(self.rootpath):
os.mkdir(self.rootpath)
provider = FilesystemProvider(self.rootpath)
# config = DEFAULT_CONFIG.copy()
# config.update({
config = {
"provider_mapping": {
"/": provider
},
"user_mapping": {},
"host": SERVER_HOST,
"port": SERVER_PORT,
"enable_loggers": [
# "http_authenticator",
# "lock_manager",
],
"debug_methods": [],
"property_manager": True, # True: use lock_manager.LockManager
"lock_manager": True, # True: use lock_manager.LockManager
# None: domain_controller.WsgiDAVDomainController(user_mapping)
"domain_controller": None,
"verbose": 4,
}
if withAuthentication:
config["user_mapping"] = {
"/": {
"tester": {
"password": "******",
"description": "",
"roles": []
},
"tester2": {
"password": "******",
"description": "",
"roles": []
},
}
}
config["http_authenticator"] = {
"accept_basic": True,
"accept_digest": False,
"default_to_digest": False,
}
app = WsgiDAVApp(config)
self.ext_server = ExtServer((config["host"], config["port"]),
{"": app})
print("WsgiDAVServerThread ext_server.serve_forever_stoppable()...")
self.ext_server.serve_forever_stoppable()
print("WsgiDAVServerThread ext_server stopped.")
self.ext_server = None
def set_root(self, path):
root, path = path.split("/", 1)
if self._root_path == root:
return path
self._root_path = root
if root == "temp":
# Open the DAV Provider as source
from wsgidav.fs_dav_provider import FilesystemProvider
self._dav_provider = FilesystemProvider("/tmp")
elif root == "user":
from wsgidav.fs_dav_provider import FilesystemProvider
self._dav_provider = FilesystemProvider(os.path.expanduser("~"))
elif root == "data_dav":
from data.datastore_dav import DatastoreDAVProvider
self._dav_provider = DatastoreDAVProvider()
elif root == "fs2dav":
# Open the PyFilesystem2 filesystem as source
from mapper.dav_provider_from_fs import FS2DAVProvider
# from fs import open_fs
from fs.osfs import OSFS
from data.datastore_fs import DatastoreFS
# source_fs = open_fs("osfs://" + BASE_DIR)
# source_fs = OSFS(BASE_DIR)
source_fs = DatastoreFS("/")
self._dav_provider = FS2DAVProvider(source_fs)
elif root == "fire_dav_todo":
from fire.firestore_dav import FirestoreDAVProvider
self._dav_provider = FirestoreDAVProvider()
else:
raise ValueError("Invalid Wsgi DAV Provider root '%s'" %
root.replace("<", "<"))
return path
def main():
# from .fs_from_dav_provider import DAVProvider2FS
from wsgidav.fs_dav_provider import FilesystemProvider
dav_provider = FilesystemProvider("/tmp")
dav_fs = DAVProvider2FS(dav_provider)
# dav_fs = open_fs("dav_provider://")
# dav_fs = WrapDAVProvider2FS(dav_provider)
# dav_fs.environ["wsgidav.auth.user_name"] = "tester"
# dav_fs.environ["wsgidav.auth.roles"] = ["admin"]
result = dav_fs.tree()
# result = dav_fs.listdir("/")
return result
def __init__(self):
self.app = WsgiDAVApp({
'provider_mapping': {
'/': FilesystemProvider(tmp_root_directory)
},
'simple_dc': {
'user_mapping': {
"*": True
}
}
})
self.server = make_server('',
8080,
app=self.app,
handler_class=MutedWSGIRequestHandler)
def make_fs(self):
global test_count
test_count += 1
test_name = self.id().split(".")[-1]
# if test_name in ("test_upload", "test_download"):
# pytest.skip("No time to waste...")
# return
if test_name in ("test_appendbytes", "test_appendtext"):
pytest.xfail("Appending is not supported")
if test_name in ("test_bin_files", "test_files", "test_open_files"):
pytest.xfail("Updating is not supported")
if test_name in ("test_invalid_chars"):
pytest.xfail("TODO: get list of invalid characters from the DAV Provider")
# Return an instance of your FS object here
dav_provider = FilesystemProvider("/tmp/_playground_")
dav_fs = DAVProvider2FS(dav_provider)
test_path = "/%02d_%s" % (test_count, test_name)
test_fs = dav_fs._reset_path(test_path, True)
return test_fs
def create_webdav_app(global_config,
mount_path='/api/file/webdav',
workspace=None):
from wsgidav.wsgidav_app import WsgiDAVApp
from wsgidav.dir_browser import WsgiDavDirBrowser
from wsgidav.error_printer import ErrorPrinter
from wsgidav.request_resolver import RequestResolver
from wsgidav.fs_dav_provider import FilesystemProvider
if workspace is None:
workspace = os.getcwd()
config = dict(mount_path=mount_path,
provider_mapping={'/': FilesystemProvider(workspace)},
middleware_stack=[
ErrorPrinter,
WsgiDavDirBrowser,
RequestResolver,
],
verbose=2)
return WsgiDAVApp(config)
def create_app():
root_path = gettempdir()
provider = FilesystemProvider(root_path, readonly=True)
config = {
"provider_mapping": {
"/tmp": provider
},
"http_authenticator": {
"domain_controller":
None # None: dc.simple_dc.SimpleDomainController(user_mapping)
},
"simple_dc": {
"user_mapping": {
"*": True
}
}, # anonymous access
"verbose": 1,
# "enable_loggers": [],
"property_manager": True, # True: use property_manager.PropertyManager
"lock_manager": True, # True: use lock_manager.LockManager
}
# app = WsgiDAVApp(config)
return WsgiDAVApp(config)
def Filesystem(root):
"""Create a filesystem provider at a given path."""
from wsgidav.fs_dav_provider import FilesystemProvider
return FilesystemProvider(root)
def add_provider(self, share, provider, readonly=False):
"""Add a provider to the provider_map routing table."""
# Make sure share starts with, or is '/'
share = "/" + share.strip("/")
assert share not in self.provider_map
if compat.is_basestring(provider):
# Syntax:
# <mount_path>: <folder_path>
# We allow a simple string as 'provider'. In this case we interpret
# it as a file system root folder that is published.
provider = FilesystemProvider(provider, readonly)
elif type(provider) in (dict, ):
if "provider" in provider:
# Syntax:
# <mount_path>: {"provider": <class_path>, "args": <pos_args>, "kwargs": <named_args}
prov_class = dynamic_import_class(provider["provider"])
provider = prov_class(*provider.get("args", []),
**provider.get("kwargs", {}))
else:
# Syntax:
# <mount_path>: {"root": <path>, "redaonly": <bool>}
provider = FilesystemProvider(
provider["root"], bool(provider.get("readonly", False)))
elif type(provider) in (list, tuple):
raise ValueError(
"Provider {}: tuple/list syntax is no longer supported".format(
provider))
# provider = FilesystemProvider(provider[0], provider[1])
if not isinstance(provider, DAVProvider):
raise ValueError("Invalid provider {}".format(provider))
provider.set_share_path(share)
if self.mount_path:
provider.set_mount_path(self.mount_path)
# TODO: someday we may want to configure different lock/prop
# managers per provider
provider.set_lock_manager(self.lock_manager)
provider.set_prop_manager(self.prop_manager)
self.provider_map[share] = provider
# self.provider_map[share] = {"provider": provider, "allow_anonymous": False}
# Store the list of share paths, ordered by length, so route lookups
# will return the most specific match
self.sorted_share_list = [s.lower() for s in self.provider_map.keys()]
self.sorted_share_list = sorted(self.sorted_share_list,
key=len,
reverse=True)
return provider
def add_provider(self, share, provider, readonly=False):
"""Add a provider to the provider_map routing table."""
# Make sure share starts with, or is '/'
share = "/" + share.strip("/")
assert share not in self.provider_map
if compat.is_basestring(provider):
# Syntax:
# <mount_path>: <folder_path>
# We allow a simple string as 'provider'. In this case we interpret
# it as a file system root folder that is published.
provider = FilesystemProvider(provider, readonly)
elif type(provider) in (dict,):
if "provider" in provider:
# Syntax:
# <mount_path>: {"provider": <class_path>, "args": <pos_args>, "kwargs": <named_args}
prov_class = dynamic_import_class(provider["provider"])
provider = prov_class(
*provider.get("args", []), **provider.get("kwargs", {})
)
else:
# Syntax:
# <mount_path>: {"root": <path>, "redaonly": <bool>}
provider = FilesystemProvider(
provider["root"], bool(provider.get("readonly", False))
)
elif type(provider) in (list, tuple):
raise ValueError(
"Provider {}: tuple/list syntax is no longer supported".format(provider)
)
# provider = FilesystemProvider(provider[0], provider[1])
if not isinstance(provider, DAVProvider):
raise ValueError("Invalid provider {}".format(provider))
provider.set_share_path(share)
if self.mount_path:
provider.set_mount_path(self.mount_path)
# TODO: someday we may want to configure different lock/prop
# managers per provider
provider.set_lock_manager(self.lock_manager)
provider.set_prop_manager(self.prop_manager)
self.provider_map[share] = provider
# self.provider_map[share] = {"provider": provider, "allow_anonymous": False}
# Store the list of share paths, ordered by length, so route lookups
# will return the most specific match
self.sorted_share_list = [s.lower() for s in self.provider_map.keys()]
self.sorted_share_list = sorted(self.sorted_share_list, key=len, reverse=True)
return provider
from wsgidav.fs_dav_provider import FilesystemProvider
from wsgidav.wsgidav_app import WsgiDAVApp
from eric.settings.base import MEDIA_ROOT
from importlib import import_module
from django.core.exceptions import ImproperlyConfigured
from django.http import HttpResponse
from django.utils import six
from django.utils.decorators import classonlymethod
from django.views import View
from eric.shared_elements.models import File
projects_storage = os.path.join(MEDIA_ROOT, 'projects_storage')
provider = FilesystemProvider(projects_storage)
class WsgiDavDomainController:
def requireAuthentication(self, realmname, environ):
return True
def getDomainRealm(self, inputRelativeURL, environ):
return environ.get('PATH_INFO').split('/')[1]
def authDomainUser(self, realmname, username, password, environ):
user = authenticate(username=username, password=password)
try:
return File.objects.viewable()
except Exception as error:
return False
# https://docs.pyfilesystem.org/en/latest/implementers.html#testing-filesystems
from .fs_from_dav_provider import DAVProvider2FS
from wsgidav.fs_dav_provider import FilesystemProvider
import unittest
import pytest
from fs.test import FSTestCases
# Create the test playground if needed
dav_provider = FilesystemProvider("/tmp")
dav_fs = DAVProvider2FS(dav_provider)
dav_fs._reset_path("/_playground_", True)
dav_fs.close()
test_count = 0
class TestDAVProvider2FS(FSTestCases, unittest.TestCase):
def make_fs(self):
global test_count
test_count += 1
test_name = self.id().split(".")[-1]
# if test_name in ("test_upload", "test_download"):
# pytest.skip("No time to waste...")
# return
if test_name in ("test_appendbytes", "test_appendtext"):
pytest.xfail("Appending is not supported")
if test_name in ("test_bin_files", "test_files", "test_open_files"):
pytest.xfail("Updating is not supported")
if test_name in ("test_invalid_chars"):
pytest.xfail("TODO: get list of invalid characters from the DAV Provider")
# Return an instance of your FS object here
def run_wsgidav_server(with_auth, with_ssl):
"""Start blocking WsgiDAV server (called as a separate process)."""
package_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), ".."))
share_path = os.path.join(gettempdir(), "wsgidav-test")
if not os.path.exists(share_path):
os.mkdir(share_path)
provider = FilesystemProvider(share_path)
config = DEFAULT_CONFIG.copy()
config.update({
"host": "127.0.0.1",
"port": 8080,
"provider_mapping": {
"/": provider
},
"domaincontroller":
None, # None: domain_controller.WsgiDAVDomainController(user_mapping)
"user_mapping": {},
"verbose": 0,
"enable_loggers": [],
"propsmanager": True, # None: no property manager
"locksmanager": True, # True: use lock_manager.LockManager
"domaincontroller":
None, # None: domain_controller.WsgiDAVDomainController(user_mapping)
})
if with_auth:
config.update({
"user_mapping": {
"/": {
"tester": {
"password": "******",
"description": "",
"roles": [],
},
},
},
"acceptbasic": True,
"acceptdigest": False,
"defaultdigest": False,
})
if with_ssl:
config.update({
"ssl_certificate":
os.path.join(package_path,
"wsgidav/server/sample_bogo_server.crt"),
"ssl_private_key":
os.path.join(package_path,
"wsgidav/server/sample_bogo_server.key"),
"ssl_certificate_chain":
None,
# "acceptdigest": True,
# "defaultdigest": True,
})
app = WsgiDAVApp(config)
from wsgidav.server.run_server import _runBuiltIn
_runBuiltIn(app, config, None)
