def davserver_run():
global davserver
SUPPORTED_SERVERS = {
"cheroot": runCheroot,
}
config = _initConfig()
app = WsgiDAVApp(config)
server = config["server"]
handler = SUPPORTED_SERVERS.get(server)
if not handler:
raise RuntimeError(
"Unsupported server type {!r} (expected {!r})".format(
server, "', '".join(SUPPORTED_SERVERS.keys())))
if not useLxml and config["verbose"] >= 1:
print("WARNING: Could not import lxml: using xml instead (slower).")
print(
" Consider installing lxml https://pypi.python.org/pypi/lxml."
)
config["verbose"] = 0
davserver = handler(app, config, server)
try:
davserver.start()
except KeyboardInterrupt:
if config["verbose"] >= 1:
print("Caught Ctrl-C, shutting down...")
RunTime.wantQuit = True
finally:
davserver.stop()
print('davserver terminated')
def run(self):
""" Starts listening server"""
logging.info (" [+] Starting Macro_Pack WebDAV server...")
logging.info (" [-] Files in \"" + self.WRoot + r"\" folder are accessible using url http://<hostname>:%s or \\<hostname>@%s\DavWWWRoot" % (self.listenPort, self.listenPort))
logging.info (" [-] Listening on port %s (ctrl-c to exit)...", self.listenPort)
# Prepare WsgiDAV config
config = {
'middleware_stack' : {
WsgiDavDirBrowser, #Enabling dir_browser middleware
},
'host': 'localhost',
'dir_browser': {'davmount': False,
'enable': True, #Enabling directory browsing on dir_browser
'ms_mount': False,
'ms_sharepoint_plugin': True,
'ms_sharepoint_urls': False,
'response_trailer': ''},
'port': self.listenPort, # Specifying listening port
'provider_mapping': {'/': self.WRoot} #Specifying root folder
}
app = WsgiDAVApp(config)
server_args = {
"bind_addr": (config["host"], config["port"]),
"wsgi_app": app,
}
server = wsgi.Server(**server_args)
try:
server.start()
except:
logging.info(" [!] Ctrl + C detected, closing WebDAV sever")
server.stop()
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({
"provider_mapping": {
"/": provider
},
"user_mapping": {},
"verbose": 1,
"enable_loggers": [],
"propsmanager": None, # None: no property manager
"locksmanager": True, # True: use lock_manager.LockManager
"domaincontroller":
None, # None: domain_controller.WsgiDAVDomainController(user_mapping)
})
if withAuthentication:
config["user_mapping"] = {
"/": {
"tester": {
"password": "******",
"description": "",
"roles": [],
},
},
}
config["acceptbasic"] = True
config["acceptdigest"] = False
config["defaultdigest"] = False
return WsgiDAVApp(config)
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 run():
SUPPORTED_SERVERS = {
"paste": _runPaste,
"cheroot": _runCheroot,
"cherrypy": _runCherryPy,
"ext-wsgiutils": _runExtWsgiutils,
"flup-fcgi": _runFlup,
"flup-fcgi_fork": _runFlup,
"wsgiref": _runWsgiref,
}
config = _initConfig()
util.initLogging(config["verbose"], config.get("enable_loggers", []))
app = WsgiDAVApp(config)
server = config["server"]
handler = SUPPORTED_SERVERS.get(server)
if not handler:
raise RuntimeError(
"Unsupported server type {!r} (expected {!r})".format(
server, "', '".join(SUPPORTED_SERVERS.keys())))
if not useLxml: # and config["verbose"] >= 1:
_logger.warn(
"WARNING: Could not import lxml: using xml instead (slower). "
"Consider installing lxml https://pypi.python.org/pypi/lxml.")
handler(app, config, server)
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 main():
rootpath = gettempdir()
provider = FilesystemProvider(rootpath)
config = DEFAULT_CONFIG.copy()
config.update({
"provider_mapping": {
"/": provider
},
"user_mapping": {},
"verbose": 1,
"enable_loggers": [],
"propsmanager": True, # True: use property_manager.PropertyManager
"locksmanager": True, # True: use lock_manager.LockManager
"domaincontroller":
None, # None: domain_controller.WsgiDAVDomainController(user_mapping)
})
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/%s %s" %
(__version__, CherryPyWSGIServer.version),
)
try:
server.start()
except KeyboardInterrupt:
print("Caught Ctrl-C, shutting down...")
finally:
server.stop()
def main_loop(self):
provider = FabnetProvider(self.nibbler)
config = DEFAULT_CONFIG.copy()
config.update({
"provider_mapping": {"/": provider},
"user_mapping": {},
"verbose": 1,
#"debug_methods": ['OPTIONS', 'PROPFIND', 'GET'],
"enable_loggers": [],
"propsmanager": True, # True: use property_manager.PropertyManager
"locksmanager": True, # True: use lock_manager.LockManager
"acceptdigest": False, # Allow digest authentication, True or False
"defaultdigest": False, # True (default digest) or False (default basic)
"domaincontroller": KSDomainController(self.nibbler.get_security_provider()),
"dir_browser": {'response_trailer': "<a href='http://idepositbox.com'>"\
"iDepositBox/%s</a> ${time}"%VERSION}
})
app = WsgiDAVApp(config)
self.__init_logger()
if config["verbose"] >= 1:
print("Running %s, listening on %s://%s:%s" % (wsgiserver.CherryPyWSGIServer.version, 'http', self.host, self.port))
self.server = wsgiserver.CherryPyWSGIServer((self.host, self.port), app,)
self.server.provider = provider
self.server.start()
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 webdav_server_add(self,
name="webdav",
path="/tmp",
port=4443,
webdavprovider=None,
user_mapping={}):
"""
to test manually: wsgidav --root . --server gevent -p 8888 -H 0.0.0.0 --auth anonymous
don't forget to install first using: kosmos 'j.servers.rack._server_test_start()'
can use cyberduck to test
to implement custom backend: https://github.com/mar10/wsgidav/blob/master/wsgidav/samples/virtual_dav_provider.py
:param name:
:param path:
:param port:
:param webdavprovider:
:return:
"""
# from wsgidav.version import __version__
# from wsgidav.wsgidav_app import DEFAULT_CONFIG, WsgiDAVApp
from wsgidav.wsgidav_app import WsgiDAVApp
from gevent.pywsgi import WSGIServer
if not webdavprovider:
from wsgidav.fs_dav_provider import FilesystemProvider
webdavprovider = FilesystemProvider(path)
def addUser(realmName, user, password, description, roles=[]):
realmName = "/" + realmName.strip(r"\/")
userDict = user_mapping.setdefault(realmName,
{}).setdefault(user, {})
userDict["password"] = password
userDict["description"] = description
userDict["roles"] = roles
if user_mapping == {}:
addUser("", "root", "root", "")
config = {
"host": "0.0.0.0",
"port": port,
"provider_mapping": {
"/": webdavprovider
},
"verbose": 1,
"simple_dc": {
"user_mapping": user_mapping
},
}
app = WsgiDAVApp(config)
server = WSGIServer(("0.0.0.0", port), application=app)
self.add(name=name, server=server)
def runserver():
app = WsgiDAVApp(DEFAULT_CONFIG)
server_args = {
"bind_addr": (DEFAULT_CONFIG["host"], DEFAULT_CONFIG["port"]),
"wsgi_app": app,
}
server = wsgi.Server(**server_args)
return server.start()
def run(self):
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({
"provider_mapping": {
"/": provider
},
"user_mapping": {},
"host": "localhost",
"port": 8080,
"enable_loggers": [
# "http_authenticator",
# "lock_manager",
],
"debug_methods": [],
"propsmanager":
True, # True: use lock_manager.LockManager
"locksmanager":
True, # True: use lock_manager.LockManager
"domaincontroller":
None, # None: domain_controller.WsgiDAVDomainController(user_mapping)
"verbose": 2,
})
if withAuthentication:
config["user_mapping"] = {
"/": {
"tester": {
"password": "******",
"description": "",
"roles": [],
},
"tester2": {
"password": "******",
"description": "",
"roles": [],
},
},
}
config["acceptbasic"] = True
config["acceptdigest"] = False
config["defaultdigest"] = False
app = WsgiDAVApp(config)
self.ext_server = ExtServer((config["host"], config["port"]),
{"": app})
self.ext_server.serve_forever_stoppable()
self.ext_server = None
def handle(self, *args, **options):
if WsgiDAVApp is None:
raise CommandError(
'To use this command, you should install WsgiDAV first with'
'typing\n\n pip install wsgidav\n\n'
'in your console.')
config = self.configure(options)
app = WsgiDAVApp(config)
freeze_support()
with make_server(config['host'], config['port'], app) as webdavd:
webdavd.serve_forever()
def run(self):
""" Starts listening server"""
logging.info(" [+] Starting Macro_Pack WebDAV server...")
logging.info(
" [-] Files in \"" + self.WRoot +
r"\" folder are accessible using url http://{ip}:{port} or \\{ip}@{port}\DavWWWRoot"
.format(ip=getHostIp(), port=self.listenPort))
logging.info(" [-] Listening on port %s (ctrl-c to exit)...",
self.listenPort)
# Prepare WsgiDAV config
config = {
'middleware_stack': {
WsgiDavDirBrowser, #Enabling dir_browser middleware
},
'verbose': 3,
'add_header_MS_Author_Via': True,
'unquote_path_info': False,
're_encode_path_info': None,
'host': '0.0.0.0',
'dir_browser': {
'davmount': False,
'enable': True, #Enabling directory browsing on dir_browser
'ms_mount': False,
'show_user': True,
'ms_sharepoint_plugin': True,
'ms_sharepoint_urls': False,
'response_trailer': False
},
'port': self.listenPort, # Specifying listening port
'provider_mapping': {
'/': self.WRoot
} #Specifying root folder
}
app = WsgiDAVApp(config)
server_args = {
"bind_addr": (config["host"], config["port"]),
"wsgi_app": app,
}
server = wsgi.Server(**server_args)
try:
log = logging.getLogger('wsgidav')
log.raiseExceptions = False # hack to avoid false exceptions
log.propagate = True
log.setLevel(logging.INFO)
server.start()
except KeyboardInterrupt:
logging.info(" [!] Ctrl + C detected, closing WebDAV sever")
server.stop()
def start_davsrv(config=False):
if config == False:
config = commonConf
app = WsgiDAVApp(config)
server_args = {
"bind_addr": (config["host"], config["port"]),
"wsgi_app": app,
}
server = wsgi.Server(**server_args)
server.start()
def create_app(config=None):
# from .fire.firestore_dav import FirestoreDAVProvider
from wsgidav.wsgidav_app import WsgiDAVApp
dav_provider = FirestoreDAVProvider()
config = config or {}
config["provider_mapping"] = {"/": dav_provider}
# allow anonymous access or use domain controller
config["simple_dc"] = {"user_mapping": {"*": True}}
config["verbose"] = 3
return WsgiDAVApp(config)
def run():
config, args = _initConfig()
app = WsgiDAVApp(config)
pid_file_name = config.get("pid_file", "")
if pid_file_name:
write_pidfile(pid_file_name)
if len(args) > 0 and args[0] == 'runfcgi':
_runFlup(app, config, 'flup-fcgi_fork')
else:
_runCherryPy(app, config, 'cherrypy-bundled')
def create_app(source_fs, config=None):
from wsgidav.wsgidav_app import WsgiDAVApp
from mapper.dav_provider_from_fs import FS2DAVProvider
dav_provider = FS2DAVProvider(source_fs)
config = config or {}
config["provider_mapping"] = {"/": dav_provider}
# allow anonymous access or use domain controller
config["simple_dc"] = {"user_mapping": {"*": True}}
config["verbose"] = 3
return WsgiDAVApp(config)
def get_app(self):
config = {
'provider_mapping': {
'/': CustomDAVProvider(self.root_path)
},
'simple_dc': {
'user_mapping': {
'*': True
}
},
'verbose': self.verbose,
}
return WsgiDAVApp(config)
def davmain(config, args):
app = WsgiDAVApp(config)
if len(args) > 0:
if args[0] == "runfcgi":
if len(args) >= 2 and args[1] == "method=threaded":
_runFlup(app, config, "flup-fcgi")
else:
_runFlup(app, config, "flup-fcgi_fork")
else:
util.warn("Unknown command %s" % args[0])
exit(1)
else:
_runCherryPy(app, config, "cherrypy-bundled")
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 create_app():
# logging.debug("real_main")
# logger = logging.getLogger("wsgidav")
# logger.propagate = True
# logger.setLevel(logging.DEBUG)
config = get_config()
# Preset trusted_auth_header in environ for non-wsgidav applications too
auth_conf = config.get("http_authenticator", {})
trusted_auth_header = auth_conf.get("trusted_auth_header", None)
if trusted_auth_header:
os.environ["TRUSTED_AUTH_HEADER"] = trusted_auth_header
return WsgiDAVApp(config)
def webdav_server(tmp_path_factory):
host, port = "localhost", 0
directory = os.fspath(tmp_path_factory.mktemp("http"))
dirmap = {"/": directory}
app = WsgiDAVApp(
{
"host": host,
"port": port,
"provider_mapping": dirmap,
"simple_dc": {"user_mapping": {"*": AUTH}},
}
)
server = make_server(host, port, app)
with run_server_on_thread(server) as httpd:
yield httpd
def run():
config = _initConfig()
app = WsgiDAVApp(config)
# Try running WsgiDAV inside the following external servers:
res = False
for e in config["ext_servers"]:
fn = SUPPORTED_SERVERS.get(e)
if fn is None:
print "Invalid external server '%s'. (expected: '%s')" % (
e, "', '".join(SUPPORTED_SERVERS.keys()))
elif fn(app, config, e):
res = True
break
if not res:
print "No supported WSGI server installed."
def run():
config = _init_config()
util.init_logging(config)
app = WsgiDAVApp(config)
server = config["server"]
handler = SUPPORTED_SERVERS.get(server)
if not handler:
raise RuntimeError(
"Unsupported server type {!r} (expected {!r})".format(
server, "', '".join(SUPPORTED_SERVERS.keys())))
if not use_lxml: # and config["verbose"] >= 1:
_logger.warn(
"Could not import lxml: using xml instead (slower). "
"Consider installing lxml https://pypi.python.org/pypi/lxml.")
handler(app, config, server)
def get_server(config: Dict[str, Any]) -> wsgi.Server:
bind_addr = (config["host"], config["port"])
server = _servers.get(bind_addr)
if not server:
dav_app = WsgiDAVApp(config)
path_map = {
"/test": partial(serve_document, config),
"/dav": dav_app,
}
dispatch = wsgi.PathInfoDispatcher(path_map)
server_args = {
"bind_addr": bind_addr,
"wsgi_app": dispatch,
}
server = wsgi.Server(**server_args)
server.prepare()
_servers[bind_addr] = server
server._manabi_id = bind_addr
return server
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 app(self):
root = os.path.dirname(os.path.abspath(__file__))
from fileserver.webdav import provider
config = {
"provider_mapping": {
"/": provider.BCDBFSProvider(self.path)
},
"verbose":
5,
"port":
self.port,
"middleware_stack": [
WsgiDavDebugFilter,
ErrorPrinter,
HTTPAuthenticator,
WsgiDavDirBrowser, # configured under dir_browser option (see below)
RequestResolver, # this must be the last middleware item
],
"error_printer": {
"catch_all": True
}, # False,
"enable_loggers": ["wsgidav"],
"simple_dc": {
"user_mapping": {
"*": True
}
},
}
if self.debug:
config["middleware_stack"].pop(0)
config["middleware_stack"].pop(0)
if not self._app:
self._app = WsgiDAVApp(config)
self._app.debug = True
return self._app
def run(self, host, port, validate_credentials, folder_creation_in_cache,
file_creation_in_cache):
self._validate_configure_authenticator(validate_credentials)
self.client.folder_creation_in_cache = folder_creation_in_cache
self.client.file_creation_in_cache = file_creation_in_cache
port = int(port)
config = {
"host": host,
"port": port,
"provider_mapping": {
'/': self.provider
},
"http_authenticator": {
"accept_basic": True
},
"error_printer": {
"catch_all": True
},
"simple_dc": {
"user_mapping": {
"*": {
self._config['webDavUser']: {
"password": self._config['webDavPassword']
}
}
}
}
}
app = WsgiDAVApp(config)
server_args = {"bind_addr": (host, port), "wsgi_app": app}
server = wsgi.Server(**server_args)
server.start()
