#2687 - Include mimeo python module

modules/adblockplus/files/mimeo.py

 #!/usr/bin/env python3
 
 import argparse
 import re
 import sys
 import threading
 import traceback
 
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from string import Template
 
 # The token used for the headers passed by nginx is: http_
-REGEX = r'\$http_[\w]+\b'

[Vasily Kuznetsov, 2017/08/15 18:56:25]

Square brackets are not necessary around '\w', it could be just r'\$http_\w+\b'

[f.lopez, 2017/08/16 00:54:31]

Done.

+REGEX = r'\$http_\w+\b'
 DEFAULT_LOG = '$remote_addr - - [$time_local] "$request" $status $bytes_sent'
 _lock = threading.Lock()
 
 
 class Handler(BaseHTTPRequestHandler):
     def get_header_values(self):
         values = {}
         headers = re.findall(REGEX, self.format)
         for name in headers:
-            new_var = name[6:]
+            new_var = name[6:].replace('_', '-')
             values[name[1:]] = self.headers.get(new_var, '-')
         return values
 
     def send_simple_response(self, status, response=None):
         self.send_response(status)
         self.end_headers()
         if response is None:
             response = bytes(self.responses[status][0], 'UTF-8')
         self.wfile.write(response)
 
     def write_info(self, args):
-        _lock.acquire()
-        try:
-            message = Template(self.format)
-            self.output.write(message.safe_substitute(args) + '\n')
+        message = Template(self.format).safe_substitute(args) + '\n'
+        with _lock:
+            self.output.write(message)
             self.output.flush()
-        except Exception:

[Vasily Kuznetsov, 2017/08/15 18:56:25]

You can just write `except` instead of `except Exception`.

[f.lopez, 2017/08/16 00:54:31]

Done.

-            traceback.print_exc(file=sys.stderr)
-            self.send_simple_response(500)

[Vasily Kuznetsov, 2017/08/15 18:56:25]

When `write_info` returns, the code will try to send response again (in line
58), and that will probably not go well. Perhaps it would be better to move the
exception logging/handling to the outer function (do_POST) and only leave
try/finally here.

[f.lopez, 2017/08/16 00:54:32]

What if I use this function to return the code instead?

if it catches an exception I send back a 500 and if not I send back a 200?, that
way I can actually have more control over the main functionality of the script,
so for different errors/conditionals I can even return different status codes?

And then in the line 58 I just send the `status` I got from the function?

[Vasily Kuznetsov, 2017/08/16 11:32:27]

Yes, this approach can work too, although you would also need to deal with the
different content in 200 and 500 responses. Perhaps `write_info` could return
`True/False` depending on whether it managed to write things out successfully.
You'd end up with something like this:

    def write_info(self, args):
        _lock.acquire()
        try:
            # ...
        except:
            traceback.print_exc(file=sys.stderr)
            return False
        finally:
            _lock.release()
        return True

    def do_POST(self):
        # ...
        if self.write_info(values):
            self.send_simple_response(status, content)
        else:
            self.send_simple_response(500)

However, I think the code would be simpler and have less branching if you just
move all exception handling to the outside, like this:

    def write_info(self, args):
        _lock.acquire()
        try:
            # ...
        finally:
            _lock.release()

    def do_POST(self):
        # ...
        try:
            self.write_info(values)
            self.send_simple_response(status, content)
        except:
            traceback.print_exc(file=sys.stderr)
            self.send_simple_response(500)

With this approach, you can also use the fact that locks support context manager
protocol [1] and rewrite `write_info` using `with` for additional style points:

    def write_info(self, args):
        with _lock:
            # ...

[1]: https://docs.python.org/3.6/library/threading.html#with-locks

-        finally:
-            _lock.release()
 
     def do_POST(self):
         status = 200
         content = bytes(self.response, 'UTF-8')
         values = {
             'remote_addr': self.address_string(),
             'time_local': self.log_date_time_string(),
             'request': self.requestline,
             'status': status,
             'bytes_sent': len(content),
         }
         values.update(self.get_header_values())
-        self.write_info(values)
-        self.send_simple_response(status, content)
+        try:
+            self.write_info(values)
+            self.send_simple_response(status, content)
+        except:
+            traceback.print_exc(file=sys.stderr)
+            self.send_simple_response(500)
 
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
     parser.add_argument('--port', action='store',
                         default=8000, type=int,
                         nargs='?',
                         help='Port to use [default: 8000]')
     parser.add_argument('--response', action='store',
                         type=str, nargs='?', default='OK',
                         help='The response send to the client')
     parser.add_argument('--format', action='store',
                         type=str, nargs='?',
                         default=DEFAULT_LOG,
                         help='Format of the log ouput')
     parser.add_argument('output', action='store',
                         type=str, nargs='?', default='-',
                         help='The file where the logs will be written')
     args = parser.parse_args()
     if args.output and args.output != '-':
         fh = open(args.output, 'a')
     else:
-        fh = sys.stdout
-    Handler.output = fh
-    Handler.format = args.format
-    Handler.response = args.response
-    server_address = ('', args.port)
-    httpd = HTTPServer(server_address, Handler)
+        fh = open(sys.stdout.fileno(), 'w', closefd=False)
     try:
+        Handler.output = fh
+        Handler.format = args.format
+        Handler.response = args.response
+        server_address = ('', args.port)
+        httpd = HTTPServer(server_address, Handler)
         httpd.serve_forever()
-    except:
-        if args.output != '-':
-            fh.close()
+    finally:
+        fh.close()