Merge branch 'release/0.7'

Author: jezdez

.travis.yml

@@ -3,8 +3,6 @@ python:
   - "2.6"
   - "2.7"
 before_install:
-  - export PIP_USE_MIRRORS=true
-  - export PIP_INDEX_URL=https://simple.crate.io/
   - export DJANGO_SETTINGS_MODULE=celery_haystack.test_settings
 install:
   - pip install -e .
@@ -15,10 +13,9 @@ script:
   - coverage run --branch --source=celery_haystack `which django-admin.py` test celery_haystack
   - coverage report --omit=celery_haystack/test*
 env:
-  - DJANGO=1.3.1 HAYSTACK=v1
-  - DJANGO=1.3.1 HAYSTACK=v2
-  - DJANGO=1.4 HAYSTACK=v1
-  - DJANGO=1.4 HAYSTACK=v2
-branches:
-  only:
-    - develop
+  - DJANGO=1.3.7 HAYSTACK=v1
+  - DJANGO=1.3.7 HAYSTACK=v2
+  - DJANGO=1.4.5 HAYSTACK=v1
+  - DJANGO=1.4.5 HAYSTACK=v2
+  - DJANGO=1.5 HAYSTACK=v1
+  - DJANGO=1.5 HAYSTACK=v2

AUTHORS

@@ -2,3 +2,4 @@ Josh Bohde
 Germán M. Bravo
 Jannis Leidel <[email protected]>
 Daniel Lindsley
+Stefan Wehrmeyer

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012, Jannis Leidel and other contributors.
+Copyright (c) 2011-2013, Jannis Leidel and contributors.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,

MANIFEST.in

@@ -42,15 +42,73 @@ By default a few dependencies will automatically be installed:
 .. _`django-celery-transactions`: https://github.com/chrisdoble/django-celery-transactions 
 .. _`Celery's user guide`: http://celery.readthedocs.org/en/latest/userguide/tasks.html#database-transactions
 
-Setup
+Usage
 -----
 
-1. Add ``'celery_haystack'`` to ``INSTALLED_APPS``.
+Haystack 1.X
+~~~~~~~~~~~~
+
+1. Add ``'celery_haystack'`` to the ``INSTALLED_APPS`` setting
+
+   ::
+
+     INSTALLED_APPS = [
+         # ..
+         'celery_haystack',
+     ]
+
 2. Alter all of your ``SearchIndex`` subclasses to inherit from
-   ``celery_haystack.indexes.CelerySearchIndex`` (as well as
-   ``haystack.indexes.Indexable`` if you use Haystack `2.X`_).
+   ``celery_haystack.indexes.CelerySearchIndex``
+
+   ::
+
+     from haystack import site
+     from celery_haystack.indexes import CelerySearchIndex
+     from myapp.models import Note
+
+     class NoteIndex(CelerySearchIndex):
+         text = indexes.CharField(document=True, model_attr='content')
+
+     site.register(Note, NoteIndex)
+
 3. Ensure your Celery instance is running.
 
+Haystack 2.X
+~~~~~~~~~~~~
+
+1. Add ``'celery_haystack'`` to the ``INSTALLED_APPS`` setting
+
+   ::
+
+     INSTALLED_APPS = [
+         # ..
+         'celery_haystack',
+     ]
+
+2. Enable the celery-haystack signal processor in the settings
+
+   ::
+
+    HAYSTACK_SIGNAL_PROCESSOR = 'celery_haystack.signals.CelerySignalProcessor'
+
+3. Alter all of your ``SearchIndex`` subclasses to inherit from
+   ``celery_haystack.indexes.CelerySearchIndex`` and
+   ``haystack.indexes.Indexable``
+
+   ::
+
+     from haystack import indexes
+     from celery_haystack.indexes import CelerySearchIndex
+     from myapp.models import Note
+
+     class NoteIndex(CelerySearchIndex, indexes.Indexable):
+         text = indexes.CharField(document=True, model_attr='content')
+
+         def get_model(self):
+             return Note
+
+4. Ensure your Celery instance is running.
+
 Thanks
 ------
 

README.rst

@@ -1 +1,5 @@
-__version__ = '0.6.2'
+__version__ = '0.7'
+
+
+def version_hook(config):
+    config['metadata']['version'] = __version__

celery_haystack/__init__.py

@@ -1,20 +1,32 @@
 from django.conf import settings  # noqa
-from haystack import constants
+from django.core.exceptions import ImproperlyConfigured
+from haystack import constants, __version__ as haystack_version
 from appconf import AppConf
 
 
 class CeleryHaystack(AppConf):
+    #: The default alias to
     DEFAULT_ALIAS = None
+    #: The delay (in seconds) after which a failed index is retried
     RETRY_DELAY = 5 * 60
+    #: The number of retries that are done
     MAX_RETRIES = 1
+    #: The default Celery task class
     DEFAULT_TASK = 'celery_haystack.tasks.CeleryHaystackSignalHandler'
+    #: Whether the task should be handled transaction safe
     TRANSACTION_SAFE = True
 
+    #: The batch size used by the CeleryHaystackUpdateIndex task
     COMMAND_BATCH_SIZE = None
+    #: The max age of items used by the CeleryHaystackUpdateIndex task
     COMMAND_AGE = None
+    #: Wehther to remove items from the index that aren't in the DB anymore
     COMMAND_REMOVE = False
+    #: The number of multiprocessing workers used by the CeleryHaystackUpdateIndex task
     COMMAND_WORKERS = 0
+    #: The names of apps to run update_index for
     COMMAND_APPS = []
+    #: The verbosity level of the update_index call
     COMMAND_VERBOSITY = 1
 
     def configure_default_alias(self, value):
@@ -28,3 +40,12 @@ def configure(self):
                 value = int(value)
             data[name] = value
         return data
+
+if (haystack_version[0] >= 2 and
+    getattr(settings, 'HAYSTACK_SIGNAL_PROCESSOR', None) !=
+        'celery_haystack.signals.CelerySignalProcessor'):
+
+    raise ImproperlyConfigured("When using celery-haystack with Haystack 2.X "
+                               "the HAYSTACK_SIGNAL_PROCESSOR setting must be "
+                               "set to 'celery_haystack.signals."
+                               "CelerySignalProcessor'.")

celery_haystack/conf.py

@@ -3,7 +3,7 @@
 from haystack import indexes
 from haystack.utils import get_identifier
 
-from celery_haystack.utils import get_update_task
+from .utils import get_update_task
 
 
 class CelerySearchIndex(indexes.SearchIndex):
@@ -14,44 +14,36 @@ class CelerySearchIndex(indexes.SearchIndex):
     def __init__(self, *args, **kwargs):
         super(CelerySearchIndex, self).__init__(*args, **kwargs)
         self.task_cls = get_update_task()
-        self.has_get_model = hasattr(self, 'get_model')
-
-    def handle_model(self, model):
-        if model is None and self.has_get_model:
-            return self.get_model()
-        return model
 
     # We override the built-in _setup_* methods to connect the enqueuing
     # operation.
-    def _setup_save(self, model=None):
-        model = self.handle_model(model)
-        signals.post_save.connect(self._enqueue_save, sender=model, dispatch_uid=CelerySearchIndex)
-
-    def _setup_delete(self, model=None):
-        model = self.handle_model(model)
-        signals.post_delete.connect(self._enqueue_delete, sender=model, dispatch_uid=CelerySearchIndex)
-
-    def _teardown_save(self, model=None):
-        model = self.handle_model(model)
-        signals.post_save.disconnect(self._enqueue_save, sender=model, dispatch_uid=CelerySearchIndex)
-
-    def _teardown_delete(self, model=None):
-        model = self.handle_model(model)
-        signals.post_delete.disconnect(self._enqueue_delete, sender=model, dispatch_uid=CelerySearchIndex)
-
-    def _enqueue_save(self, instance, **kwargs):
-        if not getattr(instance, 'skip_indexing', False):
-            self.enqueue_save(instance, **kwargs)
-
-    def _enqueue_delete(self, instance, **kwargs):
-        if not getattr(instance, 'skip_indexing', False):
-            self.enqueue_delete(instance, **kwargs)
+    def _setup_save(self, model):
+        signals.post_save.connect(self.enqueue_save,
+                                  sender=model,
+                                  dispatch_uid=CelerySearchIndex)
+
+    def _setup_delete(self, model):
+        signals.post_delete.connect(self.enqueue_delete,
+                                    sender=model,
+                                    dispatch_uid=CelerySearchIndex)
+
+    def _teardown_save(self, model):
+        signals.post_save.disconnect(self.enqueue_save,
+                                     sender=model,
+                                     dispatch_uid=CelerySearchIndex)
+
+    def _teardown_delete(self, model):
+        signals.post_delete.disconnect(self.enqueue_delete,
+                                       sender=model,
+                                       dispatch_uid=CelerySearchIndex)
 
     def enqueue_save(self, instance, **kwargs):
-        return self.enqueue('update', instance)
+        if not getattr(instance, 'skip_indexing', False):
+            return self.enqueue('update', instance)
 
     def enqueue_delete(self, instance, **kwargs):
-        return self.enqueue('delete', instance)
+        if not getattr(instance, 'skip_indexing', False):
+            return self.enqueue('delete', instance)
 
     def enqueue(self, action, instance):
         """

celery_haystack/indexes.py

@@ -0,0 +1,47 @@
+from django.db.models import signals
+
+from haystack.signals import BaseSignalProcessor
+from haystack.utils import get_identifier
+from haystack.exceptions import NotHandled
+
+from .utils import get_update_task
+from .indexes import CelerySearchIndex
+
+
+class CelerySignalProcessor(BaseSignalProcessor):
+
+    def setup(self):
+        self.task_cls = get_update_task()
+        signals.post_save.connect(self.enqueue_save)
+        signals.post_delete.connect(self.enqueue_delete)
+
+    def teardown(self):
+        signals.post_save.disconnect(self.enqueue_save)
+        signals.post_delete.disconnect(self.enqueue_delete)
+
+    def enqueue_save(self, sender, instance, **kwargs):
+        return self.enqueue('update', instance, sender, **kwargs)
+
+    def enqueue_delete(self, sender, instance, **kwargs):
+        return self.enqueue('delete', instance, sender, **kwargs)
+
+    def enqueue(self, action, instance, sender, **kwargs):
+        """
+        Given an individual model instance, determine if a backend
+        handles the model, check if the index is Celery-enabled and
+        enqueue task.
+        """
+        using_backends = self.connection_router.for_write(instance=instance)
+
+        for using in using_backends:
+            try:
+                connection = self.connections[using]
+                index = connection.get_unified_index().get_index(sender)
+            except NotHandled:
+                continue  # Check next backend
+
+            if isinstance(index, CelerySearchIndex):
+                if action == 'update' and not index.should_update(instance):
+                    continue
+                self.task_cls.delay(action, get_identifier(instance))
+                return  # Only enqueue instance once