Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
"href": href,
"ofe_prefix": ofe_prefix,
"a_class": " ".join(a_classes),
"tr_class": " ".join(tr_classes),
"display_name": res.get_display_name(),
"last_modified": res.get_last_modified(),
"is_collection": res.is_collection,
"content_length": res.get_content_length(),
"display_type": di.get("type"),
"display_type_comment": di.get("typeComment"),
}
dirInfoList.append(entry)
#
ignore_patterns = self.dir_config.get("ignore", [])
if compat.is_basestring(ignore_patterns):
ignore_patterns = ignore_patterns.split(",")
ignored_list = []
for entry in dirInfoList:
# Skip ignore patterns
ignore = False
for pat in ignore_patterns:
if fnmatch(entry["display_name"], pat):
ignored_list.append(entry["display_name"])
# _logger.debug("Ignore {}".format(entry["display_name"]))
ignore = True
break
if ignore:
continue
#
last_modified = entry.get("last_modified")
def add_provider(self, share, provider, readonly=False):
"""Add a provider to the provider_map routing table."""
# Make sure share starts with, or is '/'
share = "/" + share.strip("/")
assert share not in self.provider_map
if compat.is_basestring(provider):
# Syntax:
# :
# We allow a simple string as 'provider'. In this case we interpret
# it as a file system root folder that is published.
provider = FilesystemProvider(provider, readonly)
elif type(provider) in (dict,):
if "provider" in provider:
# Syntax:
# : {"provider": , "args": , "kwargs": : {"root":
def write(self, chunk):
"""Put a chunk of bytes (or an iterable) to the queue.
May block if max_size number of chunks is reached.
"""
if self.is_closed:
raise ValueError("Cannot write to closed object")
# print("FileLikeQueue.write(), n={}".format(len(chunk)))
# Add chunk to queue (blocks if queue is full)
if compat.is_basestring(chunk):
self.queue.put(chunk)
else: # if not a string, assume an iterable
for o in chunk:
self.queue.put(o)
method,
sub_app_start_response.status,
)
)
headersdict = dict(sub_app_start_response.response_headers)
for envitem in headersdict.keys():
_logger.info("{}: {}".format(envitem, repr(headersdict[envitem])))
_logger.info("")
# Check, if response is a binary string, otherwise we probably have
# calculated a wrong content-length
assert compat.is_bytes(v), v
# Dump response body
drb = environ.get("wsgidav.dump_response_body")
if compat.is_basestring(drb):
# Middleware provided a formatted body representation
_logger.info(drb)
drb = environ["wsgidav.dump_response_body"] = None
elif drb is True:
# Else dump what we get, (except for long GET responses)
if method == "GET":
if first_yield:
_logger.info("{}...".format(v[:50]))
elif len(v) > 0:
_logger.info(v)
nbytes += len(v)
first_yield = False
yield v
if hasattr(app_iter, "close"):
app_iter.close()
def __init__(self, path, environ, display_info, member_name_list):
super(VirtualCollection, self).__init__(path, environ)
if compat.is_basestring(display_info):
display_info = {"type": display_info}
assert type(display_info) is dict
assert type(member_name_list) is list
self.display_info = display_info
self.member_name_list = member_name_list
def make_domain_controller(wsgidav_app, config):
dc = config.get("http_authenticator", {}).get("domain_controller")
org_dc = dc
if dc is True or not dc:
# True or null:
dc = SimpleDomainController
elif compat.is_basestring(dc):
# If a plain string is passed, try to import it as class
dc = dynamic_import_class(dc)
if inspect.isclass(dc):
# If a class is passed, instantiate that
dc = dc(wsgidav_app, config)
else:
raise RuntimeError(
"Could not resolve domain controller class (got {})".format(org_dc)
)
# print("make_domain_controller", dc)
return dc