server: prefix private methods with '__'

ffstatus/server.py

@@ -64,7 +64,7 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         BaseHTTPRequestHandler.__init__(
             self, request, client_address, sockserver)
 
-    def parse_url_pathquery(self):
+    def __parse_url_pathquery(self):
         """Extracts the query parameters from the request path."""
         url = re.match(r'^/(?P<path>.*?)(\?(?P<query>.+))?$', self.path.strip())
         if url is None:
@@ -81,29 +81,29 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
     def do_GET(self):
         """Handles all HTTP GET requests."""
 
-        path, query = self.parse_url_pathquery()
+        path, query = self.__parse_url_pathquery()
         if path is None:
             self.send_error(400, 'Could not parse URL (' + str(self.path) + ')')
             return
 
         # / - index page, shows generic help
         if path == '':
-            self.respond_index(query)
+            self.__respond_index(query)
             return
 
         # /list - list stored nodes
         if path == 'list':
-            self.respond_list(query)
+            self.__respond_list(query)
             return
 
         # /vpn - notification endpoint for gateway's VPN connections
         if path == 'vpn':
-            self.respond_vpn(query)
+            self.__respond_vpn(query)
             return
 
         # /providers
         if path == 'providers':
-            self.respond_providers(query)
+            self.__respond_providers(query)
             return
 
         # /node/<id>.json - node's data
@@ -113,15 +113,15 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
             cmd = match.group('cmd')
             nodeid = match.group('id').lower()
             if cmd == '.json':
-                self.respond_node(nodeid)
+                self.__respond_node(nodeid)
             else:
-                self.respond_nodedetail(nodeid, cmd[1:])
+                self.__respond_nodedetail(nodeid, cmd[1:])
             return
 
         # /status/<id> - node's status
         match = REGEX_URL_NODESTATUS.match(path)
         if match is not None:
-            self.respond_nodestatus(match.group(1))
+            self.__respond_nodestatus(match.group(1))
             return
 
         # no match -> 404
@@ -130,21 +130,21 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
     def do_POST(self):
         """Handles all HTTP POST requests."""
 
-        path, query = self.parse_url_pathquery()
+        path, query = self.__parse_url_pathquery()
         if path is None:
             self.send_error(400, 'Could not parse URL (' + str(self.path) + ')')
             return
-        params = self.parse_post_params()
+        params = self.__parse_post_params()
 
         # node id/mac to name mapping
         if path == 'idmac2name':
-            self.respond_nodeidmac2name(params)
+            self.__respond_nodeidmac2name(params)
             return
 
         # no match -> 404
         self.send_error(404, 'The URL \'{0}\' was not found here.'.format(path))
 
-    def send_nocache_headers(self):
+    def __send_nocache_headers(self):
         """
         Sets HTTP headers indicating that this response shall not be cached.
         """
@@ -153,21 +153,21 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         self.send_header('Pragma', 'no-cache')
         self.send_header('Expires', '0')
 
-    def send_headers(self,
-                     content_type='text/html; charset=utf-8',
-                     nocache=True, extra={}):
+    def __send_headers(self,
+                       content_type='text/html; charset=utf-8',
+                       nocache=True, extra={}):
         """Send HTTP 200 Response header with the given Content-Type.
         Optionally send no-caching headers, too."""
 
         self.send_response(200)
         self.send_header('Content-Type', content_type)
         if nocache:
-            self.send_nocache_headers()
+            self.__send_nocache_headers()
         for key in extra:
             self.send_header(key, extra[key])
         self.end_headers()
 
-    def parse_post_params(self):
+    def __parse_post_params(self):
         ctype, pdict = cgi.parse_header(self.headers.getheader('content-type'))
 
         if ctype == 'multipart/form-data':
@@ -185,11 +185,11 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
 
         return postvars
 
-    def respond_index(self, query):
+    def __respond_index(self, query):
         """Display the index page."""
 
         storage = self.server.storage
-        self.send_headers()
+        self.__send_headers()
 
         self.wfile.write('<!DOCTYPE html><html><head><title>BATCAVE</title></head>\n')
         self.wfile.write('<body>\n')
@@ -212,10 +212,10 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         self.wfile.write('</dl>\n')
         self.wfile.write('</body></html>')
 
-    def respond_list(self, query):
+    def __respond_list(self, query):
         """List stored data."""
 
-        self.send_headers()
+        self.__send_headers()
 
         self.wfile.write('<!DOCTYPE html><html>\n')
         self.wfile.write('<head><title>BATCAVE</title></head>\n')
@@ -240,7 +240,7 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         self.wfile.write('</tbody>\n')
         self.wfile.write('</table>\n')
 
-    def respond_node(self, rawid):
+    def __respond_node(self, rawid):
         """Display node data."""
 
         # search node by the given id
@@ -252,10 +252,10 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
             return
 
         # dump node data as JSON
-        self.send_headers('text/json')
+        self.__send_headers('text/json')
         self.wfile.write(json.dumps(node))
 
-    def respond_nodestatus(self, rawid):
+    def __respond_nodestatus(self, rawid):
         """Display node status."""
 
         status = self.server.storage.get_nodestatus(rawid)
@@ -263,13 +263,13 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         if status is None:
             self.send_error(404, 'No node with id \'' + rawid + '\' present.')
 
-        self.send_headers('text/plain')
+        self.__send_headers('text/plain')
         self.wfile.write(status)
 
-    def respond_nodeidmac2name(self, ids):
+    def __respond_nodeidmac2name(self, ids):
         """Return a mapping of the given IDs (or MACs) into their hostname."""
 
-        self.send_headers('text/plain')
+        self.__send_headers('text/plain')
         for nodeid in ids:
             node = None
             if not ':' in nodeid:
@@ -279,7 +279,7 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
             nodename = node.get('hostname', nodeid) if node is not None else nodeid
             self.wfile.write('{0}={1}\n'.format(nodeid, nodename))
 
-    def respond_nodedetail(self, nodeid, field):
+    def __respond_nodedetail(self, nodeid, field):
         """
         Return a field from the given node.
         String and integers are returned as text/plain,
@@ -310,10 +310,10 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
             value = len(value)
 
         no_json = isinstance(value, basestring) or isinstance(value, int)
-        self.send_headers('text/plain' if no_json else 'text/json')
+        self.__send_headers('text/plain' if no_json else 'text/json')
         self.wfile.write(value if no_json else json.dumps(value))
 
-    def respond_vpn(self, query):
+    def __respond_vpn(self, query):
         storage = self.server.storage
         peername = query.get('peer')
         key = query.get('key')
@@ -323,7 +323,7 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         timestamp = query.get('ts', time.time())
 
         if action == 'list':
-            self.respond_vpnlist()
+            self.__respond_vpnlist()
             return
 
         if action != 'establish' and action != 'disestablish':
@@ -346,10 +346,10 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         try:
             if action == 'establish':
                 self.server.storage.log_vpn_connect(
-                    key, peername, remote, gw, ts)
+                    key, peername, remote, gateway, timestamp)
 
             elif action == 'disestablish':
-                self.server.storage.log_vpn_connect(key, gw, ts)
+                self.server.storage.log_vpn_connect(key, gateway, timestamp)
 
             else:
                 self.logger.error('Unknown VPN action \'%s\' not filtered.',
@@ -364,13 +364,13 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
             self.send_error(400, 'Bad key.')
             return
 
-        self.send_headers('text/plain')
+        self.__send_headers('text/plain')
         self.wfile.write('OK')
 
         storage.save()
 
-    def respond_vpnlist(self):
-        self.send_headers()
+    def __respond_vpnlist(self):
+        self.__send_headers()
         self.wfile.write('<!DOCTYPE html>\n')
         self.wfile.write('<html><head><title>BATCAVE - VPN LIST</title></head>\n')
         self.wfile.write('<body>\n')
@@ -412,7 +412,7 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         self.wfile.write('</body>')
         self.wfile.write('</html>')
 
-    def respond_providers(self, query):
+    def __respond_providers(self, query):
         """Return a summary of providers."""
 
         outputformat = query['format'].lower() if 'format' in query else 'html'
@@ -469,14 +469,14 @@ class BatcaveHttpRequestHandler(BaseHTTPRequestHandler):
         isps_sum = sum([isps[x] for x in isps])
 
         if outputformat == 'csv':
-            self.send_headers('text/csv')
+            self.__send_headers('text/csv')
 
             self.wfile.write('Count;Name\n')
             for isp in isps:
                 self.wfile.write('{0};"{1}"\n'.format(isps[isp], isp))
 
         elif outputformat == 'json':
-            self.send_headers('text/json')
+            self.__send_headers('text/json')
 
             data = [
                 {