WebDav HTTP dump of requests

install/requirements.txt

 -e git+https://github.com/algoo/wsgidav.git@py3#egg=wsgidav
 zope.interface==4.1.3
 zope.sqlalchemy==0.7.6
-
+PyYAML

tracim/tracim/lib/daemons.py

 import threading
 from configparser import DuplicateSectionError
+from datetime import datetime
 from wsgiref.simple_server import make_server
 import signal
 
 import collections
-import transaction
+import time
+
+import io
+import yaml
 
 from radicale import Application as RadicaleApplication
 from radicale import HTTPServer as BaseRadicaleHTTPServer
 from inspect import isfunction
 import traceback
 
+from wsgidav.server.cherrypy import wsgiserver
+from wsgidav.server.cherrypy.wsgiserver.wsgiserver3 import \
+    HTTPConnection as BaseHTTPConnection
+from wsgidav.server.cherrypy.wsgiserver.wsgiserver3 import \
+    HTTPRequest as BaseHTTPRequest
+
 DEFAULT_CONFIG_FILE = "wsgidav.conf"
 PYTHON_VERSION = "%s.%s.%s" % (sys.version_info[0], sys.version_info[1], sys.version_info[2])
 
 
+class HTTPRequest(BaseHTTPRequest):
+    """
+    Exeprimental override of HTTPRequest designed to permit
+    dump of HTTP requests
+    """
+    def parse_request(self, can_dump: bool=True):
+        super().parse_request()
+        dump = self.server.wsgi_app.config.get('dump_requests', False)
+        if self.ready and dump and can_dump:
+            dump_to_path = self.server.wsgi_app.config.get(
+                'dump_requests_path',
+                '/tmp/wsgidav_dumps',
+            )
+            self.dump(dump_to_path)
+
+    def dump(self, dump_to_path: str):
+        if self.ready:
+            os.makedirs(dump_to_path, exist_ok=True)
+            dump_file = '{0}/{1}_{2}.yml'.format(
+                dump_to_path,
+                '{0}_{1}'.format(
+                    datetime.utcnow().strftime('%Y-%m-%d_%H-%I-%S'),
+                    int(round(time.time() * 1000)),
+                ),
+                self.method.decode('utf-8'),
+            )
+            with open(dump_file, 'w+') as f:
+                dump_content = dict()
+                dump_content['path'] = self.path.decode('ISO-8859-1')
+                str_headers = dict(
+                    (k.decode('utf8'), v.decode('ISO-8859-1')) for k, v in
+                    self.inheaders.items()
+                )
+                dump_content['headers'] = str_headers
+                dump_content['content'] = self.conn.read_content\
+                    .decode('ISO-8859-1')
+
+                f.write(yaml.dump(dump_content, default_flow_style=False))
+
+
+class HTTPConnection(BaseHTTPConnection):
+    """
+    Exeprimental override of HTTPConnection designed to permit
+    dump of HTTP requests
+    """
+    RequestHandlerClass = HTTPRequest
+
+    def __init__(self, server, sock, *args, **kwargs):
+        super().__init__(server, sock, *args, **kwargs)
+
+        if self.server.wsgi_app.config.get('dump_requests', False):
+            # We use HTTPRequest to parse headers, path, etc ...
+            req = self.RequestHandlerClass(self.server, self)
+            req.parse_request(can_dump=False)
+
+            # And we read request content
+            content_length = int(req.inheaders.get(b'Content-Length', b'0'))
+            content = req.rfile.read(content_length)
+
+            # We are now able to rebuild HTTP request
+            full_content = \
+                req.method + \
+                b' ' + \
+                req.uri + \
+                b' ' + \
+                req.request_protocol +\
+                b'\r\n'
+            for header_name, header_value in req.inheaders.items():
+                full_content += header_name + b': ' + header_value + b'\r\n'
+
+            full_content += b'\r\n' + content
+
+            # To give it again at HTTPConnection
+            bf = io.BufferedReader(io.BytesIO(full_content), self.rbufsize)
+
+            self.rfile = bf
+            # We will be able to dump request content with self.read_content
+            self.read_content = content
+
+
+class CherryPyWSGIServer(wsgiserver.CherryPyWSGIServer):
+    ConnectionClass = HTTPConnection
+
+
 class WsgiDavDaemon(Daemon):
 
     def __init__(self, *args, **kwargs):
         app = WsgiDAVApp(self.config)
 
         # Try running WsgiDAV inside the following external servers:
-        self._runCherryPy(app, self.config, "cherrypy-bundled")
-
-    def _runCherryPy(self, app, config, mode):
-        """Run WsgiDAV using cherrypy.wsgiserver, if CherryPy is installed."""
-        assert mode in ("cherrypy", "cherrypy-bundled")
-
-        try:
-            from wsgidav.server.cherrypy import wsgiserver
+        self._runCherryPy(app, self.config)
 
-            version = "WsgiDAV/%s %s Python/%s" % (
-                __version__,
-                wsgiserver.CherryPyWSGIServer.version,
-                PYTHON_VERSION)
+    def _runCherryPy(self, app, config):
+        version = "WsgiDAV/%s %s Python/%s" % (
+            __version__,
+            wsgiserver.CherryPyWSGIServer.version,
+            PYTHON_VERSION
+        )
 
-            wsgiserver.CherryPyWSGIServer.version = version
+        wsgiserver.CherryPyWSGIServer.version = version
 
-            protocol = "http"
+        protocol = "http"
 
-            if config["verbose"] >= 1:
-                print("Running %s" % version)
-                print("Listening on %s://%s:%s ..." % (protocol, config["host"], config["port"]))
-            self._server = wsgiserver.CherryPyWSGIServer(
-                (config["host"], config["port"]),
-                app,
-                server_name=version,
-            )
+        if config["verbose"] >= 1:
+            print("Running %s" % version)
+            print("Listening on %s://%s:%s ..." % (protocol, config["host"], config["port"]))
+        self._server = CherryPyWSGIServer(
+            (config["host"], config["port"]),
+            app,
+            server_name=version,
+        )
 
-            self._server.start()
-        except ImportError as e:
-            if config["verbose"] >= 1:
-                print("Could not import wsgiserver.CherryPyWSGIServer.")
-            return False
-        return True
+        self._server.start()
 
     def stop(self):
         self._server.stop()

tracim/tracim/lib/webdav/sql_resources.py

         # thus we want to rename a file from 'file.txt' to 'file - deleted... .txt' and not 'file.txt - deleted...'
         is_file_name = self.content.label == ''
         if is_file_name:
-            extension = re.search(r'(\.[^.]+)$', new_name).group(0)
+            search = re.search(r'(\.[^.]+)$', new_name)
+            if search:
+                extension = search.group(0)
             new_name = re.sub(r'(\.[^.]+)$', '', new_name)
 
         if self._type in [ActionDescription.ARCHIVING, ActionDescription.DELETION]: