0001-atos-genesys-do-not-use-threads-29320.patch

Benjamin Dauvergne, 22 décembre 2018 01:15

Voir les différences: en ligne côte à côte

Subject: [PATCH] atos-genesys: do not use threads (#29320)

As threads were hiding errors from asynchronous requests, we now still
hide errors when cache is full, but log them.

 passerelle/apps/atos_genesys/models.py |  6 ++++--
 passerelle/apps/atos_genesys/utils.py  | 23 ++++++++++-------------
 tests/test_atos_genesys.py             |  2 +-
 3 files changed, 15 insertions(+), 16 deletions(-)

             cache = utils.RowLockedCache(
                 function=self.call_select_codifications,
                 row=self,
                 key_prefix='atos-genesys-codifications')
                 key_prefix='atos-genesys-codifications',
                 logger=self.logger)
             return cache()
         @endpoint(name='codifications',
-...
                 cache = utils.RowLockedCache(
                     function=self.call_select_usager,
                     row=link,
                     key_prefix='atos-genesys-usager')
                     key_prefix='atos-genesys-usager',
                     logger=self.logger)
                 dossier = cache(link.id_per)
                 # build text as "id_per - prenom - no
                 text_parts = [str(link.id_per), '-']

     import time
     import six
     import threading
     from contextlib import contextmanager
     from django.db import transaction
     from django.core.cache import cache
     from passerelle.utils.jsonresponse import APIError
     DEFAULT_DURATION = 5 * 60  # 5 minutes
     # keep data in cache for 1 day, i.e. we can answer a request from cache for 1 day
-...
            a thread, prevent multiple update using row locks on database models and
            an update cache key.
         '''
         def __init__(self, function, row=None, duration=DEFAULT_DURATION, key_prefix=None):
         def __init__(self, function, logger=None, row=None, duration=DEFAULT_DURATION, key_prefix=None):
             self.function = function
             self.row = row
             self.duration = duration
             self.key_prefix = key_prefix or function.__name__
             self.logger = logger
         def _key(self, *args, **kwargs):
             keys = []
-...
                         cacheline = cache.get(key)
                         if now - timestamp < self.duration:
                             return cacheline['value']
                         updatekey = 'update-' + key
                         update = cache.get(updatekey)
                         if not update or (update['timestamp'] - now >= self.duration):
                             cache.set(updatekey, {'timestamp': now}, CACHE_DURATION)
                             def update():
                                 value = self.function(*args, **kwargs)
                                 cache.set(key, {'value': value, 'timestamp': now}, CACHE_DURATION)
                                 cache.delete(updatekey)
                             threading.Thread(target=update).start()
                         try:
                             value = self.function(*args, **kwargs)
                             cache.set(key, {'value': value, 'timestamp': now}, CACHE_DURATION)
                         except APIError as e:
                             if self.logger:
                                 self.logger.error('failure to update cache %s', e)
                 return cacheline['value']
             else:
                 value = self.function(*args, **kwargs)

             assert rlc() == 1
             assert f.calls == 1
         # Check that cache update only launch one thread and f() is called only once again
         # Check that with cache update f() is called only once again
         freezer.move_to('2018-01-01 00:02:00')
         F.value = 2
         counter = 0
+    -

Projet

Général

Profil

Produits Entr'ouvert » Passerelle

0001-atos-genesys-do-not-use-threads-29320.patch