Class Based Checks

ping/checks.py

@@ -1,7 +1,15 @@
+import inspect
+from time import time
+
 from django.conf import settings
 from django.utils.importlib import import_module
 from django.core.exceptions import ImproperlyConfigured
 
+#Check requirements
+from django.core.cache import cache
+from django.contrib.sites.models import Site
+from django.contrib.sessions.models import Session
+
 from ping.defaults import *
 
 def checks(request):
@@ -22,87 +30,89 @@ def checks(request):
             except ImportError as e:
                 raise ImproperlyConfigured('Error importing module %s: "%s"' % (module, e))
             try:
-                func = getattr(mod, attr)
+                check = getattr(mod, attr)
             except AttributeError:
                 raise ImproperlyConfigured('Module "%s" does not define a "%s" callable' % (module, attr))
 
-            key, value = func(request)
-            response_dict[key] = value
 
+            #If check is a class, create instance of it and call
+            #the _check method
+            #Otherwise, just call the check directly
+            if inspect.isclass(check):
+                instance = check(request)
+                response_dict.update(instance._check(request))
+            else:
+                check(request)
+
     return response_dict
 
-#DEFAULT SYSTEM CHECKS
 
-#Database    
-def check_database_sessions(request):
-    from django.contrib.sessions.models import Session
-    try:
-        session = Session.objects.all()[0]
-        return 'db_sessions', True
-    except:
-        return 'db_sessions', False
+class Check(object):
 
-def check_database_sites(request):
-    from django.contrib.sites.models import Site
-    try:
-        session = Site.objects.all()[0]
-        return 'db_site', True
-    except:
-        return 'db_site', False
-
-
-#Caching
-CACHE_KEY = 'django-ping-test'
-CACHE_VALUE = 'abc123'
-
-def check_cache_set(request):        
-    from django.core.cache import cache
-    try:
-        cache.set(CACHE_KEY, CACHE_VALUE, 30)
-        return 'cache_set', True
-    except:
-        return 'cache_set', False
+    def __init__(self, request):
+        pass
+
+    def _check(self, request):
+        if hasattr(self, 'key'):
+            response = {}
+            start = time()
+
+            response[self.key] = self.check(request)
 
-def check_cache_get(request):        
-    from django.core.cache import cache
-    try:
-        data = cache.get(CACHE_KEY)
-        if data == CACHE_VALUE:
-            return 'cache_get', True
+            finished = str(time() - start)
+            response[self.key]['time'] = finished
+            if hasattr(self, 'description'):
+                response[self.key]['description'] = self.description
+            return response
         else:
-            return 'cache_get', False
-    except:
-        return 'cache_get', False
+            raise AttributeError("Class %s must define a 'key' value." % self.__class__.__name__)
+
+    def check(self, request):
+        return {}
 
 
-#User
-def check_user_exists(request):        
-    from django.contrib.auth.models import User
-    try:
-        username = request.GET.get('username')
-        u = User.objects.get(username=username)
-        return 'user_exists', True
-    except:
-        return 'user_exists', False
+#DEFAULT SYSTEM CHECKS
+#Database
+class CheckDatabaseSessions(Check):
+    key = 'db_sessions'
+    description = "Queries the database for a Session."
+    def check(self, request):
+        try:
+            session = Session.objects.all()[0]
+            return {'success': True}
+        except:
+            return {'success': False}
 
+class CheckDatabaseSites(Check):
+    key = 'db_sites'
+    description = "Queries the database for a Site entry."
+    def check(self, request):
+        try:
+            session = Site.objects.all()[0]
+            return {'success':True}
+        except:
+            return {'success': False}
 
-#Celery
-def check_celery(request):
-    from datetime import datetime, timedelta
-    from time import sleep, time
-    from ping.tasks import sample_task
+#Caching
+class CheckCacheSet(Check):
+    key = 'cache_set'
+    description = "Attempts to cache a value."
+    def check(self, request):
+        try:
+            cache.set(getattr(settings, 'PING_CACHE_KEY', PING_CACHE_KEY), getattr(settings, 'PING_CACHE_VALUE', PING_CACHE_VALUE), 30)
+            return {'success':True}
+        except:
+            return {'success': False}
 
-    now = time()
-    datetimenow = datetime.now()
-    expires = datetimenow + timedelta(seconds=getattr(settings, 'PING_CELERY_TIMEOUT', PING_CELERY_TIMEOUT))
-
-    try:
-        task = sample_task.apply_async(expires=expires)
-        while expires > datetime.now():
-            if task.ready() and task.result == True:
-                finished = str(time() - now)
-                return 'celery', { 'success': True, 'time':finished }
-            sleep(0.25)
-        return 'celery', { 'success': False }
-    except Exception:
-        return 'celery', { 'success': False }
+class CheckCacheGet(Check):
+    key = 'cache_get'
+    description = "Attempts to retreive a cached value."
+    def check(self, request):
+        try:
+            data = cache.get(getattr(settings, 'PING_CACHE_KEY', PING_CACHE_KEY))
+            if data == getattr(settings, 'PING_CACHE_VALUE', PING_CACHE_VALUE):
+                return {'success':True}
+            else:
+                return {'success':False}
+        except:
+            return {'success': False}

ping/defaults.py

@@ -2,10 +2,15 @@
 PING_DEFAULT_MIMETYPE = 'text/html'
 
 PING_DEFAULT_CHECKS = (
-    'ping.checks.check_database_sessions',
-    'ping.checks.check_database_sites',
+    'ping.checks.CheckDatabaseSessions',
+    'ping.checks.CheckDatabaseSites',
+    'ping.checks.CheckCacheSet',
+    'ping.checks.CheckCacheGet',
 )
 
 PING_BASIC_AUTH = False
 
-PING_CELERY_TIMEOUT = 5
+PING_CELERY_TIMEOUT = 5
+
+PING_CACHE_KEY = 'django-ping-test'
+PING_CACHE_VALUE = 'abc123'