def __call__(self, environ, start_response):
""""""
# srvcfg = environ["wsgidav.config"]
verbose = self._config.get("verbose", 2)
method = environ["REQUEST_METHOD"]
debugBreak = False
dumpRequest = False
dumpResponse = False
if verbose >= 3:
dumpRequest = dumpResponse = True
# Process URL commands
if "dump_storage" in environ.get("QUERY_STRING"):
dav = environ.get("wsgidav.provider")
if dav.lockManager:
dav.lockManager._dump()
if dav.propManager:
dav.propManager._dump()
# Turn on max. debugging for selected litmus tests
litmusTag = environ.get("HTTP_X_LITMUS",
environ.get("HTTP_X_LITMUS_SECOND"))
if litmusTag and verbose >= 2:
print >> self.out, "----\nRunning litmus test '%s'..." % litmusTag
for litmusSubstring in self.debug_litmus:
if litmusSubstring in litmusTag:
verbose = 3
debugBreak = True
dumpRequest = True
dumpResponse = True
break
for litmusSubstring in self.break_after_litmus:
if litmusSubstring in self.passedLitmus and litmusSubstring not in litmusTag:
print >> self.out, " *** break after litmus %s" % litmusTag
sys.exit(-1)
if litmusSubstring in litmusTag:
self.passedLitmus[litmusSubstring] = True
# Turn on max. debugging for selected request methods
if verbose >= 2 and method in self.debug_methods:
verbose = 3
debugBreak = True
dumpRequest = True
dumpResponse = True
# Set debug options to environment
environ["wsgidav.verbose"] = verbose
# environ["wsgidav.debug_methods"] = self.debug_methods
environ["wsgidav.debug_break"] = debugBreak
environ["wsgidav.dump_request_body"] = dumpRequest
environ["wsgidav.dump_response_body"] = dumpResponse
# Dump request headers
if dumpRequest:
print >> self.out, "<%s> --- %s Request ---" % (
threading._get_ident(), method)
for k, v in environ.items():
if k == k.upper():
print >> self.out, "%20s: '%s'" % (k, v)
print >> self.out, "\n"
# Intercept start_response
#
sub_app_start_response = util.SubAppStartResponse()
nbytes = 0
first_yield = True
app_iter = self._application(environ, sub_app_start_response)
for v in app_iter:
# Start response (the first time)
if first_yield:
# Success!
start_response(sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info)
# Dump response headers
if first_yield and dumpResponse:
print >> self.out, "<%s> --- %s Response(%s): ---" % (
threading._get_ident(), method,
sub_app_start_response.status)
headersdict = dict(sub_app_start_response.response_headers)
for envitem in headersdict.keys():
print >> self.out, "%s: %s" % (envitem,
repr(headersdict[envitem]))
print >> self.out, ""
# Check, if response is a binary string, otherwise we probably have
# calculated a wrong content-length
assert type(v) is str
# Dump response body
drb = environ.get("wsgidav.dump_response_body")
if type(drb) is str:
# Middleware provided a formatted body representation
print >> self.out, 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:
print >> self.out, v[:50], "..."
elif len(v) > 0:
print >> self.out, v
nbytes += len(v)
first_yield = False
yield v
if hasattr(app_iter, "close"):
app_iter.close()
# Start response (if it hasn't been done yet)
if first_yield:
# Success!
start_response(sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info)
if dumpResponse:
print >> self.out, "\n<%s> --- End of %s Response (%i bytes) ---" % (
threading._get_ident(), method, nbytes)
return
def __call__(self, environ, start_response):
""""""
verbose = self._config.get("verbose", 2)
self.last_request_time = "{0}_{1}".format(
datetime.utcnow().strftime("%Y-%m-%d_%H-%M-%S"),
int(round(time.time() * 1000)))
method = environ["REQUEST_METHOD"]
debugBreak = False
dumpRequest = False
dumpResponse = False
if verbose >= 3 or self._config.get("dump_requests"):
dumpRequest = dumpResponse = True
# Process URL commands
if "dump_storage" in environ.get("QUERY_STRING"):
dav = environ.get("wsgidav.provider")
if dav.lockManager:
dav.lockManager._dump()
if dav.propManager:
dav.propManager._dump()
# Turn on max. debugging for selected litmus tests
litmusTag = environ.get("HTTP_X_LITMUS",
environ.get("HTTP_X_LITMUS_SECOND"))
if litmusTag and verbose >= 2:
print("----\nRunning litmus test '%s'..." % litmusTag,
file=self.out)
for litmusSubstring in self.debug_litmus:
if litmusSubstring in litmusTag:
verbose = 3
debugBreak = True
dumpRequest = True
dumpResponse = True
break
for litmusSubstring in self.break_after_litmus:
if litmusSubstring in self.passedLitmus and litmusSubstring not in litmusTag:
print(" *** break after litmus %s" % litmusTag,
file=self.out)
sys.exit(-1)
if litmusSubstring in litmusTag:
self.passedLitmus[litmusSubstring] = True
# Turn on max. debugging for selected request methods
if verbose >= 2 and method in self.debug_methods:
verbose = 3
debugBreak = True
dumpRequest = True
dumpResponse = True
# Set debug options to environment
environ["wsgidav.verbose"] = verbose
# environ["wsgidav.debug_methods"] = self.debug_methods
environ["wsgidav.debug_break"] = debugBreak
environ["wsgidav.dump_request_body"] = dumpRequest
environ["wsgidav.dump_response_body"] = dumpResponse
# Dump request headers
if dumpRequest:
print("<%s> --- %s Request ---" %
(threading.currentThread().ident, method),
file=self.out)
for k, v in environ.items():
if k == k.upper():
print("%20s: '%s'" % (k, v), file=self.out)
print("\n", file=self.out)
self._dump_request(environ, xml=None)
# Intercept start_response
#
sub_app_start_response = util.SubAppStartResponse()
nbytes = 0
first_yield = True
app_iter = self._application(environ, sub_app_start_response)
for v in app_iter:
# Start response (the first time)
if first_yield:
# Success!
start_response(
sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info,
)
# Dump response headers
if first_yield and dumpResponse:
print(
"<%s> --- %s Response(%s): ---" %
(threading.currentThread().ident, method,
sub_app_start_response.status),
file=self.out,
)
headersdict = dict(sub_app_start_response.response_headers)
for envitem in headersdict.keys():
print("%s: %s" % (envitem, repr(headersdict[envitem])),
file=self.out)
print("", file=self.out)
# 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
print(drb, file=self.out)
elif drb is True:
# Else dump what we get, (except for long GET responses)
if method == "GET":
if first_yield:
print(v[:50], "...", file=self.out)
elif len(v) > 0:
print(v, file=self.out)
if dumpResponse:
self._dump_response(sub_app_start_response, drb)
drb = environ["wsgidav.dump_response_body"] = None
nbytes += len(v)
first_yield = False
yield v
if hasattr(app_iter, "close"):
app_iter.close()
# Start response (if it hasn't been done yet)
if first_yield:
start_response(
# Success!
sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info,
)
if dumpResponse:
print(
"\n<%s> --- End of %s Response (%i bytes) ---" %
(threading.currentThread().ident, method, nbytes),
file=self.out,
)
return
def __call__(self, environ, start_response):
""""""
# srvcfg = environ["wsgidav.config"]
verbose = self._config.get("verbose", 3)
method = environ["REQUEST_METHOD"]
debugBreak = False
dumpRequest = False
dumpResponse = False
if verbose >= 5:
dumpRequest = dumpResponse = True
# Process URL commands
if "dump_storage" in environ.get("QUERY_STRING", ""):
dav = environ.get("wsgidav.provider")
if dav.lockManager:
dav.lockManager._dump()
if dav.propManager:
dav.propManager._dump()
# Turn on max. debugging for selected litmus tests
litmusTag = environ.get("HTTP_X_LITMUS",
environ.get("HTTP_X_LITMUS_SECOND"))
if litmusTag and verbose >= 3:
_logger.info("----\nRunning litmus test '{}'...".format(litmusTag))
for litmusSubstring in self.debug_litmus:
if litmusSubstring in litmusTag:
verbose = 5
debugBreak = True
dumpRequest = True
dumpResponse = True
break
for litmusSubstring in self.break_after_litmus:
if litmusSubstring in self.passedLitmus and litmusSubstring not in litmusTag:
_logger.info(
" *** break after litmus {}".format(litmusTag))
sys.exit(-1)
if litmusSubstring in litmusTag:
self.passedLitmus[litmusSubstring] = True
# Turn on max. debugging for selected request methods
if verbose >= 3 and method in self.debug_methods:
verbose = 5
debugBreak = True
dumpRequest = True
dumpResponse = True
# Set debug options to environment
environ["wsgidav.verbose"] = verbose
# environ["wsgidav.debug_methods"] = self.debug_methods
environ["wsgidav.debug_break"] = debugBreak
environ["wsgidav.dump_request_body"] = dumpRequest
environ["wsgidav.dump_response_body"] = dumpResponse
# Dump request headers
if dumpRequest:
_logger.info("{} Request ---".format(method))
# _logger.info("<{}> --- {} Request ---".format(
# threading.currentThread().ident, method))
for k, v in environ.items():
if k == k.upper():
_logger.info("{:<20}: '{}'".format(
k, safe_re_encode(v, "utf8")))
_logger.info("\n")
# Intercept start_response
#
sub_app_start_response = util.SubAppStartResponse()
nbytes = 0
first_yield = True
app_iter = self.next_app(environ, sub_app_start_response)
for v in app_iter:
# Start response (the first time)
if first_yield:
# Success!
start_response(sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info)
# Dump response headers
if first_yield and dumpResponse:
_logger.info("<{}> ---{} Response({}): ---".format(
threading.currentThread().ident, 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()
# Start response (if it hasn't been done yet)
if first_yield:
# Success!
start_response(sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info)
if dumpResponse:
_logger.info("<{}> --- End of {} Response ({:d} bytes) ---".format(
threading.currentThread().ident, method, nbytes))
return
def __call__(self, environ, start_response):
# Intercept start_response
sub_app_start_response = util.SubAppStartResponse()
try:
try:
# request_server app may be a generator (for example the GET handler)
# So we must iterate - not return self._application(..)!
# Otherwise the we could not catch exceptions here.
response_started = False
app_iter = self._application(environ, sub_app_start_response)
for v in app_iter:
# Start response (the first time)
if not response_started:
# Success!
start_response(sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info)
response_started = True
yield v
# Close out iterator
if hasattr(app_iter, "close"):
app_iter.close()
# Start response (if it hasn't been done yet)
if not response_started:
# Success!
start_response(sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info)
return
except DAVError as e:
_logger.debug("re-raising %s" % e)
raise
except Exception as e:
# Caught a non-DAVError
if self._catch_all_exceptions:
# Catch all exceptions to return as 500 Internal Error
traceback.print_exc(10, environ.get(
"wsgi.errors") or sys.stderr)
raise asDAVError(e)
else:
util.warn("ErrorPrinter: caught Exception")
traceback.print_exc(10, sys.stderr)
raise
except DAVError as e:
_logger.debug("caught %s" % e)
status = getHttpStatusString(e)
# Dump internal errors to console
if e.value == HTTP_INTERNAL_ERROR:
print("ErrorPrinter: caught HTTPRequestException("
"HTTP_INTERNAL_ERROR)", file=sys.stdout)
traceback.print_exc(10, environ.get(
"wsgi.errors") or sys.stdout)
print("e.srcexception:\n%s" % e.srcexception, file=sys.stdout)
elif e.value in (HTTP_NOT_MODIFIED, HTTP_NO_CONTENT):
# util.log("ErrorPrinter: forcing empty error response for %s"
# % e.value)
# See paste.lint: these code don't have content
start_response(status, [("Content-Length", "0"),
("Date", util.getRfc1123Time()),
])
yield b""
return
# If exception has pre-/post-condition: return as XML response,
# else return as HTML
content_type, body = e.getResponsePage()
# TODO: provide exc_info=sys.exc_info()?
start_response(status, [("Content-Type", content_type),
("Content-Length", str(len(body))),
("Date", util.getRfc1123Time()),
])
yield body
return
def __call__(self, environ, start_response):
# Intercept start_response
sub_app_start_response = util.SubAppStartResponse()
try:
try:
# request_server app may be a generator (for example the GET handler)
# So we must iterate - not return self.next_app(..)!
# Otherwise the we could not catch exceptions here.
response_started = False
app_iter = self.next_app(environ, sub_app_start_response)
for v in app_iter:
# Start response (the first time)
if not response_started:
# Success!
start_response(
sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info,
)
response_started = True
yield v
# Close out iterator
if hasattr(app_iter, "close"):
app_iter.close()
# Start response (if it hasn't been done yet)
if not response_started:
# Success!
start_response(
sub_app_start_response.status,
sub_app_start_response.response_headers,
sub_app_start_response.exc_info,
)
return
except DAVError as e:
_logger.debug("re-raising {}".format(e))
raise
except Exception as e:
# Caught a non-DAVError
provider = environ.get("wsgidav.provider", None)
if provider:
provider.handle_error_500(environ)
if self._catch_all_exceptions:
# Catch all exceptions to return as 500 Internal Error
# traceback.print_exc(10, environ.get("wsgi.errors") or sys.stderr)
_logger.error("{}".format(traceback.format_exc(10)))
raise as_DAVError(e)
else:
_logger.error("Caught Exception\n{}".format(
traceback.format_exc(10)))
# traceback.print_exc(10, sys.stderr)
raise
except DAVError as e:
_logger.debug("caught {}".format(e))
status = get_http_status_string(e)
# Dump internal errors to console
if e.value == HTTP_INTERNAL_ERROR:
tb = traceback.format_exc(10)
_logger.error(
"Caught HTTPRequestException(HTTP_INTERNAL_ERROR)\n{}".
format(tb))
# traceback.print_exc(10, environ.get("wsgi.errors") or sys.stdout)
_logger.error("e.src_exception:\n{}".format(e.src_exception))
elif e.value in (HTTP_NOT_MODIFIED, HTTP_NO_CONTENT):
# _logger.warn("Forcing empty error response for {}".format(e.value))
# See paste.lint: these code don't have content
start_response(status, [("Content-Length", "0"),
("Date", util.get_rfc1123_time())])
yield b""
return
# If exception has pre-/post-condition: return as XML response,
# else return as HTML
content_type, body = e.get_response_page()
# TODO: provide exc_info=sys.exc_info()?
if e.value == 403:
headers = [("X-MSDAVEXT_Error",
"131135; Insufficient permissions.")]
else:
headers = []
start_response(
status,
[
("Content-Type", content_type),
("Content-Length", str(len(body))),
("Date", util.get_rfc1123_time()),
] + headers,
)
yield body
return
