+from __future__ import with_statement
+
import json
from invirt.common import *
+from os import rename
from os.path import getmtime
+from contextlib import closing
default_src_path = '/etc/invirt/master.yaml'
default_cache_path = '/var/lib/invirt/cache.json'
-lock_file = '/var/lib/invirt/cache.lock'
+lock_path = '/var/lib/invirt/cache.lock'
def load(src_path = default_src_path,
cache_path = default_cache_path,
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.
+ # Namespace container for state variables, so that they can be updated by
+ # closures.
ns = struct()
if force_refresh:
do_refresh = True
else:
src_mtime = getmtime(src_path)
- try: cache_mtime = getmtime(cache_path)
- except OSError: do_refresh = True
- else: do_refresh = src_mtime > cache_mtime
+ try: cache_mtime = getmtime(cache_path)
+ except OSError: do_refresh = True
+ else: do_refresh = src_mtime + 1 >= cache_mtime
+
+ # We chose not to simply say
+ #
+ # do_refresh = src_mtime >= cache_time
+ #
+ # because between the getmtime(src_path) and the time the cache is
+ # rewritten, the master configuration may have been updated, so future
+ # checks here would find a cache with a newer mtime than the master
+ # (and thus treat the cache as containing the latest version of the
+ # master). The +1 means that for at least a full second following the
+ # update to the master, this function will refresh the cache, giving us
+ # 1 second to write the cache. Note that if it takes longer than 1
+ # second to write the cache, then this situation could still arise.
+ #
+ # The getmtime calls should logically be part of the same transaction
+ # as the rest of this function (cache read + conditional cache
+ # refresh), but to wrap everything in an flock would cause the
+ # following cache read to be less streamlined.
if not do_refresh:
# Try reading from the cache first. This must be transactionally
# (changing) version of the data (but the transaction can share the
# 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()))
+ try:
+ with closing(file(cache_path)) as f:
+ ns.cfg = json.read(f.read())
except: do_refresh = True
if do_refresh:
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)))
+ with lock_file(lock_path):
+ with closing(file(src_path)) as f:
+ ns.cfg = yaml.load(f, loader)
+ try:
+ with closing(file(cache_path + '.tmp', 'w')) as f:
+ f.write(json.write(ns.cfg))
except: pass # silent failure
- else: os.rename(cache_path + '.tmp', cache_path)
+ else: rename(cache_path + '.tmp', cache_path)
except IOError:
- ns.cfg = with_closing(file(src_path)) (
- lambda f: yaml.load(f, loader))
+ with closing(file(src_path)) as f:
+ ns.cfg = yaml.load(f, loader)
return ns.cfg
dicts = load()