From dc42feef5695727a219dd5b4fb4a6d9dca9f14cc Mon Sep 17 00:00:00 2001 From: Yang Zhang Date: Fri, 1 Aug 2008 01:11:58 -0400 Subject: [PATCH] just read the master configuration if the cache refresh fails svn path=/trunk/packages/sipb-xen-base/; revision=806 --- .../python-support/sipb-xen-base/invirt/config.py | 46 ++++++++++++-------- 1 file changed, 28 insertions(+), 18 deletions(-) diff --git a/files/usr/share/python-support/sipb-xen-base/invirt/config.py b/files/usr/share/python-support/sipb-xen-base/invirt/config.py index 4a27cea..6d0ab36 100644 --- a/files/usr/share/python-support/sipb-xen-base/invirt/config.py +++ b/files/usr/share/python-support/sipb-xen-base/invirt/config.py @@ -15,41 +15,51 @@ def load(src_path = default_src_path, instead from the original YAML file at src_path and regenerate the cache. I assume I have the permissions to write to the cache directory. """ + # Namespace container for various state variables, so that they can be # updated by closures. ns = struct() if force_refresh: - ns.do_refresh = True + do_refresh = True else: src_mtime = getmtime(src_path) try: cache_mtime = getmtime(cache_path) - except OSError: ns.do_refresh = True - else: ns.do_refresh = src_mtime > cache_mtime + except OSError: do_refresh = True + else: do_refresh = src_mtime > cache_mtime - if not ns.do_refresh: + if not do_refresh: # Try reading from the cache first. This must be transactionally # isolated from concurrent writes to prevent reading an incomplete # (changing) version of the data (but the transaction can share the - # lock with other concurrent reads). - @with_lock_file(lock_file, False) - def read_cache(): - try: ns.cfg = with_closing(file(cache_path)) ( + # lock with other concurrent reads). This isolation is accomplished + # using an atomic filesystem rename in the refreshing stage. + try: ns.cfg = with_closing(file(cache_path)) ( lambda f: json.read(f.read())) - except: ns.do_refresh = True + except: do_refresh = True - if ns.do_refresh: + if do_refresh: # Atomically reload the source and regenerate the cache. The read and # write must be a single transaction, or a stale version may be - # written. - @with_lock_file(lock_file) - def refresh_cache(): - import yaml + # written (if another read/write of a more recent configuration + # is interleaved). The final atomic rename is to keep this + # transactionally isolated from the above cache read. If we fail to + # acquire the lock, just try to load the master configuration. + import yaml + try: loader = yaml.CSafeLoader + except: loader = yaml.SafeLoader + try: + @with_lock_file(lock_file) + def refresh_cache(): + ns.cfg = with_closing(file(src_path)) ( + lambda f: yaml.load(f, loader)) + try: with_closing(file(cache_path + '.tmp', 'w')) ( + lambda f: f.write(json.write(ns.cfg))) + except: pass # silent failure + else: os.rename(cache_path + '.tmp', cache_path) + except IOError: ns.cfg = with_closing(file(src_path)) ( - lambda f: yaml.load(f, yaml.CSafeLoader)) - try: with_closing(file(cache_path, 'w')) ( - lambda f: f.write(json.write(ns.cfg))) - except: pass # silent failure + lambda f: yaml.load(f, loader)) return ns.cfg dicts = load() -- 1.7.9.5