Adds html info page served at /

dcolligan · dcolligan · commit 7fa289dfe22a · 2015-02-06T12:35:24.000-08:00
Also contains exception handling improvements / tests Issue ga4gh#111
diff --git a/ga4gh/frontend.py b/ga4gh/frontend.py
@@ -9,15 +9,54 @@
 
 import os
 import traceback
+import datetime
 
 import flask
 import flask.ext.api as api
 import flask.ext.cors as cors
+import humanize
 
 import ga4gh.frontend_exceptions as frontendExceptions
 import ga4gh.protocol as protocol
 
-app = api.FlaskAPI(__name__)
+
+app = flask.Flask(__name__)
+
+
+class ServerStatus(object):
+
+    def __init__(self):
+        self.startupTime = datetime.datetime.now()
+
+    def getStatusInfo(self):
+        info = {
+            'urls': self._getUrls(),
+            'uptime': self._getUptime(),
+            'version': protocol.version,
+        }
+        return info
+
+    def _getUptime(self):
+        uptime = {
+            'natural': humanize.naturaltime(self.startupTime),
+            'datetime': self.startupTime.strftime("%H:%M:%S %d %b %Y")
+        }
+        return uptime
+
+    def _getUrls(self):
+        urls = []
+        rules = app.url_map.iter_rules()
+        excluded_methods = ('OPTIONS', 'HEAD')
+        excluded_rules = (
+            '/', '/flask-api/static/<path:filename>',
+            '/static/<path:filename>')
+        for rule in rules:
+            for method in rule.methods:
+                if (method not in excluded_methods and
+                        rule.rule not in excluded_rules):
+                        urls.append((rule.rule, method))
+        urls.sort()
+        return urls
 
 
 def configure(config="DefaultConfig", config_file=None):
@@ -28,6 +67,7 @@ def configure(config="DefaultConfig", config_file=None):
     if config_file is not None:
         app.config.from_pyfile(config_file)
     cors.CORS(app, allow_headers='Content-Type')
+    app.serverStatus = ServerStatus()
 
 
 def handleHTTPPost(request, endpoint):
@@ -52,7 +92,12 @@ def handleHTTPOptions():
 
 
 @app.errorhandler(Exception)
-def handle_error(exception):
+def handleException(exception):
+    exceptionClass = exception.__class__
+    if exceptionClass in frontendExceptions.exceptionMap:
+        newExceptionClass = frontendExceptions.exceptionMap[exceptionClass]
+        exception = newExceptionClass()
+
     if not isinstance(exception, frontendExceptions.FrontendException):
         if app.config['DEBUG']:
             print(traceback.format_exc(exception))
@@ -68,7 +113,8 @@ def handle_error(exception):
 
 @app.route('/')
 def index():
-    raise frontendExceptions.PathNotFoundException()
+    return flask.render_template(
+        'index.html', info=app.serverStatus.getStatusInfo())
 
 
 @app.route('/references/<id>', methods=['GET'])
diff --git a/ga4gh/frontend_exceptions.py b/ga4gh/frontend_exceptions.py
@@ -6,6 +6,8 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
+import flask.ext.api as api
+
 
 class FrontendException(Exception):
 
@@ -74,3 +76,20 @@ def __init__(self):
         self.httpStatus = 500
         self.message = "Internal server error"
         self.code = 7
+
+
+class UnsupportedMediaTypeException(FrontendException):
+
+    def __init__(self):
+        super(FrontendException, self).__init__()
+        self.httpStatus = 415
+        self.message = "Unsupported media type"
+        self.code = 8
+
+
+# exceptions thrown by the underlying system that we want to
+# translate to exceptions that we define before they are
+# serialized and returned to the client
+exceptionMap = {
+    api.exceptions.UnsupportedMediaType: UnsupportedMediaTypeException,
+}
diff --git a/ga4gh/templates/index.html b/ga4gh/templates/index.html
@@ -0,0 +1,25 @@
+<html>
+    <head>
+        <title>GA4GH reference server {{ info.version }}</title>
+    </head>
+    <body>
+        <h2>GA4GH reference server {{ info.version }}</h2>
+        <div>
+            <h3>Operations available</h3>
+            <table>
+                <th>Method</th>
+                <th>Path</th>
+            {% for rule in info.urls %}
+            <tr>
+                <td>{{ rule[1] }}</td>
+                <td>{{ rule[0] }}</td>
+            </tr>
+            {% endfor %}
+        </table>
+        </div>
+        <div>
+            <h3>Uptime</h3>
+            Running since {{ info.uptime.natural }} ({{ info.uptime.datetime }})
+        </div>
+    </body>
+</html>
diff --git a/requirements.txt b/requirements.txt
@@ -5,6 +5,7 @@ avro
 coverage
 flake8
 guppy
+humanize
 mock
 nose
 pep8
diff --git a/tests/test_exceptions.py b/tests/test_exceptions.py
@@ -9,7 +9,51 @@
 import unittest
 import inspect
 
+import mock
+
 import ga4gh.frontend_exceptions as frontendExceptions
+import ga4gh.frontend as frontend
+
+
+class TestExceptionHandler(unittest.TestCase):
+    """
+    Test that caught exceptions are handled correctly
+    """
+    class UnknownException(Exception):
+        pass
+
+    class DummyFlask(object):
+
+        def __call__(self, *args):
+            return TestExceptionHandler.DummyResponse()
+
+    class DummyResponse(object):
+        pass
+
+    def run(self, *args, **kwargs):
+        # patching is required because flask.jsonify throws an exception
+        # if not being called in a running app context
+        dummyFlask = self.DummyFlask()
+        with mock.patch('flask.jsonify', dummyFlask):
+            super(TestExceptionHandler, self).run(*args, **kwargs)
+
+    def testMappedException(self):
+        for originalExceptionClass, mappedExceptionClass in \
+                frontendExceptions.exceptionMap.items():
+            originalException = originalExceptionClass()
+            mappedException = mappedExceptionClass()
+            response = frontend.handleException(originalException)
+            self.assertEquals(response.status_code, mappedException.httpStatus)
+
+    def testFrontendException(self):
+        exception = frontendExceptions.ObjectNotFoundException()
+        response = frontend.handleException(exception)
+        self.assertEquals(response.status_code, 404)
+
+    def testUnknownExceptionBecomesServerError(self):
+        exception = self.UnknownException()
+        response = frontend.handleException(exception)
+        self.assertEquals(response.status_code, 500)
 
 
 class TestFrontendExceptionConsistency(unittest.TestCase):
@@ -18,24 +62,33 @@ class TestFrontendExceptionConsistency(unittest.TestCase):
     - every frontend exception has a non-None error code
         - except FrontendException, which does
     - every frontend exception has a unique error code
+    - every value in exceptionMap
+        - is able to instantiate a new no-argument exception instance
+        - derives from the base frontend exception type
     """
 
     def _getFrontendExceptionClasses(self):
 
-        def isClassAndExceptionSubclass(clazz):
-            return inspect.isclass(clazz) and issubclass(clazz, Exception)
+        def isClassAndExceptionSubclass(class_):
+            return inspect.isclass(class_) and issubclass(class_, Exception)
 
         classes = inspect.getmembers(
             frontendExceptions, isClassAndExceptionSubclass)
-        return [clazz for _, clazz in classes]
+        return [class_ for _, class_ in classes]
 
     def testCodeInvariants(self):
         codes = set()
-        for clazz in self._getFrontendExceptionClasses():
-            instance = clazz()
-            assert instance.code not in codes
+        for class_ in self._getFrontendExceptionClasses():
+            instance = class_()
+            self.assertTrue(instance.code not in codes)
             codes.add(instance.code)
-            if clazz == frontendExceptions.FrontendException:
-                assert instance.code is None
+            if class_ == frontendExceptions.FrontendException:
+                self.assertIsNone(instance.code)
             else:
-                assert instance.code is not None
+                self.assertIsNotNone(instance.code)
+
+    def testExceptionMap(self):
+        for exceptionClass in frontendExceptions.exceptionMap.values():
+            exception = exceptionClass()
+            self.assertIsInstance(
+                exception, frontendExceptions.FrontendException)
diff --git a/tests/test_views.py b/tests/test_views.py
@@ -30,7 +30,7 @@ def sendVariantSetsSearch(self, data):
                              data=data)
 
     def testServer(self):
-        self.assertEqual(404, self.app.get('/').status_code)
+        self.assertEqual(404, self.app.get('/doesNotExist').status_code)
 
     def testCors(self):
         def assertHeaders(response):
