def run():
SUPPORTED_SERVERS = {"paste": _run_paste,
"cheroot": _run_cheroot,
"cherrypy": _run__cherrypy,
"ext-wsgiutils": _run_ext_wsgiutils,
"flup-fcgi": _run_flup,
"flup-fcgi_fork": _run_flup,
"wsgiref": _run_wsgiref,
}
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 testCliLogging(self):
"""CLI initializes logging."""
config = {"verbose": 3, "enable_loggers": ["test"]}
init_logging(config)
_baseLogger = logging.getLogger(BASE_LOGGER_NAME)
_enabledLogger = get_module_logger("test")
_disabledLogger = get_module_logger("test2")
_baseLogger.debug("_baseLogger.debug")
_baseLogger.info("_baseLogger.info")
_baseLogger.warning("_baseLogger.warning")
_baseLogger.error("_baseLogger.error")
_enabledLogger.debug("_enabledLogger.debug")
_enabledLogger.info("_enabledLogger.info")
_enabledLogger.warning("_enabledLogger.warning")
_enabledLogger.error("_enabledLogger.error")
_disabledLogger.debug("_disabledLogger.debug")
_disabledLogger.info("_disabledLogger.info")
_disabledLogger.warning("_disabledLogger.warning")
_disabledLogger.error("_disabledLogger.error")
rootOutput, baseOutput = self.getLogOutput()
# Printed for debugging, when test fails:
print("ROOT OUTPUT:\n'{}'\nBASE OUTPUT:\n'{}'".format(rootOutput, baseOutput))
# init_logging() removes all other handlers
assert rootOutput == ""
assert baseOutput == ""
def testCliLogging(self):
"""CLI initializes logging."""
config = {"verbose": 3, "enable_loggers": ["test"]}
init_logging(config)
_baseLogger = logging.getLogger(BASE_LOGGER_NAME)
_enabledLogger = get_module_logger("test")
_disabledLogger = get_module_logger("test2")
_baseLogger.debug("_baseLogger.debug")
_baseLogger.info("_baseLogger.info")
_baseLogger.warning("_baseLogger.warning")
_baseLogger.error("_baseLogger.error")
_enabledLogger.debug("_enabledLogger.debug")
_enabledLogger.info("_enabledLogger.info")
_enabledLogger.warning("_enabledLogger.warning")
_enabledLogger.error("_enabledLogger.error")
_disabledLogger.debug("_disabledLogger.debug")
_disabledLogger.info("_disabledLogger.info")
_disabledLogger.warning("_disabledLogger.warning")
_disabledLogger.error("_disabledLogger.error")
rootOutput, baseOutput = self.getLogOutput()
# Printed for debugging, when test fails:
print("ROOT OUTPUT:\n'{}'\nBASE OUTPUT:\n'{}'".format(
rootOutput, baseOutput))
# init_logging() removes all other handlers
assert rootOutput == ""
assert baseOutput == ""
def get_app(config):
""" Init the webdav app """
mongo_client = MongoClient(
host=config.get('mongo_opt', {}).get('host', 'localhost'))
database = mongo_client[config.get('mongo_opt',
{}).get('database', 'INGInious')]
# Create the FS provider
if "tasks_directory" not in config:
raise RuntimeError(
"WebDav access is only supported if INGInious is using a local filesystem to access tasks"
)
fs_provider = LocalFSProvider(config["tasks_directory"])
course_factory, task_factory = create_factories(fs_provider, {}, {}, None)
user_manager = UserManager(database, config.get('superadmins', []))
config = dict(wsgidav_app.DEFAULT_CONFIG)
config["provider_mapping"] = {
"/": INGIniousFilesystemProvider(course_factory, task_factory)
}
config["http_authenticator"]["domain_controller"] = get_dc(
course_factory, user_manager, fs_provider)
config["verbose"] = 0
app = wsgidav_app.WsgiDAVApp(config)
util.init_logging(config)
return app
def verbose_logging() -> None:
# Enable everything that seems like module that could have logging
init_logging({
"verbose":
5,
"enable_loggers": [
"manabi.log",
"manabi.lock",
"lock_manager",
"lock_storage",
"request_resolver",
"request_server",
"http_authenticator",
"property_manager",
"fs_dav_provider",
"dir_browser",
"server",
],
})
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 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"] >= 3:
_logger.warning(
"Could not import lxml: using xml instead (up to 10% slower). "
"Consider `pip install lxml`(see https://pypi.python.org/pypi/lxml)."
)
handler(app, config, server)
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, 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")
raise Exception('no environ in filesystem access')
if 'SSL_CLIENT_S_DN' not in environ:
raise Exception(
'no SSL_CLIENT_S_DN in environ in filesystem access')
dn = dict(
(d.split('=') for d in environ['SSL_CLIENT_S_DN'].split(',')))
if 'CN' not in dn:
raise Exception('CN not in certificate')
new_root = os.path.join(self.ROOT_PATH, dn['CN'])
assert new_root == os.path.abspath(
new_root) # no funny ".." business in CN
p = super()._loc_to_file_path(path, environ)
assert p.startswith(self.ROOT_PATH)
return os.path.join(new_root, p[len(self.ROOT_PATH) + 1:])
config = {
"provider_mapping": {
"/": Files()
},
"simple_dc": {
"user_mapping": {
"*": True
}
}, # anonymous access
"verbose": 3,
}
init_logging(config)
app = WsgiDAVApp(config)
