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()