Infra
/
tiramisu
5
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add permissive cache

This commit is contained in:
Emmanuel Garette 2017-07-13 22:04:06 +02:00
parent 962b4eb660
commit d445963429
12 changed files with 307 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
test/test_cache.py
View File

@ -86,7 +86,7 @@ def test_cache_reset():
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
assert 'u1' in settings._p_.get_cached(c) assert 'u1' in settings._p_.get_cached(c)
assert 'u2' not in values._p_.get_cached(c) assert 'u2' not in values._p_.get_cached(c)
assert 'u2' not in settings._p_.get_cached(c) assert 'u2' in settings._p_.get_cached(c)
#when remove a value #when remove a value
c.u1 c.u1
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
@ -95,7 +95,7 @@ def test_cache_reset():
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
assert 'u1' in settings._p_.get_cached(c) assert 'u1' in settings._p_.get_cached(c)
assert 'u2' not in values._p_.get_cached(c) assert 'u2' not in values._p_.get_cached(c)
assert 'u2' not in settings._p_.get_cached(c) assert 'u2' in settings._p_.get_cached(c)
#when add/del property #when add/del property
c.u1 c.u1
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
@ -144,7 +144,7 @@ def test_cache_reset_multi():
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
assert 'u1' in settings._p_.get_cached(c) assert 'u1' in settings._p_.get_cached(c)
assert 'u3' not in values._p_.get_cached(c) assert 'u3' not in values._p_.get_cached(c)
assert 'u3' not in settings._p_.get_cached(c) assert 'u3' in settings._p_.get_cached(c)
#when append value #when append value
c.u1 c.u1
c.u3 c.u3
@ -156,7 +156,7 @@ def test_cache_reset_multi():
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
assert 'u1' in settings._p_.get_cached(c) assert 'u1' in settings._p_.get_cached(c)
assert 'u3' not in values._p_.get_cached(c) assert 'u3' not in values._p_.get_cached(c)
assert 'u3' not in settings._p_.get_cached(c) assert 'u3' in settings._p_.get_cached(c)
#when pop value #when pop value
c.u1 c.u1
c.u3 c.u3
@ -168,7 +168,7 @@ def test_cache_reset_multi():
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
assert 'u1' in settings._p_.get_cached(c) assert 'u1' in settings._p_.get_cached(c)
assert 'u3' not in values._p_.get_cached(c) assert 'u3' not in values._p_.get_cached(c)
assert 'u3' not in settings._p_.get_cached(c) assert 'u3' in settings._p_.get_cached(c)
#when remove a value #when remove a value
c.u1 c.u1
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
@ -177,7 +177,7 @@ def test_cache_reset_multi():
assert 'u1' in values._p_.get_cached(c) assert 'u1' in values._p_.get_cached(c)
assert 'u1' in settings._p_.get_cached(c) assert 'u1' in settings._p_.get_cached(c)
assert 'u3' not in values._p_.get_cached(c) assert 'u3' not in values._p_.get_cached(c)
assert 'u3' not in settings._p_.get_cached(c) assert 'u3' in settings._p_.get_cached(c)
def test_reset_cache(): def test_reset_cache():
@ -313,7 +313,8 @@ def test_force_cache():
'u2': {None: (None, None)}, 'u2': {None: (None, None)},
'u3': {None: ([], None)}, 'u3': {None: ([], None)},
'u4': {None: (None, None)}} 'u4': {None: (None, None)}}
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {'u1': {None: (set(['empty']), None)}, assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'validator', 'warnings']), None)},
'u1': {None: (set(['empty']), None)},
'u2': {None: (set([]), None)}, 'u2': {None: (set([]), None)},
'u3': {None: (set(['empty']), None)}, 'u3': {None: (set(['empty']), None)},
'u4': {None: (set(['disabled']), None)}} 'u4': {None: (set(['disabled']), None)}}
@ -323,7 +324,8 @@ def test_force_cache():
assert c.cfgimpl_get_values()._p_.get_cached(c) == {'u1': {None: ([], None)}, assert c.cfgimpl_get_values()._p_.get_cached(c) == {'u1': {None: ([], None)},
'u2': {None: (None, None)}, 'u2': {None: (None, None)},
'u3': {None: ([], None)}} 'u3': {None: ([], None)}}
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {'u1': {None: (set(['empty']), None)}, assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'disabled', 'empty', 'everything_frozen', 'frozen', 'mandatory', 'validator', 'warnings']), None)},
'u1': {None: (set(['empty']), None)},
'u2': {None: (set([]), None)}, 'u2': {None: (set([]), None)},
'u3': {None: (set(['empty']), None)}, 'u3': {None: (set(['empty']), None)},
'u4': {None: (set(['disabled']), None)}} 'u4': {None: (set(['disabled']), None)}}
@ -354,7 +356,7 @@ def test_cache_master_slave():
assert cache['ip_admin_eth0.netmask_admin_eth0'][None][0] == [None] assert cache['ip_admin_eth0.netmask_admin_eth0'][None][0] == [None]
assert cache['ip_admin_eth0.netmask_admin_eth0'][0][0] is None assert cache['ip_admin_eth0.netmask_admin_eth0'][0][0] is None
cache = cfg.cfgimpl_get_settings()._p_.get_cached(cfg) cache = cfg.cfgimpl_get_settings()._p_.get_cached(cfg)
assert set(cache.keys()) == set(['ip_admin_eth0', 'ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0']) assert set(cache.keys()) == set([None, 'ip_admin_eth0', 'ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
assert set(cache['ip_admin_eth0'].keys()) == set([None]) assert set(cache['ip_admin_eth0'].keys()) == set([None])
assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None]) assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None])
assert set(cache['ip_admin_eth0.netmask_admin_eth0'].keys()) == set([None, 0]) assert set(cache['ip_admin_eth0.netmask_admin_eth0'].keys()) == set([None, 0])
@ -371,7 +373,7 @@ def test_cache_master_slave():
assert cache['ip_admin_eth0.netmask_admin_eth0'][0][0] is None assert cache['ip_admin_eth0.netmask_admin_eth0'][0][0] is None
assert cache['ip_admin_eth0.netmask_admin_eth0'][1][0] is None assert cache['ip_admin_eth0.netmask_admin_eth0'][1][0] is None
cache = cfg.cfgimpl_get_settings()._p_.get_cached(cfg) cache = cfg.cfgimpl_get_settings()._p_.get_cached(cfg)
assert set(cache.keys()) == set(['ip_admin_eth0', 'ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0']) assert set(cache.keys()) == set([None, 'ip_admin_eth0', 'ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
assert set(cache['ip_admin_eth0'].keys()) == set([None]) assert set(cache['ip_admin_eth0'].keys()) == set([None])
assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None]) assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None])
assert set(cache['ip_admin_eth0.netmask_admin_eth0'].keys()) == set([None, 0, 1]) assert set(cache['ip_admin_eth0.netmask_admin_eth0'].keys()) == set([None, 0, 1])
@ -393,7 +395,8 @@ def test_cache_callback():
cfg.cfgimpl_get_settings().remove('expire') cfg.cfgimpl_get_settings().remove('expire')
cfg.read_write() cfg.read_write()
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val2': {None: (set(['mandatory']), None)}, 'val2': {None: (set(['mandatory']), None)},
'val3': {None: (set([]), None)}, 'val3': {None: (set([]), None)},
'val4': {None: (set([]), None)}, 'val4': {None: (set([]), None)},
@ -404,12 +407,15 @@ def test_cache_callback():
'val4': {None: ('val', None)}, 'val4': {None: ('val', None)},
'val5': {None: (['yes'], None)}} 'val5': {None: (['yes'], None)}}
cfg.val1 = 'new' cfg.val1 = 'new'
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val3': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val3': {None: (set([]), None)},
'val5': {None: (set(['empty']), None)}} 'val5': {None: (set(['empty']), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val3': {None: ('yes', None)}, assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val3': {None: ('yes', None)},
'val5': {None: (['yes'], None)}} 'val5': {None: (['yes'], None)}}
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val2': {None: (set(['mandatory']), None)}, 'val2': {None: (set(['mandatory']), None)},
'val3': {None: (set([]), None)}, 'val3': {None: (set([]), None)},
'val4': {None: (set([]), None)}, 'val4': {None: (set([]), None)},
@ -420,8 +426,10 @@ def test_cache_callback():
'val4': {None: ('new', None)}, 'val4': {None: ('new', None)},
'val5': {None: (['yes'], None)}} 'val5': {None: (['yes'], None)}}
cfg.val3 = 'new2' cfg.val3 = 'new2'
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val2': {None: (set(['mandatory']), None)}, 'val2': {None: (set(['mandatory']), None)},
'val3': {None: (set([]), None)},
'val4': {None: (set([]), None)}, 'val4': {None: (set([]), None)},
'val5': {None: (set(['empty']), None)}} 'val5': {None: (set(['empty']), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1': {None: ('new', None)}, assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1': {None: ('new', None)},
@ -429,7 +437,8 @@ def test_cache_callback():
'val4': {None: ('new', None)}, 'val4': {None: ('new', None)},
'val5': {None: (['yes'], None)}} 'val5': {None: (['yes'], None)}}
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val2': {None: (set(['mandatory']), None)}, 'val2': {None: (set(['mandatory']), None)},
'val3': {None: (set([]), None)}, 'val3': {None: (set([]), None)},
'val4': {None: (set([]), None)}, 'val4': {None: (set([]), None)},
@ -440,16 +449,19 @@ def test_cache_callback():
'val4': {None: ('new', None)}, 'val4': {None: ('new', None)},
'val5': {None: (['yes'], None)}} 'val5': {None: (['yes'], None)}}
cfg.val4 = 'new3' cfg.val4 = 'new3'
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val2': {None: (set(['mandatory']), None)}, 'val2': {None: (set(['mandatory']), None)},
'val3': {None: (set([]), None)}, 'val3': {None: (set([]), None)},
'val4': {None: (set([]), None)},
'val5': {None: (set(['empty']), None)}} 'val5': {None: (set(['empty']), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1': {None: ('new', None)}, assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1': {None: ('new', None)},
'val2': {None: ('new', None)}, 'val2': {None: ('new', None)},
'val3': {None: ('new2', None)}, 'val3': {None: ('new2', None)},
'val5': {None: (['yes'], None)}} 'val5': {None: (['yes'], None)}}
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val2': {None: (set(['mandatory']), None)}, 'val2': {None: (set(['mandatory']), None)},
'val3': {None: (set([]), None)}, 'val3': {None: (set([]), None)},
'val4': {None: (set([]), None)}, 'val4': {None: (set([]), None)},
@ -460,16 +472,19 @@ def test_cache_callback():
'val4': {None: ('new3', None)}, 'val4': {None: ('new3', None)},
'val5': {None: (['yes'], None)}} 'val5': {None: (['yes'], None)}}
cfg.val5.append('new4') cfg.val5.append('new4')
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val2': {None: (set(['mandatory']), None)}, 'val2': {None: (set(['mandatory']), None)},
'val3': {None: (set([]), None)}, 'val3': {None: (set([]), None)},
'val4': {None: (set([]), None)}} 'val4': {None: (set([]), None)},
'val5': {None: (set(['empty']), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1': {None: ('new', None)}, assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1': {None: ('new', None)},
'val2': {None: ('new', None)}, 'val2': {None: ('new', None)},
'val3': {None: ('new2', None)}, 'val3': {None: ('new2', None)},
'val4': {None: ('new3', None)}} 'val4': {None: ('new3', None)}}
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val2': {None: (set(['mandatory']), None)}, 'val2': {None: (set(['mandatory']), None)},
'val3': {None: (set([]), None)}, 'val3': {None: (set([]), None)},
'val4': {None: (set([]), None)}, 'val4': {None: (set([]), None)},
@ -491,15 +506,19 @@ def test_cache_master_and_slaves_master():
cfg.cfgimpl_get_settings().remove('expire') cfg.cfgimpl_get_settings().remove('expire')
cfg.read_write() cfg.read_write()
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val1.val1': {None: (set(['empty']), None)}, 'val1.val1': {None: (set(['empty']), None)},
'val1.val2': {None: (set([]), None)}} 'val1.val2': {None: (set([]), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([], None)}, 'val1.val2': {None: ([], None)}} assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([], None)}, 'val1.val2': {None: ([], None)}}
cfg.val1.val1.append() cfg.val1.val1.append()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}} assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val1.val1': {None: (set(['empty']), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {} assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {}
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val1.val1': {None: (set(['empty']), None)}, 'val1.val1': {None: (set(['empty']), None)},
'val1.val2': {None: (set([]), None), 0: (set([]), None)}} 'val1.val2': {None: (set([]), None), 0: (set([]), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([None], None)}, assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([None], None)},
@ -507,11 +526,14 @@ def test_cache_master_and_slaves_master():
cfg.val1.val1.append() cfg.val1.val1.append()
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
cfg.val1.val2[1] = 'oui' cfg.val1.val2[1] = 'oui'
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1.val1': {None: (set(['empty']), None)}} 'val1': {None: (set([]), None)},
'val1.val1': {None: (set(['empty']), None)},
'val1.val2': {None: (set([]), None), 0: (set([]), None), 1: (set([]), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([None, None], None)}} assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([None, None], None)}}
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val1.val1': {None: (set(['empty']), None)}, 'val1.val1': {None: (set(['empty']), None)},
'val1.val2': {None: (set([]), None), 0: (set([]), None), 1: (set([]), None)}} 'val1.val2': {None: (set([]), None), 0: (set([]), None), 1: (set([]), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([None, None], None)}, assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([None, None], None)},
@ -528,15 +550,19 @@ def test_cache_master_callback():
cfg.cfgimpl_get_settings().remove('expire') cfg.cfgimpl_get_settings().remove('expire')
cfg.read_write() cfg.read_write()
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val1.val1': {None: (set(['empty']), None)}, 'val1.val1': {None: (set(['empty']), None)},
'val1.val2': {None: (set([]), None)}} 'val1.val2': {None: (set([]), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([], None)}, 'val1.val2': {None: ([], None)}} assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([], None)}, 'val1.val2': {None: ([], None)}}
cfg.val1.val1.append() cfg.val1.val1.append()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}} assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val1.val1': {None: (set(['empty']), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {} assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {}
cfg.cfgimpl_get_values().force_cache() cfg.cfgimpl_get_values().force_cache()
assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {'val1': {None: (set([]), None)}, assert cfg.cfgimpl_get_settings()._p_.get_cached(cfg) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'val1': {None: (set([]), None)},
'val1.val1': {None: (set(['empty']), None)}, 'val1.val1': {None: (set(['empty']), None)},
'val1.val2': {None: (set([]), None), 0: (set([]), None)}} 'val1.val2': {None: (set([]), None), 0: (set([]), None)}}
assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([None], None)}, assert cfg.cfgimpl_get_values()._p_.get_cached(cfg) == {'val1.val1': {None: ([None], None)},
@ -554,32 +580,67 @@ def test_cache_requires():
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {} assert c.cfgimpl_get_settings()._p_.get_cached(c) == {}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {} assert c.cfgimpl_get_values()._p_.get_cached(c) == {}
assert c.ip_address_service == None assert c.ip_address_service == None
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {'activate_service': {None: (set([]), None)}, assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}} 'ip_address_service': {None: (set([]), None)}}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {'ip_address_service': {None: (None, None)}} assert c.cfgimpl_get_values()._p_.get_cached(c) == {'ip_address_service': {None: (None, None)}}
c.cfgimpl_get_values().force_cache() c.cfgimpl_get_values().force_cache()
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {'activate_service': {None: (set([]), None)}, assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}} 'ip_address_service': {None: (set([]), None)}}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {'ip_address_service': {None: (None, None)}, assert c.cfgimpl_get_values()._p_.get_cached(c) == {'ip_address_service': {None: (None, None)},
'activate_service': {None: (True, None)}} 'activate_service': {None: (True, None)}}
c.ip_address_service = '1.1.1.1' c.ip_address_service = '1.1.1.1'
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {'activate_service': {None: (set([]), None)}} assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {'activate_service': {None: (True, None)}} assert c.cfgimpl_get_values()._p_.get_cached(c) == {'activate_service': {None: (True, None)}}
c.cfgimpl_get_values().force_cache() c.cfgimpl_get_values().force_cache()
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {'activate_service': {None: (set([]), None)}, assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}} 'ip_address_service': {None: (set([]), None)}}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {'ip_address_service': {None: ('1.1.1.1', None)}, assert c.cfgimpl_get_values()._p_.get_cached(c) == {'ip_address_service': {None: ('1.1.1.1', None)},
'activate_service': {None: (True, None)}} 'activate_service': {None: (True, None)}}
c.activate_service = False c.activate_service = False
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {} assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)}}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {} assert c.cfgimpl_get_values()._p_.get_cached(c) == {}
c.cfgimpl_get_values().force_cache() c.cfgimpl_get_values().force_cache()
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {'activate_service': {None: (set([]), None)}, assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set(['disabled']), None)}} 'ip_address_service': {None: (set(['disabled']), None)}}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {'activate_service': {None: (False, None)}} assert c.cfgimpl_get_values()._p_.get_cached(c) == {'activate_service': {None: (False, None)}}
def test_cache_global_properties():
a = BoolOption('activate_service', '', True)
b = IPOption('ip_address_service', '',
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
od = OptionDescription('service', '', [a, b])
c = Config(od)
c.cfgimpl_get_settings().remove('expire')
c.read_write()
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {}
assert c.ip_address_service == None
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}}
assert c.cfgimpl_get_values()._p_.get_cached(c) == {'ip_address_service': {None: (None, None)}}
c.cfgimpl_get_settings().remove('disabled')
assert c.ip_address_service == None
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}}
c.cfgimpl_get_settings().append('test')
assert c.ip_address_service == None
assert c.cfgimpl_get_settings()._p_.get_cached(c) == {None: {None: (set(['cache', 'frozen', 'hidden', 'validator', 'warnings', 'test']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}}

12
test/test_option_setting.py
View File

@ -536,6 +536,18 @@ def test_reset_properties_force_store_value():
raises(ValueError, 'setting.reset(all_properties=True, opt=option)') raises(ValueError, 'setting.reset(all_properties=True, opt=option)')
def test_set_modified_value():
gcdummy = BoolOption('dummy', 'dummy', default=False, properties=('force_store_value',))
gcgroup = OptionDescription('gc', '', [gcdummy])
descr = OptionDescription('tiramisu', '', [gcgroup])
cfg = Config(descr)
setting = cfg.cfgimpl_get_settings()
option = cfg.cfgimpl_get_description().gc.dummy
assert setting._p_.get_modified_properties() == {}
setting._p_.set_modified_properties({None: set(('frozen', 'expire', 'cache', 'validator', 'warnings'))})
assert setting._p_.get_modified_properties() == {None: set(('frozen', 'expire', 'cache', 'validator', 'warnings'))}
def test_pprint(): def test_pprint():
msg_error = _("cannot access to {0} \"{1}\" because has {2} {3}") msg_error = _("cannot access to {0} \"{1}\" because has {2} {3}")
msg_is = _('the value of "{0}" is "{1}"') msg_is = _('the value of "{0}" is "{1}"')

88
test/test_state.py
View File

@ -536,47 +536,47 @@ def test_state_groupconfig():
pass pass
def test_state_unkown_setting_owner(): #def test_state_unkown_setting_owner():
"""load an unknow _owner, should create it""" # """load an unknow _owner, should create it"""
assert not 'supernewuser' in owners.__dict__ # assert not 'supernewuser' in owners.__dict__
val = """ccopy_reg # val = """ccopy_reg
_reconstructor #_reconstructor
p0 #p0
(ctiramisu.setting #(ctiramisu.setting
Settings #Settings
p1 #p1
c__builtin__ #c__builtin__
object #object
p2 #p2
Ntp3 #Ntp3
Rp4 #Rp4
(dp5 #(dp5
S'_owner' #S'_owner'
p6 #p6
S'supernewuser' #S'supernewuser'
p7 #p7
sS'_p_' #sS'_p_'
p8 #p8
g0 #g0
(ctiramisu.storage.dictionary.setting #(ctiramisu.storage.dictionary.setting
Settings #Properties
p9 #p9
g2 #g2
Ntp10 #Ntp10
Rp11 #Rp11
(dp12 #(dp12
S'_cache' #S'_cache'
p13 #p13
(dp14 #(dp14
sS'_permissives' #sS'_permissives'
p15 #p15
(dp16 #(dp16
sS'_properties' #sS'_properties'
p17 #p17
(dp18 #(dp18
sbsb. #sbsb.
.""" #."""
if sys.version_info[0] >= 3: # pragma: optional cover # if sys.version_info[0] >= 3: # pragma: optional cover
val = bytes(val, "UTF-8") # val = bytes(val, "UTF-8")
loads(val) # loads(val)
assert 'supernewuser' in owners.__dict__ # assert 'supernewuser' in owners.__dict__

38
tiramisu/config.py
View File

@ -73,7 +73,7 @@ class SubConfig(object):
def cfgimpl_reset_cache(self, def cfgimpl_reset_cache(self,
only_expired=False, only_expired=False,
only=('values', 'settings'), only=('values', 'properties', 'permissives', 'settings'),
opt=None, opt=None,
path=None): path=None):
"""reset all settings in cache """reset all settings in cache
@ -84,13 +84,15 @@ class SubConfig(object):
context = self._cfgimpl_get_context() context = self._cfgimpl_get_context()
if 'values' in only: if 'values' in only:
values = context.cfgimpl_get_values() values = context.cfgimpl_get_values()
if 'settings' in only: if 'settings' in only or 'properties' in only or 'permissives' in only:
settings = context.cfgimpl_get_settings() settings = context.cfgimpl_get_settings()
if only_expired: if only_expired:
if 'values' in only: if 'values' in only:
values._p_.reset_expired_cache(int(time())) values._p_.reset_expired_cache(int(time()))
if 'settings' in only: if 'settings' in only or 'properties' in only:
settings._p_.reset_expired_cache(int(time())) settings._p_.reset_expired_cache(int(time()))
if 'settings' in only or 'permissives' in only:
settings._pp_.reset_expired_cache(int(time()))
elif not None in (opt, path): elif not None in (opt, path):
if opt.__class__.__name__ == 'DynOptionDescription': if opt.__class__.__name__ == 'DynOptionDescription':
descr = context.cfgimpl_get_description() descr = context.cfgimpl_get_description()
@ -102,8 +104,10 @@ class SubConfig(object):
path = subpath + '.' + spath[-1] + suffix path = subpath + '.' + spath[-1] + suffix
if 'values' in only: if 'values' in only:
values._p_.delcache(path) values._p_.delcache(path)
if 'settings' in only: if 'settings' in only or 'properties' in only:
settings._p_.delcache(path) settings._p_.delcache(path)
if 'settings' in only or 'permissives' in only:
settings._pp_.delcache(path)
elif not isinstance(opt, DynSymLinkOption) and opt._is_subdyn(): elif not isinstance(opt, DynSymLinkOption) and opt._is_subdyn():
descr = context.cfgimpl_get_description() descr = context.cfgimpl_get_description()
spath = path.split('.') spath = path.split('.')
@ -126,23 +130,33 @@ class SubConfig(object):
path += '.' + spath3 + suffix path += '.' + spath3 + suffix
if 'values' in only: if 'values' in only:
values._p_.delcache(path) values._p_.delcache(path)
if 'settings' in only: if 'settings' in only or 'properties' in only:
settings._p_.delcache(path) settings._p_.delcache(path)
if 'settings' in only or 'permissives' in only:
settings._pp_.delcache(path)
else: else:
if 'values' in only: if 'values' in only:
values._p_.delcache(path) values._p_.delcache(path)
if 'settings' in only: if 'settings' in only or 'permissives' in only:
settings._p_.delcache(path) settings._p_.delcache(path)
if 'settings' in only or 'permissives' in only:
settings._pp_.delcache(path)
for option in getattr(opt, '_dependencies', []): for option in getattr(opt, '_dependencies', []):
if 'values' in only: if 'values' in only:
option.reset_cache(opt, values, 'values') option.reset_cache(opt, values, 'values')
if 'settings' in only: if 'settings' in only:
option.reset_cache(opt, settings, 'settings') option.reset_cache(opt, settings, 'settings')
else:
if 'properties' in only:
option.reset_cache(opt, settings, 'properties')
if 'permissives' in only:
option.reset_cache(opt, settings, 'permissives')
else: else:
if 'values' in only: if 'values' in only:
values._p_.reset_all_cache() values._p_.reset_all_cache()
if 'settings' in only: if 'settings' in only:
settings._p_.reset_all_cache() settings._p_.reset_all_cache()
settings._pp_.reset_all_cache()
def cfgimpl_get_home_by_path(self, path, force_permissive=False, def cfgimpl_get_home_by_path(self, path, force_permissive=False,
returns_raise=False, _setting_properties=undefined): returns_raise=False, _setting_properties=undefined):
@ -752,8 +766,8 @@ class _CommonConfig(SubConfig):
session)) session))
config.cfgimpl_get_settings()._p_.set_modified_properties(self.cfgimpl_get_settings( config.cfgimpl_get_settings()._p_.set_modified_properties(self.cfgimpl_get_settings(
)._p_.get_modified_properties()) )._p_.get_modified_properties())
config.cfgimpl_get_settings()._p_.set_modified_permissives(self.cfgimpl_get_settings( config.cfgimpl_get_settings()._pp_.set_modified_permissives(self.cfgimpl_get_settings(
)._p_.get_modified_permissives()) )._pp_.get_modified_permissives())
return config return config
@ -781,7 +795,7 @@ class Config(_CommonConfig):
self._impl_settings = force_settings self._impl_settings = force_settings
self._impl_values = Values(self, force_values) self._impl_values = Values(self, force_values)
else: else:
settings, values = get_storages(self, session_id, persistent) properties, permissives, values = get_storages(self, session_id, persistent)
if name is undefined: if name is undefined:
name = 'config' name = 'config'
if session_id is not None: if session_id is not None:
@ -790,7 +804,7 @@ class Config(_CommonConfig):
raise ValueError(_("name is mandatory for the config").format(name)) raise ValueError(_("name is mandatory for the config").format(name))
if name is not None and not valid_name(name): # pragma: optional cover if name is not None and not valid_name(name): # pragma: optional cover
raise ValueError(_("invalid name: {0} for config").format(name)) raise ValueError(_("invalid name: {0} for config").format(name))
self._impl_settings = Settings(self, settings) self._impl_settings = Settings(self, properties, permissives)
self._impl_values = Values(self, values) self._impl_values = Values(self, values)
super(Config, self).__init__(descr, weakref.ref(self)) super(Config, self).__init__(descr, weakref.ref(self))
self._impl_meta = None self._impl_meta = None
@ -829,8 +843,8 @@ class GroupConfig(_CommonConfig):
raise ConflictError(_('config name must be uniq in ' raise ConflictError(_('config name must be uniq in '
'groupconfig for {0}').format(name)) 'groupconfig for {0}').format(name))
self._impl_children = children self._impl_children = children
settings, values = get_storages(self, session_id, persistent) properties, permissives, values = get_storages(self, session_id, persistent)
self._impl_settings = Settings(self, settings) self._impl_settings = Settings(self, properties, permissives)
self._impl_values = Values(self, values) self._impl_values = Values(self, values)
super(GroupConfig, self).__init__(_descr, weakref.ref(self)) super(GroupConfig, self).__init__(_descr, weakref.ref(self))
self._impl_meta = None self._impl_meta = None

69
tiramisu/setting.py
View File

@ -310,9 +310,9 @@ class Property(object):
#____________________________________________________________ #____________________________________________________________
class Settings(object): class Settings(object):
"``config.Config()``'s configuration options settings" "``config.Config()``'s configuration options settings"
__slots__ = ('context', '_owner', '_p_', '__weakref__') __slots__ = ('context', '_owner', '_p_', '_pp_', '__weakref__')
def __init__(self, context, storage): def __init__(self, context, properties, permissives):
""" """
initializer initializer
@ -325,7 +325,8 @@ class Settings(object):
# generic owner # generic owner
self._owner = owners.user self._owner = owners.user
self.context = weakref.ref(context) self.context = weakref.ref(context)
self._p_ = storage self._p_ = properties
self._pp_ = permissives
def _getcontext(self): def _getcontext(self):
"""context could be None, we need to test it """context could be None, we need to test it
@ -370,7 +371,7 @@ class Settings(object):
if opt is not None and _path is None: if opt is not None and _path is None:
_path = opt.impl_getpath(self._getcontext()) _path = opt.impl_getpath(self._getcontext())
self._p_.delproperties(_path) self._p_.delproperties(_path)
self._getcontext().cfgimpl_reset_cache(opt=opt, path=_path) self._getcontext().cfgimpl_reset_cache(opt=opt, path=_path, only=('settings',))
def _getproperties(self, opt=None, path=None, def _getproperties(self, opt=None, path=None,
setting_properties=undefined, read_write=True, setting_properties=undefined, read_write=True,
@ -378,14 +379,27 @@ class Settings(object):
""" """
""" """
if opt is None: if opt is None:
props = self._p_.getproperties(path, default_properties) ntime = int(time())
if self._p_.hascache(path, index):
is_cached, props = self._p_.getcache(path, ntime, index)
else:
is_cached = False
if not is_cached or 'cache' not in props:
props = self._p_.getproperties(path, default_properties)
if 'cache' in props:
if 'expire' in props:
ntime = ntime + expires_time
else:
ntime = None
self._p_.setcache(path, props, ntime, index)
else: else:
if setting_properties is undefined:
setting_properties = self._getproperties(read_write=False)
if path is None: # pragma: optional cover if path is None: # pragma: optional cover
raise ValueError(_('if opt is not None, path should not be' raise ValueError(_('if opt is not None, path should not be'
' None in _getproperties')) ' None in _getproperties'))
if setting_properties is undefined:
setting_properties = self._getproperties(read_write=False)
is_cached = False is_cached = False
if apply_requires: if apply_requires:
if 'cache' in setting_properties and 'expire' in setting_properties: if 'cache' in setting_properties and 'expire' in setting_properties:
ntime = int(time()) ntime = int(time())
@ -440,6 +454,26 @@ class Settings(object):
self._p_.setproperties(path, properties) self._p_.setproperties(path, properties)
self._getcontext().cfgimpl_reset_cache(opt=opt, path=path) self._getcontext().cfgimpl_reset_cache(opt=opt, path=path)
def getpermissive(self, setting_properties, path=None):
if 'cache' in setting_properties and 'expire' in setting_properties:
ntime = int(time())
else:
ntime = None
if 'cache' in setting_properties and self._pp_.hascache(path, None):
is_cached, perm = self._pp_.getcache(path, ntime, None)
else:
is_cached = False
if not is_cached:
if path is not None:
perm = self._pp_.getpermissive(path)
else:
perm = self._pp_.getpermissive()
if 'cache' in setting_properties:
if 'expire' in setting_properties:
ntime = ntime + expires_time
self._pp_.setcache(path, perm, ntime, None)
return perm
#____________________________________________________________ #____________________________________________________________
def validate_properties(self, opt_or_descr, is_descr, check_frozen, path, def validate_properties(self, opt_or_descr, is_descr, check_frozen, path,
value=None, force_permissive=False, value=None, force_permissive=False,
@ -472,10 +506,10 @@ class Settings(object):
# remove opt permissive # remove opt permissive
# permissive affect option's permission with or without permissive # permissive affect option's permission with or without permissive
# global property # global property
properties -= self._p_.getpermissive(path) properties -= self.getpermissive(setting_properties, path)
# remove global permissive if need # remove global permissive if need
if force_permissive is True or 'permissive' in setting_properties: if force_permissive is True or 'permissive' in setting_properties:
properties -= self._p_.getpermissive() properties -= self.getpermissive(setting_properties)
# calc properties # calc properties
properties &= setting_properties properties &= setting_properties
@ -540,8 +574,15 @@ class Settings(object):
path = opt.impl_getpath(self._getcontext()) path = opt.impl_getpath(self._getcontext())
if not isinstance(permissive, tuple): # pragma: optional cover if not isinstance(permissive, tuple): # pragma: optional cover
raise TypeError(_('permissive must be a tuple')) raise TypeError(_('permissive must be a tuple'))
self._p_.setpermissive(path, permissive) self._pp_.setpermissive(path, permissive)
self._getcontext().cfgimpl_reset_cache(opt=opt, path=path) setting_properties = self._getproperties(read_write=False)
self._getcontext().cfgimpl_reset_cache(opt=opt, path=path, only=('values',))
if 'cache' in setting_properties:
if 'expire' in setting_properties:
ntime = int(time()) + expires_time
else:
ntime = None
self._pp_.setcache(path, set(permissive), ntime, None)
#____________________________________________________________ #____________________________________________________________
def setowner(self, owner): def setowner(self, owner):
@ -549,6 +590,7 @@ class Settings(object):
if not isinstance(owner, owners.Owner): # pragma: optional cover if not isinstance(owner, owners.Owner): # pragma: optional cover
raise TypeError(_("invalid generic owner {0}").format(str(owner))) raise TypeError(_("invalid generic owner {0}").format(str(owner)))
self._owner = owner self._owner = owner
#FIXME qu'est ce qui se passe si pas de owner ??
def getowner(self): def getowner(self):
return self._owner return self._owner
@ -718,16 +760,17 @@ class Settings(object):
return self._p_.get_modified_properties() return self._p_.get_modified_properties()
def get_modified_permissives(self): def get_modified_permissives(self):
return self._p_.get_modified_permissives() return self._pp_.get_modified_permissives()
def __getstate__(self): def __getstate__(self):
return {'_p_': self._p_, '_owner': str(self._owner)} return {'_p_': self._p_, '_pp_': self._pp_, '_owner': str(self._owner)}
def _impl_setstate(self, storage): def _impl_setstate(self, storage):
self._p_._storage = storage self._p_._storage = storage
def __setstate__(self, states): def __setstate__(self, states):
self._p_ = states['_p_'] self._p_ = states['_p_']
self._pp_ = states['_pp_']
try: try:
self._owner = getattr(owners, states['_owner']) self._owner = getattr(owners, states['_owner'])
except AttributeError: except AttributeError:

5
tiramisu/storage/__init__.py
View File

@ -133,9 +133,10 @@ def get_storages(context, session_id, persistent):
session_id = gen_id(context) session_id = gen_id(context)
imp = storage_type.get() imp = storage_type.get()
storage = imp.Storage(session_id, persistent) storage = imp.Storage(session_id, persistent)
settings = imp.Settings(storage) properties = imp.Properties(storage)
permissives = imp.Permissives(storage)
values = imp.Values(storage) values = imp.Values(storage)
return settings, values return properties, permissives, values
def get_storages_option(type_): def get_storages_option(type_):

6
tiramisu/storage/dictionary/__init__.py
View File

@ -23,9 +23,9 @@ The advantage of this solution is that you can easily create a Config and
use it. But if something goes wrong, you will lost your modifications. use it. But if something goes wrong, you will lost your modifications.
""" """
from .value import Values from .value import Values
from .setting import Settings from .setting import Properties, Permissives
from .storage import setting, Storage, list_sessions, delete_session from .storage import setting, Storage, list_sessions, delete_session
from .option import StorageBase, StorageOptionDescription, StorageMasterSlaves from .option import StorageBase, StorageOptionDescription, StorageMasterSlaves
__all__ = (setting, Values, Settings, Storage, list_sessions, delete_session, __all__ = ('setting', 'Values', 'Properties', 'Permissives', 'Storage', 'list_sessions',
StorageBase, StorageOptionDescription, StorageMasterSlaves) 'delete_session', 'StorageBase', 'StorageOptionDescription', 'StorageMasterSlaves')

29
tiramisu/storage/dictionary/setting.py
View File

@ -19,16 +19,15 @@ from copy import copy
from ..util import Cache from ..util import Cache
class Settings(Cache): class Properties(Cache):
__slots__ = ('_properties', '_permissives') __slots__ = ('_properties',)
def __init__(self, storage): def __init__(self, storage):
# properties attribute: the name of a property enables this property # properties attribute: the name of a property enables this property
# key is None for global properties # key is None for global properties
self._properties = {} self._properties = {}
# permissive properties # permissive properties
self._permissives = {} super(Properties, self).__init__(storage)
super(Settings, self).__init__(storage)
# properties # properties
def setproperties(self, path, properties): def setproperties(self, path, properties):
@ -47,12 +46,6 @@ class Settings(Cache):
if path in self._properties: if path in self._properties:
del(self._properties[path]) del(self._properties[path])
def setpermissive(self, path, permissive):
self._permissives[path] = frozenset(permissive)
def getpermissive(self, path=None):
return self._permissives.get(path, frozenset())
def get_modified_properties(self): def get_modified_properties(self):
"""return all modified settings in a dictionary """return all modified settings in a dictionary
example: {'path1': set(['prop1', 'prop2'])} example: {'path1': set(['prop1', 'prop2'])}
@ -62,6 +55,21 @@ class Settings(Cache):
def set_modified_properties(self, properties): def set_modified_properties(self, properties):
self._properties = properties self._properties = properties
class Permissives(Cache):
__slots__ = ('_permissives',)
def __init__(self, storage):
# permissive properties
self._permissives = {}
super(Permissives, self).__init__(storage)
def setpermissive(self, path, permissive):
self._permissives[path] = frozenset(permissive)
def getpermissive(self, path=None):
return self._permissives.get(path, frozenset())
def get_modified_permissives(self): def get_modified_permissives(self):
"""return all modified permissives in a dictionary """return all modified permissives in a dictionary
example: {'path1': set(['perm1', 'perm2'])} example: {'path1': set(['perm1', 'perm2'])}
@ -70,3 +78,4 @@ class Settings(Cache):
def set_modified_permissives(self, permissives): def set_modified_permissives(self, permissives):
self._permissives = permissives self._permissives = permissives

4
tiramisu/storage/sqlite3/__init__.py
View File

@ -21,7 +21,7 @@ You should not configure differents Configs with same session_id.
""" """
from .value import Values from .value import Values
from .setting import Settings from .setting import Properties, Permissives
from .storage import Storage, list_sessions, delete_session from .storage import Storage, list_sessions, delete_session
__all__ = ('Values', 'Settings', 'Storage', 'list_sessions', 'delete_session') __all__ = ('Values', 'Properties', 'Permissives', 'Storage', 'list_sessions', 'delete_session')

58
tiramisu/storage/sqlite3/setting.py
View File

@ -18,11 +18,11 @@
from .sqlite3db import Sqlite3DB from .sqlite3db import Sqlite3DB
class Settings(Sqlite3DB): class Properties(Sqlite3DB):
__slots__ = tuple() __slots__ = tuple()
def __init__(self, storage): def __init__(self, storage):
super(Settings, self).__init__(storage) super(Properties, self).__init__(storage)
# properties # properties
def setproperties(self, path, properties): def setproperties(self, path, properties):
@ -63,6 +63,33 @@ class Settings(Sqlite3DB):
self._storage.execute("DELETE FROM property WHERE path = ? AND session_id = ?", self._storage.execute("DELETE FROM property WHERE path = ? AND session_id = ?",
(path, self._session_id)) (path, self._session_id))
def get_modified_properties(self):
"""return all modified settings in a dictionary
example: {'path1': set(['prop1', 'prop2'])}
"""
ret = {}
for path, properties, _ in self._storage.select("SELECT * FROM property "
"WHERE session_id = ?",
(self._session_id,),
only_one=False):
path = self._sqlite_decode_path(path)
ret[path] = self._sqlite_decode(properties)
return ret
def set_modified_properties(self, properties):
self._storage.execute("DELETE FROM property", commit=False)
for path, property_ in properties.items():
self._storage.execute("INSERT INTO property(path, properties, session_id) "
"VALUES (?, ?, ?)", (path,
self._sqlite_encode(property_),
self._session_id,
), False)
self._storage._conn.commit()
class Permissives(Sqlite3DB):
__slots__ = tuple()
# permissive # permissive
def setpermissive(self, path, permissive): def setpermissive(self, path, permissive):
path = self._sqlite_encode_path(path) path = self._sqlite_encode_path(path)
@ -83,35 +110,12 @@ class Settings(Sqlite3DB):
else: else:
return frozenset(self._sqlite_decode(permissives[0])) return frozenset(self._sqlite_decode(permissives[0]))
def get_modified_properties(self):
"""return all modified settings in a dictionary
example: {'path1': set(['prop1', 'prop2'])}
"""
ret = {}
for path, properties, _ in self._storage.select("SELECT * FROM property "
"WHERE session_id = ?",
(self._session_id,),
only_one=False):
path = self._sqlite_decode_path(path)
ret[path] = self._sqlite_decode(properties)
return ret
def set_modified_properties(self, properties):
self._storage.execute("DELETE FROM property", commit=False)
for path, property_ in properties.items():
self._storage.execute("INSERT INTO property(path, property, session_id) "
"VALUES (?, ?, ?)", (path,
self._sqlite_encode(property_),
self._session_id,
), False)
self._storage._conn.commit()
def get_modified_permissives(self): def get_modified_permissives(self):
"""return all modified permissives in a dictionary """return all modified permissives in a dictionary
example: {'path1': set(['perm1', 'perm2'])} example: {'path1': set(['perm1', 'perm2'])}
""" """
ret = {} ret = {}
for path, permissives in self._storage.select("SELECT * FROM permissive " for path, permissives in self._storage.select("SELECT path, permissives FROM permissive "
"WHERE session_id = ?", "WHERE session_id = ?",
(self._session_id,), (self._session_id,),
only_one=False): only_one=False):
@ -122,7 +126,7 @@ class Settings(Sqlite3DB):
def set_modified_permissives(self, permissives): def set_modified_permissives(self, permissives):
self._storage.execute("DELETE FROM permissive", commit=False) self._storage.execute("DELETE FROM permissive", commit=False)
for path, permissive in permissives.items(): for path, permissive in permissives.items():
self._storage.execute("INSERT INTO permissive(path, permissive, session_id) " self._storage.execute("INSERT INTO permissive(path, permissives, session_id) "
"VALUES (?, ?, ?)", (path, "VALUES (?, ?, ?)", (path,
self._sqlite_encode(permissive), self._sqlite_encode(permissive),
self._session_id, self._session_id,

17
tiramisu/storage/sqlite3/value.py
View File

@ -231,10 +231,19 @@ class Values(Sqlite3DB):
index = export[1][idx] index = export[1][idx]
value = export[2][idx] value = export[2][idx]
owner = export[3][idx] owner = export[3][idx]
self._storage.execute("INSERT INTO value(path, value, owner, idx, session_id) VALUES " if index is None:
"(?, ?, ?, ?, ?)", (path, self._sqlite_encode(value), self._storage.execute("INSERT INTO value(path, value, owner, idx, session_id) VALUES "
str(owner), index, "(?, ?, ?, ?, ?)", (path, self._sqlite_encode(value),
self._session_id)) str(owner), index,
self._session_id), commit=False)
else:
for val in zip(index, value, owner):
self._storage.execute("INSERT INTO value(path, value, owner, idx, session_id)"
"VALUES (?, ?, ?, ?, ?)", (path,
self._sqlite_encode(val[1]),
str(val[2]), val[0],
self._session_id),
commit=False)
self._storage._conn.commit() self._storage._conn.commit()
def get_max_length(self, path, session): def get_max_length(self, path, session):

4
tiramisu/value.py
View File

@ -199,7 +199,7 @@ class Values(object):
self._setvalue(opt, path, value, force_owner=owners.forced) self._setvalue(opt, path, value, force_owner=owners.forced)
else: else:
self._p_.resetvalue(path, session) self._p_.resetvalue(path, session)
context.cfgimpl_reset_cache(opt=opt, path=path) context.cfgimpl_reset_cache(opt=opt, path=path, only=('values', 'properties'))
def _isempty(self, opt, value, force_allow_empty_list=False, index=None): def _isempty(self, opt, value, force_allow_empty_list=False, index=None):
"convenience method to know if an option is empty" "convenience method to know if an option is empty"
@ -430,7 +430,7 @@ class Values(object):
def _setvalue(self, opt, path, value, force_owner=undefined, index=None): def _setvalue(self, opt, path, value, force_owner=undefined, index=None):
context = self._getcontext() context = self._getcontext()
context.cfgimpl_reset_cache(opt=opt, path=path) context.cfgimpl_reset_cache(opt=opt, path=path, only=('values', 'properties'))
if force_owner is undefined: if force_owner is undefined:
owner = context.cfgimpl_get_settings().getowner() owner = context.cfgimpl_get_settings().getowner()
else: else: