Added stacky server api methods show, do_uuid, search and show

stacktach/models.py

@@ -13,10 +13,15 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-from django import forms
+import copy
 from django.db import models
 
 
+def routing_key_type(key):
+    if key.endswith('error'):
+        return 'E'
+    return ' '
+
 class Deployment(models.Model):
     name = models.CharField(max_length=50)
 
@@ -25,6 +30,8 @@ class Deployment(models.Model):
 
 
 class GenericRawData(models.Model):
+    result_titles = [["#", "?", "When", "Deployment", "Event", "Host",
+                          "Instance", "Request id"]]
     deployment = models.ForeignKey(Deployment)
     tenant = models.CharField(max_length=50, null=True, blank=True,
                               db_index=True)
@@ -52,8 +59,17 @@ class GenericRawData(models.Model):
     def get_name():
         return GenericRawData.__name__
 
+    def search_results(self, results, when, routing_key_status):
+        if not results:
+            results = copy.deepcopy(self.result_titles)
+        results.append([self.id, routing_key_status, str(when),
+                        self.deployment.name, self.event, self.host,
+                        self.instance, self.request_id])
+        return results
 
 class RawData(models.Model):
+    result_titles = [["#", "?", "When", "Deployment", "Event", "Host",
+                          "State", "State'", "Task'"]]
     deployment = models.ForeignKey(Deployment)
     tenant = models.CharField(max_length=50, null=True, blank=True,
                               db_index=True)
@@ -87,10 +103,22 @@ class RawData(models.Model):
     def __repr__(self):
         return "%s %s %s" % (self.event, self.instance, self.state)
 
+    @property
+    def uuid(self):
+        return self.instance
+
     @staticmethod
     def get_name():
         return RawData.__name__
 
+    def search_results(self, results, when, routing_key_status):
+        if not results:
+            results = copy.deepcopy(self.result_titles)
+        results.append([self.id, routing_key_status, str(when),
+                        self.deployment.name, self.event, self.host, self.state,
+                        self.old_state, self.old_task])
+        return results
+
 
 class RawDataImageMeta(models.Model):
     raw = models.ForeignKey(RawData, null=False)
@@ -273,6 +301,8 @@ class JsonReport(models.Model):
 
 
 class GlanceRawData(models.Model):
+    result_titles = [["#", "?", "When", "Deployment", "Event", "Host",
+                          "Status"]]
     ACTIVE = 'active'
     DELETED = 'deleted'
     KILLED = 'killed'
@@ -317,6 +347,14 @@ class GlanceRawData(models.Model):
     def get_name():
         return GlanceRawData.__name__
 
+    def search_results(self, results, when, routing_key_status):
+        if not results:
+            results = copy.deepcopy(self.result_titles)
+        results.append([self.id, routing_key_status, str(when),
+                            self.deployment.name, self.event, self.host,
+                            self.status])
+        return results
+
 
 class ImageUsage(models.Model):
     uuid = models.CharField(max_length=50, db_index=True)

stacktach/stacky_server.py

@@ -9,13 +9,14 @@ from django.shortcuts import get_object_or_404
 import datetime_to_decimal as dt
 import models
 import utils
+from django.core.exceptions import ObjectDoesNotExist, FieldError
 
 SECS_PER_HOUR = 60 * 60
 SECS_PER_DAY = SECS_PER_HOUR * 24
 
 
-def get_event_names():
-    return models.RawData.objects.values('event').distinct()
+def get_event_names(service='nova'):
+    return _model_factory(service).values('event').distinct()
 
 
 def get_host_names():
@@ -104,22 +105,25 @@ def do_hosts(request):
     return rsp(json.dumps(results))
 
 
-def do_uuid(request):
+def do_uuid(request, service='nova'):
     uuid = str(request.GET['uuid'])
     if not utils.is_uuid_like(uuid):
         msg = "%s is not uuid-like" % uuid
         return error_response(400, 'Bad Request', msg)
+    model = _model_factory(service)
+    result = {}
+    param = {}
+    if service == 'nova' or service == 'generic':
+        param = {'instance': uuid}
+    if service == 'glance':
+        param = {'uuid': uuid}
 
-    related = models.RawData.objects.select_related().filter(instance=uuid)\
-                                                     .order_by('when')
-    results = [["#", "?", "When", "Deployment", "Event", "Host", "State",
-                "State'", "Task'"]]
-    for e in related:
-        when = dt.dt_from_decimal(e.when)
-        results.append([e.id, routing_key_type(e.routing_key), str(when),
-                        e.deployment.name, e.event, e.host, e.state,
-                        e.old_state, e.old_task])
-    return rsp(json.dumps(results))
+    related = model.select_related().filter(**param).order_by('when')
+    for event in related:
+        when = dt.dt_from_decimal(event.when)
+        routing_key_status = routing_key_type(event.routing_key)
+        result = event.search_results(result, when, routing_key_status)
+    return rsp(json.dumps(result))
 
 
 def do_timings_uuid(request):
@@ -202,15 +206,7 @@ def do_request(request):
     return rsp(json.dumps(results))
 
 
-def do_show(request, event_id):
-    event_id = int(event_id)
-    results = []
-    event = None
-    try:
-        event = models.RawData.objects.get(id=event_id)
-    except models.RawData.ObjectDoesNotExist:
-        return results
-
+def append_nova_raw_attributes(event, results):
     results.append(["Key", "Value"])
     results.append(["#", event.id])
     when = dt.dt_from_decimal(event.when)
@@ -224,16 +220,77 @@ def do_show(request, event_id):
     results.append(["Host", event.host])
     results.append(["UUID", event.instance])
     results.append(["Req ID", event.request_id])
-
-    final = [results, ]
-    j = json.loads(event.json)
-    final.append(json.dumps(j, indent=2))
-    final.append(event.instance)
-
-    return rsp(json.dumps(final))
+    return results
 
 
-def do_watch(request, deployment_id):
+def append_glance_raw_attributes(event, results):
+    results.append(["Key", "Value"])
+    results.append(["#", event.id])
+    when = dt.dt_from_decimal(event.when)
+    results.append(["When", str(when)])
+    results.append(["Deployment", event.deployment.name])
+    results.append(["Category", event.routing_key])
+    results.append(["Publisher", event.publisher])
+    results.append(["Status", event.status])
+    results.append(["Event", event.event])
+    results.append(["Service", event.service])
+    results.append(["Host", event.host])
+    results.append(["UUID", event.uuid])
+    results.append(["Req ID", event.request_id])
+    return results
+
+
+def append_generic_raw_attributes(event, results):
+    results.append(["Key", "Value"])
+    results.append(["#", event.id])
+    when = dt.dt_from_decimal(event.when)
+    results.append(["When", str(when)])
+    results.append(["Deployment", event.deployment.name])
+    results.append(["Category", event.routing_key])
+    results.append(["Publisher", event.publisher])
+    results.append(["State", event.state])
+    results.append(["Event", event.event])
+    results.append(["Service", event.service])
+    results.append(["Host", event.host])
+    results.append(["UUID", event.instance])
+    results.append(["Req ID", event.request_id])
+    return results
+
+def _append_raw_attributes(event, results, service):
+    if service == 'nova':
+        return append_nova_raw_attributes(event, results)
+    if service == 'glance':
+        return append_glance_raw_attributes(event, results)
+    if service == 'generic':
+        return append_generic_raw_attributes(event, results)
+
+def do_show(request, event_id, service='nova'):
+    event_id = int(event_id)
+    results = []
+    model = _model_factory(service)
+    try:
+        event = model.get(id=event_id)
+        results = _append_raw_attributes(event, results, service)
+        final = [results, ]
+        j = json.loads(event.json)
+        final.append(json.dumps(j, indent=2))
+        final.append(event.uuid)
+        return rsp(json.dumps(final))
+    except ObjectDoesNotExist:
+        return rsp({})
+
+
+def _model_factory(service):
+    if service == 'glance':
+        return models.GlanceRawData.objects
+    elif service == 'nova':
+        return models.RawData.objects
+    elif service == 'generic':
+        return models.GenericRawData.objects
+
+
+def do_watch(request, deployment_id, service='nova'):
+    model = _model_factory(service)
     deployment_id = int(deployment_id)
     since = request.GET.get('since')
     event_name = request.GET.get('event_name')
@@ -244,7 +301,7 @@ def do_watch(request, deployment_id):
     events = get_event_names()
     max_event_width = max([len(event['event']) for event in events])
 
-    base_events = models.RawData.objects.order_by('when')
+    base_events = model.order_by('when')
     if deployment_id > 0:
         base_events = base_events.filter(deployment=deployment_id)
 
@@ -426,3 +483,26 @@ def do_jsonreport(request, report_id):
     report_id = int(report_id)
     report = get_object_or_404(models.JsonReport, pk=report_id)
     return rsp(report.json)
+
+
+def search(request, service):
+    DEFAULT = 1000
+    field = request.GET.get('field')
+    value = request.GET.get('value')
+    limit = request.GET.get('limit', DEFAULT)
+    limit = int(limit)
+    model = _model_factory(service)
+    filter_para = {field: value}
+    results = {}
+    try:
+        events = model.filter(**filter_para)
+        event_len = len(events)
+        if event_len > limit:
+            events = events[0:limit]
+        for event in events:
+            when = dt.dt_from_decimal(event.when)
+            routing_key_status = routing_key_type(event.routing_key)
+            results = event.search_results(results, when, routing_key_status)
+        return rsp(json.dumps(results))
+    except ObjectDoesNotExist or FieldError:
+        return rsp({})

stacktach/tests.py

@@ -27,6 +27,8 @@ from stacktach.models import GenericRawData
 from stacktach.models import GlanceRawData
 from stacktach.models import RawData
 from stacktach.models import get_model_fields
+from stacktach import datetime_to_decimal as dt
+
 
 
 class RawDataImageMetaDbTestCase(TransactionTestCase):
@@ -157,3 +159,84 @@ class GenericRawDataTestCase(TransactionTestCase):
             if field.name != 'id':
                 self.assertEquals(getattr(rawdata, field.name),
                                   kwargs[field.name])
+
+
+class NovaRawDataSearchTestCase(TransactionTestCase):
+    def test_search_results_for_nova(self):
+        expected_result = [['#', '?', 'When', 'Deployment', 'Event', 'Host',
+                            'State', "State'", "Task'"], [1L, ' ',
+                            '2013-07-17 10:16:10.717219', 'depl', 'event',
+                            'host', 'state', 'old_state', 'old_task']]
+        depl = db.get_or_create_deployment('depl')[0]
+        when = dt.dt_to_decimal(datetime.utcnow())
+        raw = db.create_nova_rawdata(deployment=depl,
+                      routing_key='routing_key',
+                                      tenant='tenant',
+                                      json='json',
+                                      when=when,
+                                      publisher='publisher',
+                                      event='event',
+                                      service='nova',
+                                      host='host',
+                                      instance='instance',
+                                      request_id='req-1234',
+                                      state='state',
+                                      old_state='old_state',
+                                      task='task',
+                                      old_task='old_task',
+                                      os_architecture='arch',
+                                      os_distro='distro',
+                                      os_version='version',
+                                      rax_options=1)
+
+        results = raw.search_results({}, "2013-07-17 10:16:10.717219", ' ')
+        self.assertEqual(results,expected_result)
+
+    def test_search_results_for_glance(self):
+        expected_result = [['#', '?', 'When', 'Deployment', 'Event', 'Host',
+                            'Status'], [1L, ' ',
+                            '2013-07-17 10:16:10.717219', 'depl', 'event',
+                            'host', 'status']]
+        depl = db.get_or_create_deployment('depl')[0]
+        when = dt.dt_to_decimal(datetime.utcnow())
+
+        glance_raw = db.create_glance_rawdata(deployment=depl,
+                                              routing_key='routing_key',
+                                              json='json',
+                                              when=when,
+                                              publisher='publisher',
+                                              event='event',
+                                              service='glance',
+                                              host='host',
+                                              uuid='instance',
+                                              request_id='req-1234',
+                                              status='status',
+                                              image_type=1)
+
+        results = glance_raw.search_results({}, "2013-07-17 10:16:10.717219",
+                                                ' ')
+        self.assertEqual(results,expected_result)
+
+    def test_search_results_for_generic(self):
+        expected_result = [['#', '?', 'When', 'Deployment', 'Event', 'Host',
+                            'Instance', 'Request id'], [1L, ' ',
+                            '2013-07-17 10:16:10.717219', 'depl', 'event',
+                            'host', 'instance', 'req-1234']]
+        depl = db.get_or_create_deployment('depl')[0]
+        when = dt.dt_to_decimal(datetime.utcnow())
+
+        generic_raw = db.create_generic_rawdata(deployment=depl,
+                                              routing_key='routing_key',
+                                              json='json',
+                                              when=when,
+                                              publisher='publisher',
+                                              event='event',
+                                              service='glance',
+                                              host='host',
+                                              instance='instance',
+                                              request_id='req-1234',
+                                              tenant='tenant')
+
+        results = generic_raw.search_results({}, "2013-07-17 10:16:10.717219",
+                                                ' ')
+        self.assertEqual(results,expected_result)

stacktach/urls.py

@@ -1,4 +1,4 @@
-from django.conf.urls.defaults import patterns, include, url
+from django.conf.urls import patterns, url
 
 
 urlpatterns = patterns('',
@@ -7,7 +7,7 @@ urlpatterns = patterns('',
     url(r'stacky/deployments/$', 'stacktach.stacky_server.do_deployments'),
     url(r'stacky/events/$', 'stacktach.stacky_server.do_events'),
     url(r'stacky/hosts/$', 'stacktach.stacky_server.do_hosts'),
-    url(r'stacky/uuid/$', 'stacktach.stacky_server.do_uuid'),
+    url(r'stacky/uuid/(?P<service>\w+)/$', 'stacktach.stacky_server.do_uuid'),
     url(r'stacky/timings/$', 'stacktach.stacky_server.do_timings'),
     url(r'stacky/timings/uuid/$', 'stacktach.stacky_server.do_timings_uuid'),
     url(r'stacky/summary/$', 'stacktach.stacky_server.do_summary'),
@@ -17,8 +17,11 @@ urlpatterns = patterns('',
                             'stacktach.stacky_server.do_jsonreport'),
     url(r'stacky/show/(?P<event_id>\d+)/$',
                                         'stacktach.stacky_server.do_show'),
-    url(r'stacky/watch/(?P<deployment_id>\d+)/$',
+    url(r'stacky/show/(?P<service>\w+)/(?P<event_id>\d+)$',
+                                        'stacktach.stacky_server.do_show'),
+    url(r'stacky/watch/(?P<deployment_id>\d+)/(?P<service>\w+)$',
                                         'stacktach.stacky_server.do_watch'),
+    url(r'stacky/search/(?P<service>\w+)/$', 'stacktach.stacky_server.search'),
     url(r'stacky/kpi/$', 'stacktach.stacky_server.do_kpi'),
     url(r'stacky/kpi/(?P<tenant_id>\w+)/$', 'stacktach.stacky_server.do_kpi'),
     url(r'stacky/usage/launches/$',

tests/unit/test_stacky_server.py

@@ -40,6 +40,12 @@ class StackyServerTestCase(unittest.TestCase):
         self.mox.StubOutWithMock(models, 'RawData', use_mock_anything=True)
         models.RawData.objects = self.mox.CreateMockAnything()
         self.mox.StubOutWithMock(models, 'Deployment', use_mock_anything=True)
+        self.mox.StubOutWithMock(models, 'GlanceRawData',
+                                 use_mock_anything=True)
+        models.GlanceRawData.objects = self.mox.CreateMockAnything()
+        self.mox.StubOutWithMock(models, 'GenericRawData',
+                                 use_mock_anything=True)
+        models.GenericRawData.objects = self.mox.CreateMockAnything()
         models.Deployment.objects = self.mox.CreateMockAnything()
         self.mox.StubOutWithMock(models, 'Lifecycle', use_mock_anything=True)
         models.Lifecycle.objects = self.mox.CreateMockAnything()
@@ -65,7 +71,8 @@ class StackyServerTestCase(unittest.TestCase):
 
     def _create_raw(self):
         raw = self.mox.CreateMockAnything()
-        raw.when = utils.decimal_utc()
+        raw.when = utils.decimal_utc(datetime.datetime(2013, 7, 17, 10, 16,
+                                                       10, 717219))
         raw.instance = INSTANCE_ID_1
         raw.id = 1
         raw.routing_key = 'monitor.info'
@@ -80,13 +87,19 @@ class StackyServerTestCase(unittest.TestCase):
         raw.publisher = "api.example.com"
         raw.service = 'api'
         raw.host = 'example.com'
+        raw.status = 'state'
         raw.request_id = REQUEST_ID_1
         raw.json = '{"key": "value"}'
+        raw.uuid = 'uuid'
+        raw.tenant = 'tenant'
         return raw
 
     def test_get_event_names(self):
+        model = self.mox.CreateMockAnything()
         result = self.mox.CreateMockAnything()
-        models.RawData.objects.values('event').AndReturn(result)
+        self.mox.StubOutWithMock(stacky_server, '_model_factory')
+        stacky_server._model_factory('nova').AndReturn(model)
+        model.values('event').AndReturn(result)
         result.distinct().AndReturn(result)
         self.mox.ReplayAll()
 
@@ -248,6 +261,10 @@ class StackyServerTestCase(unittest.TestCase):
         self.mox.VerifyAll()
 
     def test_do_uuid(self):
+        search_result = [["#", "?", "When", "Deployment", "Event", "Host",
+                          "State", "State'", "Task'"], [1, " ",
+                          "2013-07-17 10:16:10.717219", "deployment",
+                          "test.start", "example.com", "active", None, None]]
         fake_request = self.mox.CreateMockAnything()
         fake_request.GET = {'uuid': INSTANCE_ID_1}
         result = self.mox.CreateMockAnything()
@@ -256,6 +273,7 @@ class StackyServerTestCase(unittest.TestCase):
         result.order_by('when').AndReturn(result)
         raw = self._create_raw()
         result.__iter__().AndReturn([raw].__iter__())
+        raw.search_results({}, mox.IgnoreArg(), ' ').AndReturn(search_result)
         self.mox.ReplayAll()
 
         resp = stacky_server.do_uuid(fake_request)
@@ -272,6 +290,36 @@ class StackyServerTestCase(unittest.TestCase):
         self.assertEqual(json_resp[1], body)
         self.mox.VerifyAll()
 
+    def test_do_uuid_for_glance(self):
+        search_result = [["#", "?", "When", "Deployment", "Event", "Host",
+                          "Status"], [1, " ",
+                          "2013-07-17 10:16:10.717219", "deployment",
+                          "test.start", "example.com", "state"]]
+        fake_request = self.mox.CreateMockAnything()
+        fake_request.GET = {'uuid': INSTANCE_ID_1}
+        result = self.mox.CreateMockAnything()
+        models.GlanceRawData.objects.select_related().AndReturn(result)
+        result.filter(uuid=INSTANCE_ID_1).AndReturn(result)
+        result.order_by('when').AndReturn(result)
+        raw = self._create_raw()
+        result.__iter__().AndReturn([raw].__iter__())
+        raw.search_results({}, mox.IgnoreArg(), ' ').AndReturn(search_result)
+        self.mox.ReplayAll()
+
+        resp = stacky_server.do_uuid(fake_request,'glance')
+
+        self.assertEqual(resp.status_code, 200)
+        json_resp = json.loads(resp.content)
+        self.assertEqual(len(json_resp), 2)
+        header = ["#", "?", "When", "Deployment", "Event", "Host",
+                  "Status"]
+        self.assertEqual(json_resp[0], header)
+        datetime = dt.dt_from_decimal(raw.when)
+        body = [1, " ", str(datetime), "deployment", "test.start",
+                "example.com", "state"]
+        self.assertEqual(json_resp[1], body)
+        self.mox.VerifyAll()
+
     def test_do_uuid_bad_uuid(self):
         fake_request = self.mox.CreateMockAnything()
         fake_request.GET = {'uuid': "obviouslybaduuid"}
@@ -504,7 +552,9 @@ class StackyServerTestCase(unittest.TestCase):
         self.assertEqual(resp_json[1], ['Bad Request', msg])
         self.mox.VerifyAll()
 
-    def _assert_on_show(self, values, raw):
+    def _assert_on_show_nova(self, json_resp, raw):
+        self.assertEqual(len(json_resp), 3)
+        values = json_resp[0]
         self.assertEqual(len(values), 12)
         self.assertEqual(values[0], ["Key", "Value"])
         self.assertEqual(values[1], ["#", raw.id])
@@ -517,7 +567,25 @@ class StackyServerTestCase(unittest.TestCase):
         self.assertEqual(values[7], ["Event", raw.event])
         self.assertEqual(values[8], ["Service", raw.service])
         self.assertEqual(values[9], ["Host", raw.host])
-        self.assertEqual(values[10], ["UUID", raw.instance])
+        self.assertEqual(values[10],["UUID", raw.instance])
+        self.assertEqual(values[11], ["Req ID", raw.request_id])
+
+    def _assert_on_show_glance(self, json_resp, raw):
+        self.assertEqual(len(json_resp), 3)
+        values = json_resp[0]
+        self.assertEqual(len(values), 12)
+        self.assertEqual(values[0], ["Key", "Value"])
+        self.assertEqual(values[1], ["#", raw.id])
+        self.assertEqual(values[2], ["When",
+                                     str(dt.dt_from_decimal(raw.when))])
+        self.assertEqual(values[3], ["Deployment", raw.deployment.name])
+        self.assertEqual(values[4], ["Category", raw.routing_key])
+        self.assertEqual(values[5], ["Publisher", raw.publisher])
+        self.assertEqual(values[6], ["Status", raw.status])
+        self.assertEqual(values[7], ["Event", raw.event])
+        self.assertEqual(values[8], ["Service", raw.service])
+        self.assertEqual(values[9], ["Host", raw.host])
+        self.assertEqual(values[10],["UUID", raw.uuid])
         self.assertEqual(values[11], ["Req ID", raw.request_id])
 
     def test_do_show(self):
@@ -528,10 +596,81 @@ class StackyServerTestCase(unittest.TestCase):
 
         resp = stacky_server.do_show(fake_request, 1)
 
+        self.assertEqual(resp.status_code, 200)
+        json_resp = json.loads(resp.content)
+        self._assert_on_show_nova(json_resp, raw)
+        self.mox.VerifyAll()
+
+    def test_do_show_for_glance_rawdata(self):
+        fake_request = self.mox.CreateMockAnything()
+        raw = self._create_raw()
+        models.GlanceRawData.objects.get(id=1).AndReturn(raw)
+        self.mox.ReplayAll()
+
+        resp = stacky_server.do_show(fake_request, 1, 'glance')
+
+        self.assertEqual(resp.status_code, 200)
+        json_resp = json.loads(resp.content)
+        self._assert_on_show_glance(json_resp, raw)
+        self.mox.VerifyAll()
+
+    def test_do_show_for_generic_rawdata(self):
+        fake_request = self.mox.CreateMockAnything()
+        raw = self._create_raw()
+        models.GenericRawData.objects.get(id=1).AndReturn(raw)
+        self.mox.ReplayAll()
+
+        resp = stacky_server.do_show(fake_request, 1, 'generic')
+
+        self.assertEqual(resp.status_code, 200)
+        json_resp = json.loads(resp.content)
+        self._assert_on_show_nova(json_resp, raw)
+        self.mox.VerifyAll()
+
+    def test_do_show_should_return_empty_result_on_object_not_found_exception(self):
+        fake_request = self.mox.CreateMockAnything()
+        raw = self._create_raw()
+        models.RawData.objects.get(id=1).AndReturn(raw)
+        self.mox.ReplayAll()
+
+        resp = stacky_server.do_show(fake_request, 1)
+
+        self.assertEqual(resp.status_code, 200)
+        json_resp = json.loads(resp.content)
+        self._assert_on_show_nova(json_resp, raw)
+        self.mox.VerifyAll()
+
+    def test_do_watch_for_glance(self):
+        fake_request = self.mox.CreateMockAnything()
+        fake_request.GET = {}
+        self.mox.StubOutWithMock(stacky_server, 'get_deployments')
+        deployment1 = self.mox.CreateMockAnything()
+        deployment1.id = 1
+        deployment1.name = 'dep1'
+        deployments = [deployment1]
+        stacky_server.get_deployments().AndReturn(deployments)
+        self.mox.StubOutWithMock(stacky_server, 'get_event_names')
+        events = [{'event': 'test.start'}, {'event': 'test.end'}]
+        stacky_server.get_event_names().AndReturn(events)
+        results = self.mox.CreateMockAnything()
+        models.GlanceRawData.objects.order_by('when').AndReturn(results)
+        results.filter(when__gt=mox.IgnoreArg()).AndReturn(results)
+        results.filter(when__lte=mox.IgnoreArg()).AndReturn(results)
+        results.__iter__().AndReturn([self._create_raw()].__iter__())
+        self.mox.ReplayAll()
+
+        resp = stacky_server.do_watch(fake_request, 0, 'glance')
         self.assertEqual(resp.status_code, 200)
         json_resp = json.loads(resp.content)
         self.assertEqual(len(json_resp), 3)
-        self._assert_on_show(json_resp[0], raw)
+        self.assertEqual(json_resp[0], [10, 1, 15, 20, 10, 36])
+        self.assertEqual(json_resp[1][0][0], 1)
+        self.assertEqual(json_resp[1][0][1], u' ')
+        time_str = "%s %s" % (json_resp[1][0][2], json_resp[1][0][3])
+        datetime.datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S.%f")
+        self.assertEqual(json_resp[1][0][4], u'dep1')
+        self.assertEqual(json_resp[1][0][5], u'test.start')
+        self.assertEqual(json_resp[1][0][6], u'%s' % INSTANCE_ID_1)
         self.mox.VerifyAll()
 
     def test_do_watch(self):
@@ -547,7 +686,10 @@ class StackyServerTestCase(unittest.TestCase):
         events = [{'event': 'test.start'}, {'event': 'test.end'}]
         stacky_server.get_event_names().AndReturn(events)
         results = self.mox.CreateMockAnything()
-        models.RawData.objects.order_by('when').AndReturn(results)
+        model = self.mox.CreateMockAnything()
+        self.mox.StubOutWithMock(stacky_server, '_model_factory')
+        stacky_server._model_factory('nova').AndReturn(model)
+        model.order_by('when').AndReturn(results)
         results.filter(when__gt=mox.IgnoreArg()).AndReturn(results)
         results.filter(when__lte=mox.IgnoreArg()).AndReturn(results)
         results.__iter__().AndReturn([self._create_raw()].__iter__())
@@ -558,7 +700,6 @@ class StackyServerTestCase(unittest.TestCase):
         json_resp = json.loads(resp.content)
         self.assertEqual(len(json_resp), 3)
         self.assertEqual(json_resp[0], [10, 1, 15, 20, 10, 36])
-        print json_resp
         self.assertEqual(json_resp[1][0][0], 1)
         self.assertEqual(json_resp[1][0][1], u' ')
         time_str = "%s %s" % (json_resp[1][0][2], json_resp[1][0][3])
@@ -581,7 +722,11 @@ class StackyServerTestCase(unittest.TestCase):
         events = [{'event': 'test.start'}, {'event': 'test.end'}]
         stacky_server.get_event_names().AndReturn(events)
         results = self.mox.CreateMockAnything()
-        models.RawData.objects.order_by('when').AndReturn(results)
+        model = self.mox.CreateMockAnything()
+        self.mox.StubOutWithMock(stacky_server, '_model_factory')
+        stacky_server._model_factory('nova').AndReturn(model)
+        model.order_by('when').AndReturn(results)
+
         results.filter(deployment=1).AndReturn(results)
         results.filter(when__gt=mox.IgnoreArg()).AndReturn(results)
         results.filter(when__lte=mox.IgnoreArg()).AndReturn(results)
@@ -593,7 +738,6 @@ class StackyServerTestCase(unittest.TestCase):
         json_resp = json.loads(resp.content)
         self.assertEqual(len(json_resp), 3)
         self.assertEqual(json_resp[0], [10, 1, 15, 20, 10, 36])
-        print json_resp
         self.assertEqual(json_resp[1][0][0], 1)
         self.assertEqual(json_resp[1][0][1], u' ')
         time_str = "%s %s" % (json_resp[1][0][2], json_resp[1][0][3])
@@ -628,7 +772,6 @@ class StackyServerTestCase(unittest.TestCase):
         json_resp = json.loads(resp.content)
         self.assertEqual(len(json_resp), 3)
         self.assertEqual(json_resp[0], [10, 1, 15, 20, 10, 36])
-        print json_resp
         self.assertEqual(json_resp[1][0][0], 1)
         self.assertEqual(json_resp[1][0][1], u' ')
         time_str = "%s %s" % (json_resp[1][0][2], json_resp[1][0][3])
@@ -960,3 +1103,82 @@ class StackyServerTestCase(unittest.TestCase):
         self.assertEqual(resp_json[1], ['Bad Request', msg])
         self.mox.VerifyAll()
 
+    def test_model_factory_for_nova(self):
+        self.mox.UnsetStubs()
+        nova_model = stacky_server._model_factory('nova')
+        self.assertEqual(nova_model.model, models.RawData)
+
+    def test_model_factory_for_nova(self):
+        self.mox.UnsetStubs()
+        nova_model = stacky_server._model_factory('glance')
+        self.assertEqual(nova_model.model, models.GlanceRawData)
+
+    def test_model_factory_for_nova(self):
+        self.mox.UnsetStubs()
+        nova_model = stacky_server._model_factory('generic')
+        self.assertEqual(nova_model.model, models.GenericRawData)
+
+    def _assert_on_search_nova(self, json_resp, raw):
+        title = json_resp[0]
+        values = json_resp[1]
+        self.assertEqual(len(values), 9)
+        self.assertEqual([title[0], values[0]],["#", raw.id] )
+        self.assertEqual([title[1], values[1]], ['?', ' '])
+        self.assertEqual([title[2], values[2]], ["When",
+                                     str(dt.dt_from_decimal(raw.when))])
+        self.assertEqual([title[3], values[3]], ["Deployment", raw.deployment.name])
+        self.assertEqual([title[4], values[4]], ["Event", raw.event])
+        self.assertEqual([title[5], values[5]], ["Host", raw.host])
+        self.assertEqual([title[6], values[6]], ["State", raw.state])
+        self.assertEqual([title[7], values[7]], ["State'", raw.old_state])
+
+    def test_search_by_field_for_nova(self):
+        search_result = [["#", "?", "When", "Deployment", "Event", "Host",
+                          "State", "State'", "Task'"], [1, " ",
+                          "2013-07-17 10:16:10.717219", "deployment",
+                          "test.start", "example.com", "active", None, None]]
+        fake_request = self.mox.CreateMockAnything()
+        fake_request.GET = {'field': 'tenant', 'value': 'tenant'}
+        raw = self._create_raw()
+        models.RawData.objects.filter(tenant='tenant').AndReturn([raw])
+        raw.search_results({}, mox.IgnoreArg(), ' ').AndReturn(search_result)
+        self.mox.ReplayAll()
+
+        resp = stacky_server.search(fake_request, 'nova')
+
+        self.assertEqual(resp.status_code, 200)
+        json_resp = json.loads(resp.content)
+        self._assert_on_search_nova(json_resp, raw)
+        self.mox.VerifyAll()
+
+    def test_search_by_field_for_nova_with_limit(self):
+        search_result = [["#", "?", "When", "Deployment", "Event", "Host",
+                          "State", "State'", "Task'"], [1, " ",
+                          "2013-07-17 10:16:10.717219", "deployment",
+                          "test.start", "example.com", "active", None, None]]
+        search_result_2 = [["#", "?", "When", "Deployment", "Event", "Host",
+                          "State", "State'", "Task'"], [1, " ",
+                          "2013-07-17 10:16:10.717219", "deployment",
+                          "test.start", "example.com", "active", None, None],[2, " ",
+                          "2013-07-17 10:16:10.717219", "deployment",
+                          "test.start", "example.com", "active", None, None]]
+        fake_request = self.mox.CreateMockAnything()
+        fake_request.GET = {'field': 'tenant', 'value': 'tenant', 'limit': '2'}
+        raw1 = self._create_raw()
+        raw2 = self._create_raw()
+        raw3 = self._create_raw()
+        raw2.id = 2
+        raw3.id = 3
+        models.RawData.objects.filter(tenant='tenant').AndReturn([raw1, raw2,
+                                                                   raw3])
+        raw1.search_results({}, mox.IgnoreArg(), ' ').AndReturn(search_result)
+        raw2.search_results(search_result, mox.IgnoreArg(),' ').AndReturn(search_result_2)
+        self.mox.ReplayAll()
+
+        resp = stacky_server.search(fake_request, 'nova')
+
+        self.assertEqual(resp.status_code, 200)
+        json_resp = json.loads(resp.content)
+        self.assertEqual(len(json_resp), 3)
+        self._assert_on_search_nova(json_resp, raw1)
+        self.mox.VerifyAll()