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