Added a silent failure option to prevent Haystack from suppressing some failures.

This option defaults to ``True`` for compatibility & to prevent cases where lost connections can break reindexes/searches.

Author: toastdriven

docs/multiple_index.rst

@@ -25,6 +25,7 @@ complete setup that accesses all backends might look like::
             'TIMEOUT': 60 * 5,
             'INCLUDE_SPELLING': True,
             'BATCH_SIZE': 100,
+            'SILENTLY_FAIL': True,
         },
         'autocomplete': {
             'ENGINE': 'haystack.backends.whoosh_backend.WhooshEngine',
@@ -33,15 +34,18 @@ complete setup that accesses all backends might look like::
             'POST_LIMIT': 128 * 1024 * 1024,
             'INCLUDE_SPELLING': True,
             'BATCH_SIZE': 100,
+            'SILENTLY_FAIL': True,
         },
         'slave': {
             'ENGINE': 'xapian_backend.XapianEngine',
             'PATH': '/home/search/xapian_index',
             'INCLUDE_SPELLING': True,
             'BATCH_SIZE': 100,
+            'SILENTLY_FAIL': True,
         },
         'db': {
             'ENGINE': 'haystack.backends.simple_backend.SimpleEngine',
+            'SILENTLY_FAIL': True,
         }
     }
 

haystack/backends/__init__.py

@@ -67,6 +67,7 @@ def __init__(self, connection_alias, **connection_options):
         self.timeout = connection_options.get('TIMEOUT', 10)
         self.include_spelling = connection_options.get('INCLUDE_SPELLING', False)
         self.batch_size = connection_options.get('BATCH_SIZE', 1000)
+        self.silently_fail = connection_options.get('SILENTLY_FAIL', True)
 
     def update(self, index, iterable):
         """

haystack/backends/simple_backend.py

@@ -29,17 +29,14 @@ class SimpleSearchBackend(BaseSearchBackend):
     def update(self, indexer, iterable, commit=True):
         if settings.DEBUG:
             logger.warning('update is not implemented in this backend')
-        pass
 
     def remove(self, obj, commit=True):
         if settings.DEBUG:
             logger.warning('remove is not implemented in this backend')
-        pass
 
     def clear(self, models=[], commit=True):
         if settings.DEBUG:
             logger.warning('clear is not implemented in this backend')
-        pass
 
     @log_query
     def search(self, query_string, sort_by=None, start_offset=0, end_offset=None,

haystack/backends/solr_backend.py

@@ -51,12 +51,18 @@ def update(self, index, iterable, commit=True):
             for obj in iterable:
                 docs.append(index.full_prepare(obj))
         except UnicodeDecodeError:
-            sys.stderr.write("Chunk failed.\n")
+            if not self.silently_fail:
+                raise
+            
+            self.log.error("Chunk failed.\n")
 
         if len(docs) > 0:
             try:
                 self.conn.add(docs, commit=commit, boost=index.get_field_weights())
             except (IOError, SolrError), e:
+                if not self.silently_fail:
+                    raise
+                
                 self.log.error("Failed to add documents to Solr: %s", e)
 
     def remove(self, obj_or_string, commit=True):
@@ -69,6 +75,9 @@ def remove(self, obj_or_string, commit=True):
             }
             self.conn.delete(**kwargs)
         except (IOError, SolrError), e:
+            if not self.silently_fail:
+                raise
+            
             self.log.error("Failed to remove document '%s' from Solr: %s", solr_id, e)
 
     def clear(self, models=[], commit=True):
@@ -87,6 +96,9 @@ def clear(self, models=[], commit=True):
             # Run an optimize post-clear. http://wiki.apache.org/solr/FAQ#head-9aafb5d8dff5308e8ea4fcf4b71f19f029c4bb99
             self.conn.optimize()
         except (IOError, SolrError), e:
+            if not self.silently_fail:
+                raise
+            
             if len(models):
                 self.log.error("Failed to clear Solr index of models '%s': %s", ','.join(models_to_delete), e)
             else:
@@ -175,6 +187,9 @@ def search(self, query_string, sort_by=None, start_offset=0, end_offset=None,
         try:
             raw_results = self.conn.search(query_string, **kwargs)
         except (IOError, SolrError), e:
+            if not self.silently_fail:
+                raise
+            
             self.log.error("Failed to query Solr using '%s': %s", query_string, e)
             raw_results = EmptyResults()
 
@@ -230,6 +245,9 @@ def more_like_this(self, model_instance, additional_query_string=None,
         try:
             raw_results = self.conn.more_like_this(query, field_name, **params)
         except (IOError, SolrError), e:
+            if not self.silently_fail:
+                raise
+            
             self.log.error("Failed to fetch More Like This from Solr for document '%s': %s", query, e)
             raw_results = EmptyResults()
 

haystack/backends/whoosh_backend.py

@@ -177,7 +177,13 @@ def update(self, index, iterable, commit=True):
             for key in doc:
                 doc[key] = self._from_python(doc[key])
 
-            writer.update_document(**doc)
+            try:
+                writer.update_document(**doc)
+            except Exception, e:
+                if not self.silently_fail:
+                    raise
+                
+                self.log.error("Failed to add documents to Whoosh: %s", e)
 
         if len(iterable) > 0:
             # For now, commit no matter what, as we run into locking issues otherwise.
@@ -194,23 +200,36 @@ def remove(self, obj_or_string, commit=True):
 
         self.index = self.index.refresh()
         whoosh_id = get_identifier(obj_or_string)
-        self.index.delete_by_query(q=self.parser.parse(u'%s:"%s"' % (ID, whoosh_id)))
+        
+        try:
+            self.index.delete_by_query(q=self.parser.parse(u'%s:"%s"' % (ID, whoosh_id)))
+        except Exception, e:
+            if not self.silently_fail:
+                raise
+            
+            self.log.error("Failed to remove document '%s' from Whoosh: %s", whoosh_id, e)
 
     def clear(self, models=[], commit=True):
         if not self.setup_complete:
             self.setup()
 
         self.index = self.index.refresh()
 
-        if not models:
-            self.delete_index()
-        else:
-            models_to_delete = []
-            
-            for model in models:
-                models_to_delete.append(u"%s:%s.%s" % (DJANGO_CT, model._meta.app_label, model._meta.module_name))
+        try:
+            if not models:
+                self.delete_index()
+            else:
+                models_to_delete = []
+                
+                for model in models:
+                    models_to_delete.append(u"%s:%s.%s" % (DJANGO_CT, model._meta.app_label, model._meta.module_name))
+                
+                self.index.delete_by_query(q=self.parser.parse(u" OR ".join(models_to_delete)))
+        except Exception, e:
+            if not self.silently_fail:
+                raise
 
-            self.index.delete_by_query(q=self.parser.parse(u" OR ".join(models_to_delete)))
+            self.log.error("Failed to remove document '%s' from Whoosh: %s", whoosh_id, e)
 
     def delete_index(self):
         # Per the Whoosh mailing list, if wiping out everything from the index,
@@ -369,6 +388,9 @@ def search(self, query_string, sort_by=None, start_offset=0, end_offset=None,
             try:
                 raw_page = ResultsPage(raw_results, page_num, page_length)
             except ValueError:
+                if not self.silently_fail:
+                    raise
+                
                 return {
                     'results': [],
                     'hits': 0,
@@ -486,6 +508,9 @@ def more_like_this(self, model_instance, additional_query_string=None,
         try:
             raw_page = ResultsPage(raw_results, page_num, page_length)
         except ValueError:
+            if not self.silently_fail:
+                raise
+            
             return {
                 'results': [],
                 'hits': 0,

tests/solr_tests/tests/solr_backend.py

@@ -173,6 +173,33 @@ def setUp(self):
     def tearDown(self):
         connections['default']._index = self.old_ui
         super(SolrSearchBackendTestCase, self).tearDown()
+
+    def test_non_silent(self):
+        bad_sb = connections['default'].backend('bad', URL='http://omg.wtf.bbq:1000/solr', SILENTLY_FAIL=False)
+        
+        try:
+            bad_sb.update(self.smmi, self.sample_objs)
+            self.fail()
+        except:
+            pass
+
+        try:
+            bad_sb.remove('core.mockmodel.1')
+            self.fail()
+        except:
+            pass
+        
+        try:
+            bad_sb.clear()
+            self.fail()
+        except:
+            pass
+        
+        try:
+            bad_sb.search('foo')
+            self.fail()
+        except:
+            pass
 
     def test_update(self):
         self.sb.update(self.smmi, self.sample_objs)

tests/whoosh_tests/tests/whoosh_backend.py

@@ -127,6 +127,35 @@ def whoosh_search(self, query):
         searcher = self.raw_whoosh.searcher()
         return searcher.search(self.parser.parse(query), limit=1000)
 
+    def test_non_silent(self):
+        bad_sb = connections['default'].backend('bad', PATH='/tmp/bad_whoosh', SILENTLY_FAIL=False)
+        bad_sb.use_file_storage = False
+        bad_sb.storage = 'omg.wtf.bbq'
+
+        try:
+            bad_sb.update(self.wmmi, self.sample_objs)
+            self.fail()
+        except:
+            pass
+
+        try:
+            bad_sb.remove('core.mockmodel.1')
+            self.fail()
+        except:
+            pass
+        
+        try:
+            bad_sb.clear()
+            self.fail()
+        except:
+            pass
+        
+        try:
+            bad_sb.search('foo')
+            self.fail()
+        except:
+            pass
+    
     def test_update(self):
         self.sb.update(self.wmmi, self.sample_objs)