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 }, 'host': '0.0.0.0', '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 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 webdav_server(test_config, tmp_path_factory): test_config.requires("webdav") 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 = _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 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(): SUPPORTED_SERVERS = {"paste": _runPaste, "cherrypy": _runCherryPy, "ext-wsgiutils": _runExtWsgiutils, "flup-fcgi": _runFlup, "flup-fcgi_fork": _runFlup, "wsgiref": _runWsgiref, } 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.") handler(app, config, server)
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 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 start_server(): launch_file_monitor() provider = FilesystemProvider(workspace_dir) config = DEFAULT_CONFIG.copy() config.update({ "mount_path": "/dav", "provider_mapping": { "/": provider }, "simple_dc": { "user_mapping": { "*": True } }, "dir_browser": { "enable": True, "response_trailer": response_trailer }, "verbose": 2, }) 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=PORT)
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 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 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 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()
}, "/webdav/public": { "root": WEBDAV_PUBLIC, }, "/webdav/blackhole": { "root": WEBDAV_BLACKHOLE, }, "/webdav": { "root": WEBDAV_DIR, "readonly": True, } }, "verbose": 1, } app = WsgiDAVApp(config) server_args = { "bind_addr": (config["host"], config["port"]), "wsgi_app": app, } server = wsgi.Server(**server_args) class MyHandler(FileSystemEventHandler): def on_created(self, event): os.rename( os.path.join(event.src_path), os.path.join(BLACKHOLE_DIR, os.path.basename(event.src_path)), )
def get_wsgi_app(self): return WsgiDAVApp(self.config)
"host": "0.0.0.0", "port": 8080, "simple_dc": { "user_mapping": { "*": True } }, "provider_mapping": { "/": dataPath, }, "verbose": 1, } #-The WebDav Service------------------------ app = WsgiDAVApp(commonConf) 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 Cherry(): Log.info('######################Start Cherrypy!########################') cherrypy.config.update({'environment' : 'production', 'engine.autoreload_on' : False, 'checker.on' : False, 'server.socket_host' : '0.0.0.0', 'server.socket_port' : UtilFunc.getWebServerPort(), 'server.thread_pool' : 6, 'server.thread_pool_max' : 10, 'server.max_request_body_size' : sys.maxint, 'log.screen' : True, }) services = {'/storages':Storages(), '/system':System(), '/version':Version(), '/files':Files(), '/share':Share(), '/search':Search(), '/logs':ESLog(), '/batch':Batch(), '/photos':Photos(), '/music':Music(), '/video':Video(), '/backup':Backup()} if not UtilFunc.isPCMode(): from Apps.AppCtrl import AppCtrl services['/app'] = AppCtrl() for server in services.keys(): mountService(services[server], "/api" + server) Log.info('Mount APIServices Complete!') cherrypy.tree.mount(portal(), '/', config={'/': {'tools.auth.on' : False, 'tools.staticdir.on' : True, 'tools.staticdir.dir' : UtilFunc.module_path(), }, }) Log.info('Mount Portal Service Complete!') cherrypy.tree.mount(GuestShare(), '/share', config={'/': _getMountConfig(False)}) Log.info('Mount GuestShare Service Complete!') try: server2 = _cpwsgi_server.CPWSGIServer() server2.bind_addr = ('0.0.0.0', 1984) adapter2 = _cpserver.ServerAdapter(cherrypy.engine, server2, server2.bind_addr) adapter2.subscribe() cherrypy.tree.graft(WebServer().my_crazy_app, "/web") syncdir = os.path.join(os.getcwd(),"sync") if not os.path.exists(syncdir): os.mkdir(syncdir) config = {"mount_path" :"/syncservice", "provider_mapping":{"webdav":syncdir}, "user_mapping" :{}, "verbose" :2, "dir_browser" :{ "enable" : True, "response_trailer": "", "davmount" : False, "msmount" : False } } cherrypy.tree.graft(WsgiDAVApp(config),"/syncservice") Log.info('Start WsgiDAV Complete!') except Exception, e: Log.info('WsgiDAV Start Failed! Reason[%s]'%e)
config = DEFAULT_CONFIG.copy() provider = FilesystemProvider('../files/') config.update({ "mount_path": "", "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) }) wsgidav = WsgiDAVApp(config) def wsgidav_application(environ, start_response): return wsgidav(environ, start_response) class Services: pass services = Services() services.radio = radio.Radio(irlp_home) services.player = playback.Player(services.radio) services.scheduler = scheduler.Scheduler(services.player, services.radio)
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}, "host": SERVER_HOST, "port": SERVER_PORT, # None: dc.simple_dc.SimpleDomainController(user_mapping) "http_authenticator": {"domain_controller": None}, "simple_dc": {"user_mapping": {"*": True}}, # anonymous access "verbose": 4, "enable_loggers": [ # "http_authenticator", # "lock_manager", ], "debug_methods": [], "property_manager": True, # True: use lock_manager.LockManager "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"].update( { "user_mapping": { "/": { "tester": { "password": "******", "description": "", "roles": [], }, "tester2": { "password": "******", "description": "", "roles": [], }, } } } ) 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 run_wsgidav_server(with_auth, with_ssl, provider=None, **kwargs): """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) if provider is None: provider = FilesystemProvider(share_path) # config = DEFAULT_CONFIG.copy() # config.update({ config = { "host": "127.0.0.1", "port": 8080, "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": True, # None: no property manager "lock_manager": True, # True: use lock_manager.LockManager } if with_auth: config["http_authenticator"].update( {"accept_basic": True, "accept_digest": False, "default_to_digest": False} ) config["simple_dc"].update( { "user_mapping": { "*": { "tester": { "password": "******", "description": "", "roles": [], }, "tester2": { "password": "******", "description": "", "roles": [], }, } } } ) 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, # "accept_digest": True, # "default_to_digest": True, } ) # We want output captured for tests util.init_logging(config) # This event is .set() when server enters the request handler loop if kwargs.get("startup_event"): config["startup_event"] = kwargs["startup_event"] app = WsgiDAVApp(config) # from wsgidav.server.server_cli import _runBuiltIn # _runBuiltIn(app, config, None) from wsgidav.server.server_cli import _run_cheroot _run_cheroot(app, config, "cheroot")
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)
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 = { 'verbose': 3, 'add_header_MS_Author_Via': True, "hotfixes": { "emulate_win32_lastmod": False, # True: support Win32LastModifiedTime "re_encode_path_info": True, # (See issue #73) "unquote_path_info": False, # (See issue #8, #228) "win_accept_anonymous_options": True, }, 'host': '0.0.0.0', 'port': self.listenPort, # Specifying listening port 'provider_mapping': { '/': self.WRoot }, #Specifying root folder "middleware_stack": [ # WsgiDavDebugFilter, ErrorPrinter, #HTTPAuthenticator, WsgiDavDirBrowser, # configured under dir_browser option (see below) RequestResolver, # this must be the last middleware item ], # HTTP Authentication Options "http_authenticator": { # None: dc.simple_dc.SimpleDomainController(user_mapping) "domain_controller": None, "accept_anonymous": True, # Allow basic authentication, True or False #"accept_digest": True, # Allow digest authentication, True or False #"default_to_digest": True, # True (default digest) or False (default basic) # Name of a header field that will be accepted as authorized user "trusted_auth_header": None, }, 'dir_browser': { 'davmount': False, 'enable': True, # Enabling directory browsing on dir_browser # List of fnmatch patterns: "ignore": [ ".DS_Store", # macOS folder meta data "._*", # macOS hidden data files "Thumbs.db", # Windows image previews ], 'ms_mount': False, 'show_user': True, 'ms_sharepoint_support': True, 'ms_sharepoint_urls': False, 'response_trailer': True, }, } 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 run(self): app = WsgiDAVApp(self.config) # Try running WsgiDAV inside the following external servers: self._runCherryPy(app, self.config)
} }, # anonymous access # "http_authenticator.domain_controller": WsgiDavDomainController(), 'simple_dc.user_mapping': { provider: { None: None } }, "provider_mapping": { "/": provider }, "verbose": 1, 'accept_digest': False, 'default_to_digest': False, } app = WsgiDAVApp(config) wsgidav_app = WsgiDAVApp(config) class WsgiView(View): application = None def __init__(self, **kwargs): super(WsgiView, self).__init__(**kwargs) self.init_application() def init_application(self): application = self.application if callable(application): return