diff --git a/test/auto/test_auto.py b/test/auto/test_auto.py
index 93d0362..1396ed4 100644
--- a/test/auto/test_auto.py
+++ b/test/auto/test_auto.py
@@ -9,9 +9,9 @@ from collections import OrderedDict
 from .autopath import do_autopath
 do_autopath()
 from tiramisu import Config, MetaConfig, \
-                     StrOption, SymLinkOption, OptionDescription, MasterSlaves, DynOptionDescription, \
+                     StrOption, SymLinkOption, OptionDescription, Leadership, DynOptionDescription, \
                      submulti, undefined, owners, Params, ParamOption
-from tiramisu.error import PropertiesOptionError, APIError, ConfigError, SlaveError
+from tiramisu.error import PropertiesOptionError, APIError, ConfigError, LeadershipError
 ICON = u'\u2937'
 
 OPTIONS_TYPE = {'str': {'type': str,
@@ -73,18 +73,18 @@ def autocheck(func):
 def _autocheck_default_value(cfg, path, conf, **kwargs):
     """set and get values
     """
-    # check if is a multi, a master or a slave
+    # check if is a multi, a leader or a follower
     multi = cfg.unrestraint.option(path).option.ismulti()
     submulti_ = cfg.unrestraint.option(path).option.issubmulti()
-    isslave = cfg.unrestraint.option(path).option.isslave()
+    isfollower = cfg.unrestraint.option(path).option.isfollower()
 
     # set default value (different if value is multi or not)
     empty_value = kwargs['default']
 
     # test default value (should be empty)
-    # cannot test for slave (we cannot get all values for a slave)
+    # cannot test for follower (we cannot get all values for a follower)
     with warnings.catch_warnings(record=True) as w:
-        if not isslave:
+        if not isfollower:
             if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
                 assert cfg.config(conf).option(path).value.get() == empty_value
                 assert cfg.config(conf).forcepermissive.option(path).value.get() == empty_value
@@ -113,26 +113,26 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
     set_permissive = kwargs.get('set_permissive', True)
     multi = cfg.unrestraint.option(pathwrite).option.ismulti()
     submulti_ = cfg.unrestraint.option(pathwrite).option.issubmulti()
-    ismaster = cfg.unrestraint.option(pathwrite).option.ismaster()
-    isslave = cfg.unrestraint.option(pathwrite).option.isslave()
+    isleader = cfg.unrestraint.option(pathwrite).option.isleader()
+    isfollower = cfg.unrestraint.option(pathwrite).option.isfollower()
     if not multi:
         first_value = FIRST_VALUE
     elif submulti_ is False:
-        if not isslave:
+        if not isfollower:
             first_value = LIST_FIRST_VALUE
         else:
             second_value = LIST_SECOND_VALUE[1]
 
     else:
-        if not isslave:
+        if not isfollower:
             first_value = SUBLIST_FIRST_VALUE
         else:
             second_value = SUBLIST_SECOND_VALUE[1]
 
-    # for slave should have an index and good length
-    # for master must append, not set
+    # for follower should have an index and good length
+    # for leader must append, not set
     with warnings.catch_warnings(record=True) as w:
-        if ismaster:
+        if isleader:
             if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
                 raises(APIError, "cfg.config(conf).option(pathwrite, 0).value.set(first_value[0])")
                 if not set_permissive:
@@ -148,7 +148,7 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
                 raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathwrite).value.set([first_value[0]])")
             if len(first_value) > 1:
                 raises(APIError, "cfg.config(conf).unrestraint.option(pathwrite).value.set(first_value[1])")
-        elif isslave:
+        elif isfollower:
             if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
                 if not set_permissive:
                     cfg.config(conf).option(pathwrite, 1).value.set(second_value)
@@ -179,10 +179,10 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
             #FIXME raises(APIError, "cfg.config(conf).unrestraint.option(pathwrite).value.set(first_value)")
 
 
-def _getproperties(multi, isslave, kwargs):
+def _getproperties(multi, isfollower, kwargs):
     # define properties
     properties = copy(PROPERTIES_LIST)
-    if multi and not isslave:
+    if multi and not isfollower:
         default_props = ['empty']
         properties.append('empty')
     else:
@@ -195,7 +195,7 @@ def _getproperties(multi, isslave, kwargs):
 
 
 def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props):
-    if not cfg.unrestraint.option(pathread).option.isslave():
+    if not cfg.unrestraint.option(pathread).option.isfollower():
         if not kwargs.get('permissive_od', False):
             assert set(cfg.config(conf).option(pathread).property.get()) == set(props_permissive)
             assert set(cfg.config(conf).option(pathread).property.get()) == set(props)
@@ -229,13 +229,13 @@ def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props
 
 
 def _property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    # check if is a multi or a slave
+    # check if is a multi or a follower
     multi = cfg.unrestraint.option(pathread).option.ismulti()
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
 
     # define properties
     properties = copy(PROPERTIES_LIST)
-    if multi and not isslave:
+    if multi and not isfollower:
         default_props = ['empty']
         properties.append('empty')
     else:
@@ -244,7 +244,7 @@ def _property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **
     if extra_properties:
         properties.extend(extra_properties)
         default_props.extend(extra_properties)
-    default_props, properties = _getproperties(multi, isslave, kwargs)
+    default_props, properties = _getproperties(multi, isfollower, kwargs)
 
     if confwrite == confread:
         _check_properties(cfg, mcfg, pathread, confwrite, kwargs, default_props, default_props)
@@ -269,25 +269,25 @@ def _autocheck_get_value(cfg, pathread, conf, **kwargs):
     set_permissive = kwargs.get('set_permissive', True)
     multi = cfg.unrestraint.option(pathread).option.ismulti()
     submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
     empty_value = kwargs['default']
     if not multi:
         first_value = FIRST_VALUE
     elif submulti_ is False:
-        if not isslave:
+        if not isfollower:
             first_value = LIST_FIRST_VALUE
         else:
             second_value = LIST_SECOND_VALUE[1]
 
     else:
-        if not isslave:
+        if not isfollower:
             first_value = SUBLIST_FIRST_VALUE
         else:
             second_value = SUBLIST_SECOND_VALUE[1]
 
     # get value after set value without permissive
     with warnings.catch_warnings(record=True) as w:
-        if isslave:
+        if isfollower:
             if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
                 assert cfg.config(conf).option(pathread, 0).value.get() == empty_value
                 assert cfg.config(conf).option(pathread, 1).value.get() == second_value
@@ -319,8 +319,8 @@ def _autocheck_get_value(cfg, pathread, conf, **kwargs):
 
 
 def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
-    if not isslave:
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
+    if not isfollower:
         if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
             assert cfg.config(conf).option(pathread).owner.get() == owner
             assert cfg.config(conf).forcepermissive.option(pathread).owner.get() == owner
@@ -351,18 +351,18 @@ def autocheck_option_multi(cfg, mcfg, pathread, pathwrite, confread, confwrite,
     if not kwargs.get('permissive_od', False):
         cfg.option(pathread).option.ismulti()
         cfg.option(pathread).option.issubmulti()
-        cfg.option(pathread).option.ismaster()
-        cfg.option(pathread).option.isslave()
+        cfg.option(pathread).option.isleader()
+        cfg.option(pathread).option.isfollower()
     else:
         raises(PropertiesOptionError, "cfg.option(pathread).option.ismulti()")
         raises(PropertiesOptionError, "cfg.option(pathread).option.issubmulti()")
-        raises(PropertiesOptionError, "cfg.option(pathread).option.ismaster()")
-        raises(PropertiesOptionError, "cfg.option(pathread).option.isslave()")
+        raises(PropertiesOptionError, "cfg.option(pathread).option.isleader()")
+        raises(PropertiesOptionError, "cfg.option(pathread).option.isfollower()")
     
     cfg.forcepermissive.option(pathread).option.ismulti()
     cfg.forcepermissive.option(pathread).option.issubmulti()
-    cfg.forcepermissive.option(pathread).option.ismaster()
-    cfg.forcepermissive.option(pathread).option.isslave()
+    cfg.forcepermissive.option(pathread).option.isleader()
+    cfg.forcepermissive.option(pathread).option.isfollower()
 
 
 
@@ -370,10 +370,10 @@ def autocheck_option_multi(cfg, mcfg, pathread, pathwrite, confread, confwrite,
 def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
     """check different value of owner when any value is set to this option
     """
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
     # check if owner is a string "default" and 'isdefault'
     def do(conf):
-        if not isslave:
+        if not isfollower:
             if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
                 assert cfg.config(conf).option(pathread).owner.get() == 'default'
                 assert cfg.config(conf).forcepermissive.option(pathread).owner.get() == 'default'
@@ -438,7 +438,7 @@ def autocheck_set_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
 def autocheck_get_value_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
     multi = cfg.unrestraint.option(pathread).option.ismulti()
     submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
     _set_value(cfg, pathwrite, confwrite, **kwargs)
     empty_value = kwargs['default']
     if not multi:
@@ -450,7 +450,7 @@ def autocheck_get_value_permissive(cfg, mcfg, pathread, pathwrite, confread, con
 
     def do(conf):
         # get value after set value without permissive
-        if isslave:
+        if isfollower:
             if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
                 assert cfg.config(conf).option(pathread, 0).value.get() == empty_value
                 assert cfg.config(conf).forcepermissive.option(pathread, 0).value.get() == empty_value
@@ -504,9 +504,9 @@ def autocheck_get_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
 
 
 @autocheck
-def autocheck_value_slave(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
-    if not isslave:
+def autocheck_value_follower(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
+    if not isfollower:
         return
     if kwargs.get('propertyerror', False):
         return
@@ -529,28 +529,28 @@ def autocheck_value_slave(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
             value.append(cfg.forcepermissive.option(pathread, idx).value.get())
 
     assert value == [empty_value, empty_value]
-    # cannot access to a slave with index too high
+    # cannot access to a follower with index too high
     if submulti_ is False:
         value = LIST_FIRST_VALUE[0]
     else:
         value = SUBLIST_FIRST_VALUE[0]
 
-    raises(SlaveError, "cfg.forcepermissive.option(pathread, length).value.get()")
-    raises(SlaveError, "cfg.forcepermissive.option(pathread, length).value.set(value)")
-    raises(SlaveError, "cfg.forcepermissive.option(pathread, length).value.reset()")
-    raises(SlaveError, "cfg.forcepermissive.option(pathread, length).owner.get()")
-    raises(SlaveError, "cfg.forcepermissive.option(pathread, length).owner.isdefault()")
-    raises(SlaveError, "cfg.forcepermissive.option(pathread, length).property.get()")
-    raises(SlaveError, "cfg.forcepermissive.option(pathread, length).owner.set('new_user')")
-    raises(SlaveError, "cfg.forcepermissive.option(pathread, length).property.add('prop')")
+    raises(LeadershipError, "cfg.forcepermissive.option(pathread, length).value.get()")
+    raises(LeadershipError, "cfg.forcepermissive.option(pathread, length).value.set(value)")
+    raises(LeadershipError, "cfg.forcepermissive.option(pathread, length).value.reset()")
+    raises(LeadershipError, "cfg.forcepermissive.option(pathread, length).owner.get()")
+    raises(LeadershipError, "cfg.forcepermissive.option(pathread, length).owner.isdefault()")
+    raises(LeadershipError, "cfg.forcepermissive.option(pathread, length).property.get()")
+    raises(LeadershipError, "cfg.forcepermissive.option(pathread, length).owner.set('new_user')")
+    raises(LeadershipError, "cfg.forcepermissive.option(pathread, length).property.add('prop')")
 
 
 @autocheck
 def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    # check if is a multi, a master or a slave
+    # check if is a multi, a leader or a follower
     multi = cfg.unrestraint.option(pathread).option.ismulti()
     submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
 
     # set default value (different if value is multi or not)
     if not multi:
@@ -567,7 +567,7 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
 
     # reset value without permissive
     with warnings.catch_warnings(record=True) as w:
-        if not isslave:
+        if not isfollower:
             if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
                 cfg.config(confwrite).option(pathwrite).value.reset()
             #else:
@@ -580,7 +580,7 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
 
     # get value after reset value without permissive
     def do(conf):
-        if isslave:
+        if isfollower:
             if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
                 assert cfg.config(conf).option(pathread, 0).value.get() == empty_value
                 assert cfg.config(conf).option(pathread, 1).value.get() == second_value[1]
@@ -602,111 +602,111 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
 
 @autocheck
 def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    ismaster = cfg.unrestraint.option(pathread).option.ismaster()
+    isleader = cfg.unrestraint.option(pathread).option.isleader()
     submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
-    if not ismaster:
+    if not isleader:
         return
 
     with warnings.catch_warnings(record=True) as w:
         if not kwargs.get('propertyerror', False):
-            master_value = cfg.config(confread).forcepermissive.option(pathread).value.get()
-            len_value = len(master_value)
-            master_value.append(undefined)
+            leader_value = cfg.config(confread).forcepermissive.option(pathread).value.get()
+            len_value = len(leader_value)
+            leader_value.append(undefined)
             assert len(cfg.config(confread).forcepermissive.option(pathread).value.get()) == len_value
             with warnings.catch_warnings(record=True) as w:
-                cfg.forcepermissive.config(confwrite).option(pathread).value.set(master_value)
-                new_master_value = cfg.config(confread).forcepermissive.option(pathread).value.get()
-                len_new = len(new_master_value)
+                cfg.forcepermissive.config(confwrite).option(pathread).value.set(leader_value)
+                new_leader_value = cfg.config(confread).forcepermissive.option(pathread).value.get()
+                len_new = len(new_leader_value)
                 assert len_value + 1 == len_new
-                assert new_master_value[-1] == kwargs['default_multi']
-                slave_path = pathread.rsplit('.', 1)[0]
-                if slave_path.endswith('val1') or slave_path.endswith('val2'):
-                    slave_path += '.third' + slave_path[-4:]
+                assert new_leader_value[-1] == kwargs['default_multi']
+                follower_path = pathread.rsplit('.', 1)[0]
+                if follower_path.endswith('val1') or follower_path.endswith('val2'):
+                    follower_path += '.third' + follower_path[-4:]
                 else:
-                    slave_path += '.third'
+                    follower_path += '.third'
                 for idx in range(len_new):
-                    assert cfg.config(confread).forcepermissive.option(slave_path, idx).value.get() == kwargs['default_multi']
+                    assert cfg.config(confread).forcepermissive.option(follower_path, idx).value.get() == kwargs['default_multi']
                 #
                 if not submulti_:
                     value = 'value'
                 else:
                     value = ['value']
-                master_value.append(value)
-                assert len(cfg.config(confread).forcepermissive.option(pathread).value.get()) == len(new_master_value)
-                cfg.forcepermissive.config(confwrite).option(pathread).value.set(master_value)
+                leader_value.append(value)
+                assert len(cfg.config(confread).forcepermissive.option(pathread).value.get()) == len(new_leader_value)
+                cfg.forcepermissive.config(confwrite).option(pathread).value.set(leader_value)
                 assert cfg.config(confread).forcepermissive.option(pathread).value.get()[-1] == value
 
 
 @autocheck
 def autocheck_pop_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    ismaster = cfg.unrestraint.option(pathread).option.ismaster()
+    isleader = cfg.unrestraint.option(pathread).option.isleader()
     submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
-    if not ismaster:
+    if not isleader:
         return
 
     if not kwargs.get('propertyerror', False):
         if not submulti_:
             values = ['value1', 'value2', 'value3', 'value4']
-            slave_value = 'slave'
+            follower_value = 'follower'
         else:
             values = [['value1'], ['value2'], ['value3'], ['value4']]
-            slave_value = ['slave']
-        slaves = [kwargs['default_multi'], slave_value, kwargs['default_multi'], kwargs['default_multi']]
-        a_slave = pathwrite.rsplit('.', 1)[0]
-        if a_slave.endswith('val1') or a_slave.endswith('val2'):
-            a_slave += '.third' + a_slave[-4:]
+            follower_value = ['follower']
+        followers = [kwargs['default_multi'], follower_value, kwargs['default_multi'], kwargs['default_multi']]
+        a_follower = pathwrite.rsplit('.', 1)[0]
+        if a_follower.endswith('val1') or a_follower.endswith('val2'):
+            a_follower += '.third' + a_follower[-4:]
         else:
-            a_slave += '.third'
+            a_follower += '.third'
         with warnings.catch_warnings(record=True) as w:
             cfg.forcepermissive.config(confwrite).option(pathread).value.set(values)
-            cfg.forcepermissive.config(confwrite).option(a_slave, 1).value.set(slave_value)
-            cfg.config(confread).forcepermissive.option(a_slave, 0).value.get() == kwargs['default_multi']
-            assert cfg.config(confread).forcepermissive.option(a_slave, 0).owner.isdefault() is True
-            cfg.config(confread).forcepermissive.option(a_slave, 1).value.get() == slave_value
-            assert cfg.config(confread).forcepermissive.option(a_slave, 1).owner.isdefault() is False
-            cfg.config(confread).forcepermissive.option(a_slave, 2).value.get() == kwargs['default_multi']
-            assert cfg.config(confread).forcepermissive.option(a_slave, 2).owner.isdefault() is True
-            cfg.config(confread).forcepermissive.option(a_slave, 3).value.get() == kwargs['default_multi']
-            assert cfg.config(confread).forcepermissive.option(a_slave, 3).owner.isdefault() is True
+            cfg.forcepermissive.config(confwrite).option(a_follower, 1).value.set(follower_value)
+            cfg.config(confread).forcepermissive.option(a_follower, 0).value.get() == kwargs['default_multi']
+            assert cfg.config(confread).forcepermissive.option(a_follower, 0).owner.isdefault() is True
+            cfg.config(confread).forcepermissive.option(a_follower, 1).value.get() == follower_value
+            assert cfg.config(confread).forcepermissive.option(a_follower, 1).owner.isdefault() is False
+            cfg.config(confread).forcepermissive.option(a_follower, 2).value.get() == kwargs['default_multi']
+            assert cfg.config(confread).forcepermissive.option(a_follower, 2).owner.isdefault() is True
+            cfg.config(confread).forcepermissive.option(a_follower, 3).value.get() == kwargs['default_multi']
+            assert cfg.config(confread).forcepermissive.option(a_follower, 3).owner.isdefault() is True
             #
             cfg.forcepermissive.config(confwrite).option(pathread).value.pop(3)
-            cfg.config(confread).forcepermissive.option(a_slave, 0).value.get() == kwargs['default_multi']
-            assert cfg.config(confread).forcepermissive.option(a_slave, 0).owner.isdefault() is True
-            cfg.config(confread).forcepermissive.option(a_slave, 1).value.get() == slave_value
-            assert cfg.config(confread).forcepermissive.option(a_slave, 1).owner.isdefault() is False
-            cfg.config(confread).forcepermissive.option(a_slave, 2).value.get() == kwargs['default_multi']
-            assert cfg.config(confread).forcepermissive.option(a_slave, 2).owner.isdefault() is True
+            cfg.config(confread).forcepermissive.option(a_follower, 0).value.get() == kwargs['default_multi']
+            assert cfg.config(confread).forcepermissive.option(a_follower, 0).owner.isdefault() is True
+            cfg.config(confread).forcepermissive.option(a_follower, 1).value.get() == follower_value
+            assert cfg.config(confread).forcepermissive.option(a_follower, 1).owner.isdefault() is False
+            cfg.config(confread).forcepermissive.option(a_follower, 2).value.get() == kwargs['default_multi']
+            assert cfg.config(confread).forcepermissive.option(a_follower, 2).owner.isdefault() is True
             #
             cfg.forcepermissive.config(confwrite).option(pathread).value.pop(0)
-            cfg.config(confread).forcepermissive.option(a_slave, 0).value.get() == slave_value
-            assert cfg.config(confread).forcepermissive.option(a_slave, 0).owner.isdefault() is False
-            cfg.config(confread).forcepermissive.option(a_slave, 1).value.get() == kwargs['default_multi']
-            assert cfg.config(confread).forcepermissive.option(a_slave, 1).owner.isdefault() is True
+            cfg.config(confread).forcepermissive.option(a_follower, 0).value.get() == follower_value
+            assert cfg.config(confread).forcepermissive.option(a_follower, 0).owner.isdefault() is False
+            cfg.config(confread).forcepermissive.option(a_follower, 1).value.get() == kwargs['default_multi']
+            assert cfg.config(confread).forcepermissive.option(a_follower, 1).owner.isdefault() is True
             #
             cfg.forcepermissive.config(confwrite).option(pathread).value.pop(0)
-            cfg.config(confread).forcepermissive.option(a_slave, 0).value.get() == kwargs['default_multi']
-            assert cfg.config(confread).forcepermissive.option(a_slave, 0).owner.isdefault() is True
+            cfg.config(confread).forcepermissive.option(a_follower, 0).value.get() == kwargs['default_multi']
+            assert cfg.config(confread).forcepermissive.option(a_follower, 0).owner.isdefault() is True
 
 
 @autocheck
 def autocheck_reset_value_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    # check if is a multi, a master or a slave
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    # check if is a multi, a leader or a follower
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
     _set_value(cfg, pathwrite, confwrite, **kwargs)
     # reset value with permissive
     with warnings.catch_warnings(record=True) as w:
         if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
-            if not isslave:
+            if not isfollower:
                 cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()
             else:
                 cfg.forcepermissive.option(pathwrite, 1).value.reset()
         elif kwargs.get('permissive', False):
-            if not isslave:
+            if not isfollower:
                 cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()
             else:
                 cfg.forcepermissive.option(pathwrite, 1).value.reset()
         #FIXME else:
-        #    if not isslave:
+        #    if not isfollower:
         #        raises(PropertiesOptionError, "cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()")
         #    else:
         #        raises(PropertiesOptionError, "cfg.forcepermissive.option(pathwrite, 1).value.reset()")
@@ -736,11 +736,11 @@ def autocheck_display(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwa
 def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
     """get property from path
     """
-    # check if is a multi or a slave
+    # check if is a multi or a follower
     multi = cfg.unrestraint.option(pathread).option.ismulti()
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
 
-    default_props, properties = _getproperties(multi, isslave, kwargs)
+    default_props, properties = _getproperties(multi, isfollower, kwargs)
 
     if confread == confwrite:
         _check_properties(cfg, mcfg, pathread, confread, kwargs, default_props, default_props)
@@ -766,10 +766,10 @@ def autocheck_property_permissive(cfg, mcfg, pathread, pathwrite, confread, conf
 def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
     """check properties after set with permissive
     """
-    # check if is a multi or a slave
+    # check if is a multi or a follower
     multi = cfg.unrestraint.option(pathread).option.ismulti()
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
-    default_props, properties = _getproperties(multi, isslave, kwargs)
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
+    default_props, properties = _getproperties(multi, isfollower, kwargs)
 
     _property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs)
 
@@ -784,10 +784,10 @@ def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite
 
 @autocheck
 def autocheck_reset_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    # check if is a multi or a slave
+    # check if is a multi or a follower
     multi = cfg.unrestraint.option(pathread).option.ismulti()
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
-    default_props, properties = _getproperties(multi, isslave, kwargs)
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
+    default_props, properties = _getproperties(multi, isfollower, kwargs)
 
     _property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs)
 
@@ -816,11 +816,11 @@ def autocheck_owner_with_value(cfg, mcfg, pathread, pathwrite, confread, confwri
 
 @autocheck
 def autocheck_default_owner_with_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
     _set_value(cfg, pathwrite, confwrite, **kwargs)
 
     # test if is default owner without permissive
-    if not isslave:
+    if not isfollower:
         if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
             assert cfg.config(confwrite).option(pathread).owner.isdefault() is False
             if confwrite != confread:
@@ -842,15 +842,15 @@ def autocheck_default_owner_with_value(cfg, mcfg, pathread, pathwrite, confread,
 
 @autocheck
 def autocheck_default_owner_with_value_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    # check if is a isslave
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    # check if is a isfollower
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
 
     _set_value(cfg, pathwrite, confwrite, **kwargs)
 
     def do(conf):
         # test if is default owner with permissive
         if not kwargs.get('propertyerror', False):
-            if not isslave:
+            if not isfollower:
                 assert cfg.config(conf).forcepermissive.option(pathread).owner.isdefault() is False
             else:
                 assert cfg.config(conf).forcepermissive.option(pathread, 0).owner.isdefault() is True
@@ -864,9 +864,9 @@ def autocheck_default_owner_with_value_permissive(cfg, mcfg, pathread, pathwrite
 
 @autocheck
 def autocheck_set_owner_no_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
     if not kwargs.get('propertyerror', False):
-        if not isslave:
+        if not isfollower:
             raises(ConfigError, "cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user')")
         else:
             raises(ConfigError, "cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user')")
@@ -875,12 +875,12 @@ def autocheck_set_owner_no_value(cfg, mcfg, pathread, pathwrite, confread, confw
 @autocheck
 def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
     # test set owner without permissive
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
 
     _set_value(cfg, pathwrite, confwrite, **kwargs)
 
     # set owner without permissive
-    if not isslave:
+    if not isfollower:
         if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
             cfg.config(confwrite).option(pathwrite).owner.set('new_user')
             raises(ValueError, "cfg.config(confwrite).option(pathwrite).owner.set('default')")
@@ -900,18 +900,18 @@ def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
 
 @autocheck
 def autocheck_set_owner_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
-    isslave = cfg.unrestraint.option(pathread).option.isslave()
+    isfollower = cfg.unrestraint.option(pathread).option.isfollower()
 
     _set_value(cfg, pathwrite, confwrite, **kwargs)
 
     # set owner with permissive
     if not kwargs.get('propertyerror', False):
-        if not isslave:
+        if not isfollower:
             cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')
         else:
             cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')
     #FIXME else:
-    #    if not isslave:
+    #    if not isfollower:
     #        raises(PropertiesOptionError,
     #               "cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')")
     #    else:
@@ -1096,7 +1096,7 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
         kwargs['default'] = default_value
 
         is_dyn = False
-        is_master = False
+        is_leader = False
         dyns = []
         has_value = False
         for cpath, options in paths_.items():
@@ -1107,8 +1107,8 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
                 for dname in cpath.split('.')[:-1]:
                     if options.get(dname, {}).get('dyn'):
                         is_dyn = True
-                    if options.get(dname, {}).get('master'):
-                        is_master = True
+                    if options.get(dname, {}).get('leader'):
+                        is_leader = True
             else:
                 dirname = ''
                 name = cpath
@@ -1132,9 +1132,9 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
                         dico_value[cpath + 'link'] = default_value
 
             has_value = True
-        isslave = False
-        if '.' in path and is_master and not path.rsplit('.', 1)[1].startswith('first'):
-            isslave = True
+        isfollower = False
+        if '.' in path and is_leader and not path.rsplit('.', 1)[1].startswith('first'):
+            isfollower = True
             if not multi is submulti:
                 kwargs['default'] = None
         if is_dyn and dyns:
@@ -1181,7 +1181,7 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
             if is_dyn:
                 dico[cpath + 'extraoptconsistencyval1'] = value
                 dico_value[cpath + 'extraoptconsistencyval1'] = value
-                if is_master:
+                if is_leader:
                     spath = cpath.split('.')
                     spath[-2] = spath[-2][:-1] + '2'
                     spath[-3] = spath[-3][:-1] + '2'
@@ -1193,7 +1193,7 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
             else:
                 dico[cpath + 'extraoptconsistency'] = value
                 dico_value[cpath + 'extraoptconsistency'] = value
-        if is_master:
+        if is_leader:
             for cpath in list(paths_.keys())[len(dyns):]:
                 if cpath.endswith('.first') or cpath.endswith('.firstval1') or cpath.endswith('.firstval2'):
                     second_path = cpath.rsplit('.', 1)[0] + '.second'
@@ -1216,31 +1216,31 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
                         dvalue = None
                     #
                     kwargs['default_multi'] = dvalue
-                    if isslave:
+                    if isfollower:
                         kwargs['default'] = dvalue
-                    len_master = len(dico[cpath])
+                    len_leader = len(dico[cpath])
                     if second_path in dico:
-                        dico[second_path] = [dvalue] * len_master
+                        dico[second_path] = [dvalue] * len_leader
                         if symlink:
-                            dico[second_path + 'link'] = [dvalue] * len_master
+                            dico[second_path + 'link'] = [dvalue] * len_leader
                     if third_path in dico:
-                        dico[third_path] = [dvalue] * len_master
+                        dico[third_path] = [dvalue] * len_leader
                         if symlink:
-                            dico[third_path + 'link'] = [dvalue] * len_master
+                            dico[third_path + 'link'] = [dvalue] * len_leader
                     if cons_path in dico:
-                        dico[cons_path] = [dvalue] * len_master
+                        dico[cons_path] = [dvalue] * len_leader
                     #
-                    len_master = len(dico_value[cpath])
+                    len_leader = len(dico_value[cpath])
                     if second_path in dico_value:
-                        dico_value[second_path] = [dvalue] * len_master
+                        dico_value[second_path] = [dvalue] * len_leader
                         if symlink:
-                            dico_value[second_path + 'link'] = [dvalue] * len_master
+                            dico_value[second_path + 'link'] = [dvalue] * len_leader
                     if third_path in dico_value:
-                        dico_value[third_path] = [dvalue] * len_master
+                        dico_value[third_path] = [dvalue] * len_leader
                         if symlink:
-                            dico_value[third_path + 'link'] = [dvalue] * len_master
+                            dico_value[third_path + 'link'] = [dvalue] * len_leader
                     if cons_path in dico_value:
-                        dico_value[cons_path] = [dvalue] * len_master
+                        dico_value[cons_path] = [dvalue] * len_leader
         return is_dyn, dico, dico_value
     if DISPLAY:
         text = u' {} launch tests for {}'.format(ICON, path)
@@ -1288,33 +1288,33 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
             else:
                 ckwargs['owner'] = OWNER
                 
-            if mcfg.unrestraint.option(path).option.isslave():
+            if mcfg.unrestraint.option(path).option.isfollower():
                 dirname = path.rsplit('.', 1)[0]
-                master_path = dirname + '.first'
-                master_path_2 = None
+                leader_path = dirname + '.first'
+                leader_path_2 = None
                 if dirname.endswith('val1') or dirname.endswith('val2'):
-                    master_path += 'val1'
-                    master_path = master_path.replace('val2', 'val1')
-                    master_path_2 = master_path.replace('val1', 'val2')
+                    leader_path += 'val1'
+                    leader_path = leader_path.replace('val2', 'val1')
+                    leader_path_2 = leader_path.replace('val1', 'val2')
                 if multi is submulti:
                     value = SUBLIST_SECOND_VALUE
                 else:
                     value = LIST_SECOND_VALUE
                 with warnings.catch_warnings(record=True) as w:
-                    mcfg.option(master_path).value.set(value)
-                ckwargs['make_dict'][master_path] = value
-                ckwargs['make_dict_value'][master_path] = value
+                    mcfg.option(leader_path).value.set(value)
+                ckwargs['make_dict'][leader_path] = value
+                ckwargs['make_dict_value'][leader_path] = value
                 if symlink:
-                    ckwargs['make_dict'][master_path + 'link'] = value
-                    ckwargs['make_dict_value'][master_path + 'link'] = value
-                if master_path_2:
+                    ckwargs['make_dict'][leader_path + 'link'] = value
+                    ckwargs['make_dict_value'][leader_path + 'link'] = value
+                if leader_path_2:
                     with warnings.catch_warnings(record=True) as w:
-                        mcfg.option(master_path_2).value.set(value)
-                    ckwargs['make_dict'][master_path_2] = value
-                    ckwargs['make_dict_value'][master_path_2] = value
+                        mcfg.option(leader_path_2).value.set(value)
+                    ckwargs['make_dict'][leader_path_2] = value
+                    ckwargs['make_dict_value'][leader_path_2] = value
                     if symlink:
-                        ckwargs['make_dict'][master_path_2 + 'link'] = value
-                        ckwargs['make_dict_value'][master_path_2 + 'link'] = value
+                        ckwargs['make_dict'][leader_path_2 + 'link'] = value
+                        ckwargs['make_dict_value'][leader_path_2 + 'link'] = value
                 if default_multi:
                     if multi is not submulti:
                         dvalue = SECOND_VALUE
@@ -1337,9 +1337,9 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
                             ckwargs['make_dict'][npath + 'link'] = [dvalue] * len(value)
                             ckwargs['make_dict_value'][npath + 'link'] = [dvalue] * len(value)
                         if path == npath:
-                            ckwargs['make_dict_value'][npath][-1] = ckwargs['make_dict_value'][master_path][-1]
+                            ckwargs['make_dict_value'][npath][-1] = ckwargs['make_dict_value'][leader_path][-1]
                             if symlink:
-                                ckwargs['make_dict_value'][npath + 'link'][-1] = ckwargs['make_dict_value'][master_path][-1]
+                                ckwargs['make_dict_value'][npath + 'link'][-1] = ckwargs['make_dict_value'][leader_path][-1]
                     npath = ldirname + '.third' + suffix
                     if npath in ckwargs['make_dict']:
                         ckwargs['make_dict'][npath] = [dvalue] * len(value)
@@ -1348,9 +1348,9 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
                             ckwargs['make_dict'][npath + 'link'] = [dvalue] * len(value)
                             ckwargs['make_dict_value'][npath + 'link'] = [dvalue] * len(value)
                         if path == npath:
-                            ckwargs['make_dict_value'][npath][-1] = ckwargs['make_dict_value'][master_path][-1]
+                            ckwargs['make_dict_value'][npath][-1] = ckwargs['make_dict_value'][leader_path][-1]
                             if symlink:
-                                ckwargs['make_dict_value'][npath + 'link'][-1] = ckwargs['make_dict_value'][master_path][-1]
+                                ckwargs['make_dict_value'][npath + 'link'][-1] = ckwargs['make_dict_value'][leader_path][-1]
                     npath = ldirname + '.extraoptconsistency' + suffix
                     if npath in ckwargs['make_dict']:
                         ckwargs['make_dict'][npath] = [dvalue] * len(value)
@@ -1416,12 +1416,12 @@ def make_conf(options, multi, default, default_multi, require, consistency, call
     weakrefs = []
     dyn = []
     goptions = []
-    def make_option(path, option_infos, in_master, master):
+    def make_option(path, option_infos, in_leader, leader):
         option_type = 'str'
         option_properties = []
         option_requires = []
-        isslave = False
-        if in_master and symlink:
+        isfollower = False
+        if in_leader and symlink:
             return None, None, None
         if option_infos is not None:
             if require:
@@ -1433,7 +1433,7 @@ def make_conf(options, multi, default, default_multi, require, consistency, call
                     else:
                         option_requires.append({'option': goptions[0], 'expected': None,
                                                 'action': prop})
-            isslave = option_infos.get('slave', False)
+            isfollower = option_infos.get('follower', False)
         args = [path, "{}'s option".format(path)]
         kwargs = {}
         call_kwargs = {}
@@ -1450,7 +1450,7 @@ def make_conf(options, multi, default, default_multi, require, consistency, call
             kwargs['multi'] = multi
             if callback:
                 call_kwargs['multi'] = multi
-        if ((not in_master or master) and default) and path is not 'extraoptrequire' and not path.endswith('extraoptconsistency'):
+        if ((not in_leader or leader) and default) and path is not 'extraoptrequire' and not path.endswith('extraoptconsistency'):
             if multi is False:
                 value = FIRST_VALUE
             elif multi is True:
@@ -1506,10 +1506,10 @@ def make_conf(options, multi, default, default_multi, require, consistency, call
         for prop in PROPERTIES:
             if infos.get(prop, False) is True:
                 properties.append(prop)
-        if infos.get('master', False) is True:
+        if infos.get('leader', False) is True:
             if not multi:
                 return
-            optiondescription = MasterSlaves
+            optiondescription = Leadership
         if infos.get('dyn', False) is True:
             if symlink:
                 return
@@ -1557,7 +1557,7 @@ def make_conf(options, multi, default, default_multi, require, consistency, call
             local_collect_options = local_collect_options[optiondescription]
             local_collect_options['properties'].update(option.get(optiondescription, {}))
         option_name = path.split('.')[-1]
-        in_master = False
+        in_leader = False
         if '.' in path:
             name_od = path.rsplit('.', 1)[0]
             if '.' in name_od:
@@ -1565,9 +1565,9 @@ def make_conf(options, multi, default, default_multi, require, consistency, call
                 oddescr = collect_options.get(subod, {})
             else:
                 oddescr = collect_options
-            in_master = oddescr.get(name_od, {}).get('properties', {}).get('master')
-        master = in_master and path.endswith('first')
-        obj, objcall, sobj = make_option(option_name, option.get(option_name), in_master, master)
+            in_leader = oddescr.get(name_od, {}).get('properties', {}).get('leader')
+        leader = in_leader and path.endswith('first')
+        obj, objcall, sobj = make_option(option_name, option.get(option_name), in_leader, leader)
         if obj is None:
             return None, None, None
         weakrefs.append(weakref.ref(obj))
@@ -1576,7 +1576,7 @@ def make_conf(options, multi, default, default_multi, require, consistency, call
         if sobj is not None:
             weakrefs.append(weakref.ref(sobj))
         if '.' in path:
-            if master:
+            if leader:
                 local_collect_options.setdefault('options', []).insert(0, obj)
             else:
                 local_collect_options.setdefault('options', []).append(obj)
@@ -1609,10 +1609,10 @@ DICT_PATHS = [
     OrderedDict([('subod.subsubod.first', {}),
                  ('subod.subsubod.second', {'second': {'disabled': True}}),
                  ('subod.subsubod.third', {'third': {'hidden': True}})]),
-    # test a config with masterslaves
-    OrderedDict([('odmaster.first', {'odmaster': {'master': True}}),
-                 ('odmaster.second', {'odmaster': {'master': True}, 'second': {'disabled': True, 'slave': True}}),
-                 ('odmaster.third', {'odmaster': {'master': True}, 'third': {'hidden': True, 'slave': True}})]),
+    # test a config with leadership
+    OrderedDict([('odleader.first', {'odleader': {'leader': True}}),
+                 ('odleader.second', {'odleader': {'leader': True}, 'second': {'disabled': True, 'follower': True}}),
+                 ('odleader.third', {'odleader': {'leader': True}, 'third': {'hidden': True, 'follower': True}})]),
     # test a config with dynoption
     OrderedDict([('subod.first', {'subod': {'dyn': True}}),
                  ('subod.second', {'second': {'disabled': True}}),
@@ -1647,10 +1647,10 @@ DICT_PATHS = [
                  ('subod.subsubodval2.firstval2', None),
                  ('subod.subsubodval2.secondval2', None),
                  ('subod.subsubodval2.thirdval2', None)]),
-    # test a config with dyn subsubod with masterslave
-    OrderedDict([('subod.subsubod.first', {'subod': {'dyn': True}, 'subsubod': {'master': True}}),
-                 ('subod.subsubod.second', {'subod': {'dyn': True}, 'subsubod' : {'master': True}, 'second': {'disabled': True, 'slave': True}}),
-                 ('subod.subsubod.third', {'subod': {'dyn': True}, 'subsubod': {'master': True}, 'third': {'hidden': True, 'slave': True}}),
+    # test a config with dyn subsubod with leadership
+    OrderedDict([('subod.subsubod.first', {'subod': {'dyn': True}, 'subsubod': {'leader': True}}),
+                 ('subod.subsubod.second', {'subod': {'dyn': True}, 'subsubod' : {'leader': True}, 'second': {'disabled': True, 'follower': True}}),
+                 ('subod.subsubod.third', {'subod': {'dyn': True}, 'subsubod': {'leader': True}, 'third': {'hidden': True, 'follower': True}}),
                  ('subodval1.subsubodval1.firstval1', None),
                  ('subodval1.subsubodval1.secondval1', None),
                  ('subodval1.subsubodval1.thirdval1', None),
diff --git a/test/test_cache.py b/test/test_cache.py
index 32704e8..71d5f3b 100644
--- a/test/test_cache.py
+++ b/test/test_cache.py
@@ -8,7 +8,7 @@ do_autopath()
 from tiramisu import setting, value
 setting.expires_time = 1
 value.expires_time = 1
-from tiramisu.option import BoolOption, IPOption, IntOption, StrOption, OptionDescription, MasterSlaves
+from tiramisu.option import BoolOption, IPOption, IntOption, StrOption, OptionDescription, Leadership
 from tiramisu import Config
 from tiramisu.error import ConfigError, PropertiesOptionError
 from tiramisu.setting import groups
@@ -256,11 +256,10 @@ def test_cache_not_cache():
     assert 'u1' not in settings._p_.get_cached()
 
 
-def test_cache_master_slave():
+def test_cache_leadership():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     cfg = Config(maconfig)
     cfg.property.read_write()
@@ -419,11 +418,10 @@ def test_cache_callback():
                                                         'val5': {None: (['yes', 'new4'], None)}})
 
 
-def test_cache_master_and_slaves_master():
+def test_cache_leader_and_followers():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     cfg = Config(maconfig)
     cfg.property.read_write()
@@ -495,11 +493,10 @@ def test_cache_master_and_slaves_master():
     #                                                         'val1.val2': {0: (None, None), 1: ('oui', None)}}
 
 
-def test_cache_master_callback():
+def test_cache_leader_callback():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params=Params(kwargs={'value': ParamOption(val1)}))
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     cfg = Config(maconfig)
     cfg.property.read_write()
diff --git a/test/test_duplicate_config.py b/test/test_duplicate_config.py
index 82c7bf8..6a4e652 100644
--- a/test/test_duplicate_config.py
+++ b/test/test_duplicate_config.py
@@ -35,8 +35,8 @@ def make_description():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé")
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau")
 
-    master = OptionDescription('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    interface1 = OptionDescription('interface1', '', [master])
+    leader = OptionDescription('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = OptionDescription('interface1', '', [leader])
     interface1.impl_set_group_type(groups.family)
 
     general = OptionDescription('general', '', [numero_etab, nom_machine,
diff --git a/test/test_dyn_optiondescription.py b/test/test_dyn_optiondescription.py
index e3887ff..b0e87f4 100644
--- a/test/test_dyn_optiondescription.py
+++ b/test/test_dyn_optiondescription.py
@@ -8,7 +8,7 @@ from tiramisu import BoolOption, StrOption, ChoiceOption, IPOption, \
     NetworkOption, NetmaskOption, IntOption, FloatOption, \
     UnicodeOption, PortOption, BroadcastOption, DomainnameOption, \
     EmailOption, URLOption, UsernameOption, FilenameOption, SymLinkOption, \
-    OptionDescription, DynOptionDescription, SynDynOption, submulti, MasterSlaves, \
+    OptionDescription, DynOptionDescription, SynDynOption, submulti, Leadership, \
     Config, Params, ParamOption, ParamValue
 from tiramisu.error import PropertiesOptionError, ConfigError, ConflictError
 from tiramisu.storage import list_sessions
@@ -930,10 +930,10 @@ def test_consistency_ip_in_network_dyndescription():
     cfg.option('dodval1.cval1').value.set('192.168.1.1')
 
 
-def test_masterslaves_dyndescription():
+def test_leadership_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True)
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list)
     od = OptionDescription('od', '', [st])
     od2 = OptionDescription('od', '', [od])
@@ -988,10 +988,10 @@ def test_masterslaves_dyndescription():
     assert api.option('od.stval2.st1val2.st1val2').owner.isdefault()
 
 
-def test_masterslaves_default_multi_dyndescription():
+def test_leadership_default_multi_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True, default_multi='no')
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list)
     od = OptionDescription('od', '', [st])
     od2 = OptionDescription('od', '', [od])
@@ -1011,12 +1011,12 @@ def test_masterslaves_default_multi_dyndescription():
     assert api.option('od.stval1.st1val1.st2val1', 0).owner.isdefault()
     assert api.option('od.stval2.st1val2.st1val2').owner.isdefault()
 
-def test_masterslaves_dyndescription_param():
+def test_leadership_dyndescription_param():
     val1 = StrOption('val1', '', ['val1', 'val2'], multi=True)
     odval = OptionDescription('odval1', '', [val1])
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True)
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list, callback_params=Params(ParamOption(val1)))
     od = OptionDescription('od', '', [st, odval])
     od2 = OptionDescription('od', '', [od])
@@ -1071,10 +1071,10 @@ def test_masterslaves_dyndescription_param():
     assert cfg.option('od.stval2.st1val2.st1val2').owner.get() == owners.default
 
 
-def test_masterslaves_default_multi_dyndescription():
+def test_leadership_default_multi_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True, default_multi='no')
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list)
     od = OptionDescription('od', '', [st])
     od2 = OptionDescription('od', '', [od])
@@ -1095,7 +1095,7 @@ def test_masterslaves_default_multi_dyndescription():
     assert api.option('od.stval2.st1val2.st1val2').owner.isdefault()
 
 
-def _test_masterslaves(cfg):
+def _test_leadership(cfg):
     owner = cfg.owner.get()
     cfg.option('od.val1.val1').value.set(['val1', 'val2'])
     cfg.option('od.val1.val2', 0).value.set('val1')
@@ -1149,24 +1149,24 @@ def _test_masterslaves(cfg):
     assert cfg.option('od.stval2.st1val2.st1val2').owner.get() == owners.default
 
 
-def test_masterslaves_dyndescription_param_master():
+def test_leadership_dyndescription_param_leader():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True)
-    odval = MasterSlaves('val1', '', [val1, val2])
+    odval = Leadership('val1', '', [val1, val2])
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True)
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list, callback_params=Params(ParamOption(val1)))
     od = OptionDescription('od', '', [st, odval])
     od2 = OptionDescription('od', '', [od])
     cfg = Config(od2)
-    _test_masterslaves(cfg)
+    _test_leadership(cfg)
 
 
-def test_masterslaves_default_multi_dyndescription():
+def test_leadership_default_multi_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True, default_multi='no')
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list)
     od = OptionDescription('od', '', [st])
     od2 = OptionDescription('od', '', [od])
@@ -1187,24 +1187,24 @@ def test_masterslaves_default_multi_dyndescription():
     assert api.option('od.stval2.st1val2.st1val2').owner.isdefault()
 
 
-def test_masterslaves_dyndescription_param_slave():
+def test_leadership_dyndescription_param_follower():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True)
-    odval = MasterSlaves('val1', '', [val1, val2])
+    odval = Leadership('val1', '', [val1, val2])
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True)
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list, callback_params=Params(ParamOption(val2)))
     od = OptionDescription('od', '', [st, odval])
     od2 = OptionDescription('od', '', [od])
     cfg = Config(od2)
-    _test_masterslaves(cfg)
+    _test_leadership(cfg)
 
 
-def test_masterslaves_default_multi_dyndescription():
+def test_leadership_default_multi_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True, default_multi='no')
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list)
     od = OptionDescription('od', '', [st])
     od2 = OptionDescription('od', '', [od])
@@ -1225,10 +1225,10 @@ def test_masterslaves_default_multi_dyndescription():
     assert api.option('od.stval2.st1val2.st1val2').owner.isdefault()
 
 
-def test_masterslaves_submulti_dyndescription():
+def test_leadership_submulti_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=submulti)
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     std = DynOptionDescription('st', '', [stm], callback=return_list)
     od1 = OptionDescription('od', '', [std])
     od2 = OptionDescription('od', '', [od1])
@@ -1257,53 +1257,10 @@ def test_masterslaves_submulti_dyndescription():
     assert api.option('od.stval2.st1val2.st1val2').owner.isdefault()
 
 
-#FIXME DynOptionDescription cannot be MasterSlave
-#def test_masterslaves_consistency_ip_dyndescription():
-#    neta = NetworkOption('net', '', multi=True)
-#    maskb = NetmaskOption('mask', '', multi=True)
-#    broadc = BroadcastOption('broad', '', multi=True)
-#    maskb.impl_add_consistency('network_netmask', neta)
-#    broadc.impl_add_consistency('broadcast', neta, maskb)
-#    dod = DynOptionDescription('net', '', [neta, maskb, broadc], callback=return_list)
-#    dod.impl_set_group_type(groups.master)
-#    od1 = OptionDescription('od', '', [dod])
-#    cfg = Config(od1)
-#    api.option('netval1.netval1').value.set(['192.168.1.0'])
-#    api.option('netval1.maskval1').value.set(['255.255.255.0'])
-#    api.option('netval1.broadval1').value.set(['192.168.1.255'])
-#
-#    api.option('netval1.netval1').value.set(['192.168.1.0', '192.168.2.128'])
-#    api.option('netval1.maskval1').value.set(['255.255.255.0', '255.255.255.128'])
-#    api.option('netval1.broadval1').value.set(['192.168.1.255', '192.168.2.255'])
-#    #
-#    assert cfg.netval1.netval1 == ['192.168.1.0', '192.168.2.128']
-#    assert cfg.netval1.maskval1 == ['255.255.255.0', '255.255.255.128']
-#    assert cfg.netval1.broadval1 == ['192.168.1.255', '192.168.2.255']
-#    assert cfg.netval2.netval2 == []
-#    assert cfg.netval2.maskval2 == []
-#    assert cfg.netval2.broadval2 == []
-
-
-#def test_masterslaves_consistency_ip_dyndescription_propertyerror():
-#    a = NetworkOption('net', '', multi=True)
-#    b = NetmaskOption('mask', '', multi=True, properties=('mandatory',))
-#    c = BroadcastOption('broad', '', multi=True)
-#    b.impl_add_consistency('network_netmask', a)
-#    c.impl_add_consistency('broadcast', a, b)
-#    dod = DynOptionDescription('net', '', [a, b, c], callback=return_list)
-#    dod.impl_set_group_type(groups.master)
-#    od = OptionDescription('od', '', [dod])
-#    cfg = Config(od)
-#    api.property.read_write()
-#    cfg.netval1.netval1 = ['192.168.1.0']
-#    api.property.read_only()
-#    raises(PropertiesOptionError, "cfg.netval1.netval1")
-
-
-def test_masterslaves_callback_dyndescription():
+def test_leadership_callback_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True, callback=return_dynval, callback_params=Params(kwargs={'value': ParamOption(st1)}))
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st1 = DynOptionDescription('st', '', [stm], callback=return_list)
     od1 = OptionDescription('od', '', [st1])
     od2 = OptionDescription('od', '', [od1])
@@ -1361,10 +1318,10 @@ def test_masterslaves_callback_dyndescription():
     assert api.option('od.stval1.st1val1.st2val1', 0).value.get() == 'yes'
 
 
-def test_masterslaves_callback_value_dyndescription():
+def test_leadership_callback_value_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True, callback=return_dynval, callback_params=Params(kwargs={'value': ParamValue('val')}))
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     st = DynOptionDescription('st', '', [stm], callback=return_list)
     od = OptionDescription('od', '', [st])
     od2 = OptionDescription('od', '', [od])
@@ -1376,11 +1333,11 @@ def test_masterslaves_callback_value_dyndescription():
     assert api.option('od.stval1.st1val1.st2val1', 0).value.get() == 'val'
 
 
-def test_masterslaves_callback_nomulti_dyndescription():
+def test_leadership_callback_nomulti_dyndescription():
     v11 = StrOption('v1', '', "val")
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True, callback=return_dynval, callback_params=Params(ParamOption(v11)))
-    stm = MasterSlaves('st1', '', [st1, st2])
+    stm = Leadership('st1', '', [st1, st2])
     stt = DynOptionDescription('st', '', [stm], callback=return_list)
     od1 = OptionDescription('od', '', [stt])
     od2 = OptionDescription('od', '', [od1, v11])
@@ -1391,11 +1348,11 @@ def test_masterslaves_callback_nomulti_dyndescription():
     assert api.option('od.stval1.st1val1.st2val1', 0).value.get() == 'val'
 
 
-def test_masterslaves_callback_samegroup_dyndescription():
+def test_leadership_callback_samegroup_dyndescription():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True)
     st3 = StrOption('st3', "", multi=True, callback=return_dynval, callback_params=Params(ParamOption(st2)))
-    stm = MasterSlaves('st1', '', [st1, st2, st3])
+    stm = Leadership('st1', '', [st1, st2, st3])
     stt = DynOptionDescription('st', '', [stm], callback=return_list)
     od1 = OptionDescription('od', '', [stt])
     od2 = OptionDescription('od', '', [od1])
diff --git a/test/test_freeze.py b/test/test_freeze.py
index b157aed..fb277b6 100644
--- a/test/test_freeze.py
+++ b/test/test_freeze.py
@@ -7,7 +7,7 @@ from py.test import raises
 
 from tiramisu.setting import owners, groups
 from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
-    StrOption, OptionDescription, SymLinkOption, MasterSlaves, Config, \
+    StrOption, OptionDescription, SymLinkOption, Leadership, Config, \
     Params, ParamContext, ParamOption, ParamValue
 from tiramisu.error import PropertiesOptionError, ConfigError
 from tiramisu.storage import list_sessions
@@ -178,25 +178,25 @@ def test_force_store_value_no_requirement():
         pass
 
 
-def test_force_store_value_masterslaves_slave():
+def test_force_store_value_leadership_follower():
     b = IntOption('int', 'Test int option', multi=True)
     c = StrOption('str', 'Test string option', multi=True, properties=('force_store_value',))
-    descr = MasterSlaves("int", "", [b, c])
+    descr = Leadership("int", "", [b, c])
     raises(ConfigError, "conf = Config(descr)")
 
 
-#def test_force_store_value_masterslaves():
+#def test_force_store_value_leadership():
 #    b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',))
 #    c = StrOption('str', 'Test string option', multi=True)
-#    descr = MasterSlaves("int", "", [b, c])
+#    descr = Leadership("int", "", [b, c])
 #    api = Config(descr)
 #    assert api.value.get() == {'int': ('forced', ())}
 
 
-def test_force_store_value_masterslaves_sub():
+def test_force_store_value_leadership_sub():
     b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',))
     c = StrOption('str', 'Test string option', multi=True)
-    descr = MasterSlaves("int", "", [b, c])
+    descr = Leadership("int", "", [b, c])
     odr = OptionDescription('odr', '', [descr])
     api = Config(odr)
     compare(api.value.exportation(), (('int.int',), (None,), (tuple(),), ('forced',)))
diff --git a/test/test_masterslaves.py b/test/test_leadership.py
similarity index 84%
rename from test/test_masterslaves.py
rename to test/test_leadership.py
index e1ae87a..aadf448 100644
--- a/test/test_masterslaves.py
+++ b/test/test_leadership.py
@@ -5,8 +5,8 @@ from py.test import raises
 
 from tiramisu.setting import groups, owners
 from tiramisu import ChoiceOption, BoolOption, IntOption, IPOption, NetmaskOption, \
-    StrOption, OptionDescription, MasterSlaves, Config
-from tiramisu.error import SlaveError, PropertiesOptionError, APIError, ConfigError
+    StrOption, OptionDescription, Leadership, Config
+from tiramisu.error import LeadershipError, PropertiesOptionError, APIError, ConfigError
 from tiramisu.api import TIRAMISU_VERSION
 from tiramisu.storage import list_sessions
 
@@ -46,8 +46,8 @@ def make_description():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé")
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau")
 
-    master = OptionDescription('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    interface1 = OptionDescription('interface1', '', [master])
+    leader = OptionDescription('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = OptionDescription('interface1', '', [leader])
     interface1.impl_set_group_type(groups.family)
 
     general = OptionDescription('general', '', [numero_etab, nom_machine,
@@ -206,59 +206,58 @@ def test_iter_not_group():
         raise Exception('must raise')
 
 
-def test_groups_with_master():
+def test_groups_with_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
-    assert interface1.impl_get_group_type() == groups.master
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    assert interface1.impl_get_group_type() == groups.leadership
 
 
-def test_groups_is_master():
+def test_groups_is_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, default_multi='value')
-    interface1 = MasterSlaves('masterslaves', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('leadership', '', [ip_admin_eth0, netmask_admin_eth0])
     var = StrOption('var', "ip réseau autorisé", multi=True)
     od2 = OptionDescription('od2', '', [var])
     od1 = OptionDescription('od', '', [interface1, od2])
     api = Config(od1)
-    assert not api.option('od2').option.ismasterslaves()
-    assert api.option('masterslaves').option.ismasterslaves()
-    assert not api.option('od2.var').option.ismaster()
-    assert not api.option('od2.var').option.isslave()
-    assert api.option('masterslaves.ip_admin_eth0').option.ismulti()
-    assert api.option('masterslaves.netmask_admin_eth0').option.ismulti()
-    assert not api.option('masterslaves.ip_admin_eth0').option.issubmulti()
-    assert not api.option('masterslaves.netmask_admin_eth0').option.issubmulti()
-    assert api.option('masterslaves.ip_admin_eth0').option.ismaster()
-    assert not api.option('masterslaves.ip_admin_eth0').option.isslave()
-    assert not api.option('masterslaves.netmask_admin_eth0').option.ismaster()
-    assert api.option('masterslaves.netmask_admin_eth0').option.isslave()
-    assert api.option('masterslaves.netmask_admin_eth0').option.path() == 'masterslaves.netmask_admin_eth0'
-    assert api.option('masterslaves.netmask_admin_eth0').option.defaultmulti() == 'value'
+    assert not api.option('od2').option.isleadership()
+    assert api.option('leadership').option.isleadership()
+    assert not api.option('od2.var').option.isleader()
+    assert not api.option('od2.var').option.isfollower()
+    assert api.option('leadership.ip_admin_eth0').option.ismulti()
+    assert api.option('leadership.netmask_admin_eth0').option.ismulti()
+    assert not api.option('leadership.ip_admin_eth0').option.issubmulti()
+    assert not api.option('leadership.netmask_admin_eth0').option.issubmulti()
+    assert api.option('leadership.ip_admin_eth0').option.isleader()
+    assert not api.option('leadership.ip_admin_eth0').option.isfollower()
+    assert not api.option('leadership.netmask_admin_eth0').option.isleader()
+    assert api.option('leadership.netmask_admin_eth0').option.isfollower()
+    assert api.option('leadership.netmask_admin_eth0').option.path() == 'leadership.netmask_admin_eth0'
+    assert api.option('leadership.netmask_admin_eth0').option.defaultmulti() == 'value'
 
 
 if TIRAMISU_VERSION != 2:
-    def test_groups_with_master_in_root():
+    def test_groups_with_leader_in_root():
         ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
         netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-        interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+        interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
         raises(ConfigError, "Config(interface1)")
 
 
-def test_groups_with_master_in_config():
+def test_groups_with_leader_in_config():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     Config(od)
-    assert interface1.impl_get_group_type() == groups.master
+    assert interface1.impl_get_group_type() == groups.leadership
 
 
-def test_groups_with_master_make_dict():
+def test_groups_with_leader_make_dict():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     api = Config(od)
     assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': []}
@@ -270,10 +269,10 @@ def test_groups_with_master_make_dict():
     assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['ip1', 'ip2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None]}
 
 
-def test_groups_with_master_hidden_in_config():
+def test_groups_with_leader_hidden_in_config():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=('hidden',))
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     api = Config(od)
     api.property.read_write()
@@ -285,10 +284,10 @@ def test_groups_with_master_hidden_in_config():
     raises(PropertiesOptionError, "api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
 
 
-def test_groups_with_master_hidden_in_config2():
+def test_groups_with_leader_hidden_in_config2():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     api = Config(od)
     api.property.read_write()
@@ -312,40 +311,39 @@ def test_groups_with_master_hidden_in_config2():
     assert api.forcepermissive.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
 
 
-def test_groups_with_master_reset_empty():
+def test_groups_with_leader_reset_empty():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od_ = OptionDescription('root', '', [interface1])
     api = Config(od_)
     api.property.read_write()
     api.option('ip_admin_eth0.ip_admin_eth0').value.reset()
-    raises(SlaveError, "api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()")
+    raises(LeadershipError, "api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()")
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1'])
     api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()
 
 
-def test_groups_with_master_reset_out_of_range():
+def test_groups_with_leader_reset_out_of_range():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od_ = OptionDescription('root', '', [interface1])
     api = Config(od_)
     api.property.read_write()
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1'])
     api.forcepermissive.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.0')
     api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()
-    raises(SlaveError, "api.option('ip_admin_eth0.netmask_admin_eth0', 1).value.reset()")
+    raises(LeadershipError, "api.option('ip_admin_eth0.netmask_admin_eth0', 1).value.reset()")
     raises(IndexError, "api.option('ip_admin_eth0.ip_admin_eth0').value.pop(1)")
 
 
-def test_groups_with_master_hidden_in_config3():
-    #if master is hidden, slave are hidden too
+def test_groups_with_leader_hidden_in_config3():
+    #if leader is hidden, follower are hidden too
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=('hidden',))
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
-    #interface1.impl_set_group_type(groups.master)
     api = Config(od)
     api.property.read_write()
     api.permissive.set(frozenset(['hidden']))
@@ -364,11 +362,10 @@ def test_allowed_groups():
     raises(ValueError, "interface1.impl_set_group_type('toto')")
 
 
-def test_values_with_master_disabled_master():
+def test_values_with_leader_disabled_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -381,30 +378,29 @@ def test_values_with_master_disabled_master():
     raises(PropertiesOptionError, "api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('192.168.230.145')")
 
 
-def test_sub_group_in_master_group():
+def test_sub_group_in_leader_group():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
     subgroup = OptionDescription("subgroup", '', [])
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [subgroup, ip_admin_eth0, netmask_admin_eth0])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [subgroup, ip_admin_eth0, netmask_admin_eth0])")
 
 
 def test_group_always_has_multis():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau")
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
 
 
 #____________________________________________________________
-def test_values_with_master_and_slaves():
+def test_values_with_leader_and_followers():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
     owner = api.owner.get()
-    assert interface1.impl_get_group_type() == groups.master
+    assert interface1.impl_get_group_type() == groups.leadership
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.isdefault()
     #
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
@@ -417,16 +413,15 @@ def test_values_with_master_and_slaves():
     raises(APIError, "api.option('ip_admin_eth0.netmask_admin_eth0').value.pop(0)")
 
 
-def test_reset_values_with_master_and_slaves():
+def test_reset_values_with_leader_and_followers():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
     owner = api.owner.get()
-    assert interface1.impl_get_group_type() == groups.master
+    assert interface1.impl_get_group_type() == groups.leadership
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.isdefault()
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
@@ -441,17 +436,16 @@ def test_reset_values_with_master_and_slaves():
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
 
 
-def test_reset_values_with_master_and_slaves_default_value():
+def test_reset_values_with_leader_and_followers_default_value():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, default=['192.168.230.145'])
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, default=['255.255.255.0'])
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
 
 
-def test_reset_values_with_master_and_slaves_default():
+def test_reset_values_with_leader_and_followers_default():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, default=['192.168.230.145'])
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -488,15 +482,14 @@ def test_reset_values_with_master_and_slaves_default():
     api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(None)
 
 
-def test_values_with_master_and_slaves_slave():
+def test_values_with_leader_and_followers_follower():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
-    raises(SlaveError,
+    raises(LeadershipError,
            "api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.0')")
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
     api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.0')
@@ -517,11 +510,10 @@ def test_values_with_master_and_slaves_slave():
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
 
 
-def test_values_with_master_and_slaves_pop():
+def test_values_with_leader_and_followers_pop():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -537,11 +529,10 @@ def test_values_with_master_and_slaves_pop():
     assert api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == '255.255.0.0'
 
 
-def test_values_with_master_and_slaves_master():
+def test_values_with_leader_and_followers_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -550,7 +541,7 @@ def test_values_with_master_and_slaves_master():
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.145"])
     api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.0')
     api.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('255.255.255.0')
-    raises(SlaveError, "api.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])")
+    raises(LeadershipError, "api.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])")
     assert api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == '255.255.255.0'
     assert api.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == '255.255.255.0'
     api.option('ip_admin_eth0.ip_admin_eth0').value.pop(1)
@@ -560,10 +551,10 @@ def test_values_with_master_and_slaves_master():
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
 
 
-def test_values_with_master_and_slaves_master_pop():
+def test_values_with_leader_and_followers_leader_pop():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -591,11 +582,10 @@ def test_values_with_master_and_slaves_master_pop():
     compare(api.value.exportation(), (('ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'), (None, (0,)), (('192.168.230.146', "192.168.230.145"), ('255.255.0.0',)), ('user', ('user',))))
 
 
-def test_values_with_master_owner():
+def test_values_with_leader_owner():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -608,11 +598,10 @@ def test_values_with_master_owner():
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
 
 
-def test_values_with_master_disabled():
+def test_values_with_leader_disabled():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -649,11 +638,10 @@ def test_multi_non_valid_value():
     raises(ValueError, "api.option('ip_admin_eth0').value.set([1])")
 
 
-def test_multi_master_default_slave():
+def test_multi_leader_default_follower():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", default_multi="255.255.255.0", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -661,11 +649,10 @@ def test_multi_master_default_slave():
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.1']
 
 
-def test_groups_with_master_get_modified_value():
+def test_groups_with_leader_get_modified_value():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -679,11 +666,10 @@ def test_groups_with_master_get_modified_value():
     compare(api.value.exportation(), (('ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0',), (None, (0, 1)), (('192.168.1.1', '192.168.1.1'), ('255.255.255.255', '255.255.255.255')), ('user', ('user', 'user'))))
 
 
-def test_groups_with_master_importation():
+def test_groups_with_leader_importation():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -699,7 +685,7 @@ def test_groups_with_master_importation():
 def test_wrong_index():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, default=['1.1.1.1'])
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od1 = OptionDescription('od', '', [interface1])
     maconfig = OptionDescription('toto', '', [od1])
     api = Config(maconfig)
@@ -713,57 +699,57 @@ def test_wrong_index():
     raises(APIError, "api.option('od', 0).option.get()")
 
 
-def test_without_master_or_slave():
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [])")
+def test_without_leader_or_follower():
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [])")
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, default=['1.1.1.1'])
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0])")
     #empty optiondescription is allowed
     OptionDescription('ip_admin_eth0', '', [])
 
 
-def test_master_not_multi():
+def test_leader_not_multi():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé")
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
 
 
-def test_slave_not_multi():
+def test_follower_not_multi():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau")
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
 
 
-def test_slave_not_same():
+def test_follower_not_same():
     ip_admin_eth0 = IPOption('ip_admin_eth0', "ip réseau autorisé", multi=True, default=['1.1.1.1'])
     netmask_admin_eth0 = NetmaskOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface0 = MasterSlaves('interface0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface0 = Leadership('interface0', '', [ip_admin_eth0, netmask_admin_eth0])
     ip_admin_eth1 = IPOption('ip_admin_eth1', "ip réseau autorisé", multi=True, default=['1.1.1.1'])
     netmask_admin_eth1 = NetmaskOption('netmask_admin_eth1', "masque du sous-réseau", multi=True)
     netmask_admin_eth1.impl_add_consistency('ip_netmask', ip_admin_eth0)
-    interface1 = MasterSlaves('interface1', '', [ip_admin_eth1, netmask_admin_eth1])
+    interface1 = Leadership('interface1', '', [ip_admin_eth1, netmask_admin_eth1])
     od1 = OptionDescription('od', '', [interface0, interface1])
     maconfig = OptionDescription('toto', '', [od1])
     raises(ConfigError, "Config(maconfig)")
 
 
-def test_slave_not_same_not_equal():
+def test_follower_not_same_not_equal():
     ip_admin_eth0 = IPOption('ip_admin_eth0', "ip réseau autorisé", multi=True, default=['1.1.1.1'])
     netmask_admin_eth0 = NetmaskOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface0 = MasterSlaves('interface0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface0 = Leadership('interface0', '', [ip_admin_eth0, netmask_admin_eth0])
     ip_admin_eth1 = IPOption('ip_admin_eth1', "ip réseau autorisé", multi=True, default=['1.1.1.1'])
     netmask_admin_eth1 = NetmaskOption('netmask_admin_eth1', "masque du sous-réseau", multi=True)
     netmask_admin_eth1.impl_add_consistency('not_equal', netmask_admin_eth0)
-    interface1 = MasterSlaves('interface1', '', [ip_admin_eth1, netmask_admin_eth1])
+    interface1 = Leadership('interface1', '', [ip_admin_eth1, netmask_admin_eth1])
     od1 = OptionDescription('od', '', [interface0, interface1])
     maconfig = OptionDescription('toto', '', [od1])
     api = Config(maconfig)
     api.property.read_write()
 
 
-def test_slave_force_store_value():
+def test_follower_force_store_value():
     ip_admin_eth0 = IPOption('ip_admin_eth0', "ip réseau autorisé", multi=True, default=['1.1.1.1'])
     netmask_admin_eth0 = NetmaskOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, properties=('force_store_value',))
-    interface0 = MasterSlaves('interface0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface0 = Leadership('interface0', '', [ip_admin_eth0, netmask_admin_eth0])
     od1 = OptionDescription('od', '', [interface0])
     maconfig = OptionDescription('toto', '', [od1])
     raises(ConfigError, "Config(maconfig)")
diff --git a/test/test_mandatory.py b/test/test_mandatory.py
index 74cdf68..0afe902 100644
--- a/test/test_mandatory.py
+++ b/test/test_mandatory.py
@@ -6,7 +6,7 @@ from py.test import raises
 from tiramisu.api import TIRAMISU_VERSION
 from tiramisu import Config
 from tiramisu import IntOption, StrOption, UnicodeOption, OptionDescription, \
-                     SymLinkOption, MasterSlaves, undefined, Params, ParamOption
+                     SymLinkOption, Leadership, undefined, Params, ParamOption
 from tiramisu.error import PropertiesOptionError, ConfigError
 from tiramisu.setting import groups
 from tiramisu.storage import list_sessions
@@ -407,37 +407,34 @@ def test_mandatory_warnings_frozen():
     assert set(api.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
 
 
-def test_mandatory_master():
+def test_mandatory_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
                               properties=('mandatory', ))
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
                                    multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     descr = OptionDescription('o', '', [interface1])
     api = Config(descr)
     api.property.read_only()
     raises(PropertiesOptionError, "api.option('ip_admin_eth0.ip_admin_eth0').value.get()")
 
 
-def test_mandatory_warnings_master():
+def test_mandatory_warnings_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
                               properties=('mandatory', ))
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
                                    multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     descr = OptionDescription('o', '', [interface1])
     api = Config(descr)
     assert list(api.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
 
 
-def test_mandatory_master_empty():
+def test_mandatory_leader_empty():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
                                    multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     descr = OptionDescription('o', '', [interface1])
     api = Config(descr)
     api.property.read_write()
@@ -475,12 +472,11 @@ def test_mandatory_master_empty():
     api.option('ip_admin_eth0.ip_admin_eth0').value.reset()
 
 
-def test_mandatory_warnings_master_empty():
+def test_mandatory_warnings_leader_empty():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
                                    multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     descr = OptionDescription('o', '', [interface1])
     api = Config(descr)
     api.property.read_write()
@@ -500,12 +496,11 @@ def test_mandatory_warnings_master_empty():
     assert list(api.value.mandatory()) == []
 
 
-def test_mandatory_slave():
+def test_mandatory_follower():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
                                    multi=True, properties=('mandatory', ))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     descr = OptionDescription('o', '', [interface1])
     api = Config(descr)
     api.property.read_only()
@@ -530,12 +525,11 @@ def test_mandatory_slave():
     assert api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == 'ip'
 
 
-def test_mandatory_warnings_slave():
+def test_mandatory_warnings_follower():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
                                    multi=True, properties=('mandatory', ))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     descr = OptionDescription('o', '', [interface1])
     api = Config(descr)
     api.property.read_only()
@@ -597,32 +591,32 @@ def test_mandatory_warnings_requires():
     assert list(api.value.mandatory()) == ['str1', 'unicode2', 'str3']
 
 
-def test_mandatory_warnings_requires_masterslaves():
+def test_mandatory_warnings_requires_leadership():
     stroption = StrOption('str', 'Test string option', default="abc",
                           properties=('mandatory', ))
     stroption1 = StrOption('str1', 'Test string option', multi=True)
     stroption2 = StrOption('str2', 'Test string option', multi=True, requires=[{'option': stroption, 'expected': 'yes', 'action': 'mandatory', 'transitive': False}])
-    masterslave = MasterSlaves('master', 'masterslaves', [stroption1, stroption2])
-    descr = OptionDescription('tiram', '', [stroption, masterslave])
+    leadership = Leadership('leader', 'leadership', [stroption1, stroption2])
+    descr = OptionDescription('tiram', '', [stroption, leadership])
     api = Config(descr)
     api.option('str').value.set('')
-    api.option('master.str1').value.set(['str'])
+    api.option('leader.str1').value.set(['str'])
     assert list(api.value.mandatory()) == ['str']
     api.option('str').value.set('yes')
-    assert list(api.value.mandatory()) == ['master.str2']
+    assert list(api.value.mandatory()) == ['leader.str2']
 
 
-def test_mandatory_warnings_requires_masterslaves_slave():
+def test_mandatory_warnings_requires_leadership_follower():
     stroption = StrOption('str', 'Test string option', multi=True)
     stroption1 = StrOption('str1', 'Test string option', multi=True)
     stroption2 = StrOption('str2', 'Test string option', multi=True, requires=[{'option': stroption1, 'expected': 'yes', 'action': 'mandatory', 'transitive': False}])
-    masterslave = MasterSlaves('master', 'masterslaves', [stroption, stroption1, stroption2])
-    descr = OptionDescription('tiram', '', [masterslave])
+    leadership = Leadership('leader', 'leadership', [stroption, stroption1, stroption2])
+    descr = OptionDescription('tiram', '', [leadership])
     api = Config(descr)
-    api.option('master.str').value.set(['str'])
+    api.option('leader.str').value.set(['str'])
     assert list(api.value.mandatory()) == []
-    api.option('master.str1', 0).value.set('yes')
-    assert list(api.value.mandatory()) == ['master.str2']
+    api.option('leader.str1', 0).value.set('yes')
+    assert list(api.value.mandatory()) == ['leader.str2']
 
 
 def test_mandatory_od_disabled():
diff --git a/test/test_metaconfig.py b/test/test_metaconfig.py
index f29bb22..fcf10e2 100644
--- a/test/test_metaconfig.py
+++ b/test/test_metaconfig.py
@@ -4,9 +4,9 @@ do_autopath()
 
 from tiramisu.setting import groups, owners
 from tiramisu import IntOption, StrOption, NetworkOption, NetmaskOption, BoolOption, ChoiceOption, \
-                     IPOption, OptionDescription, MasterSlaves, Config, GroupConfig, MetaConfig, \
+                     IPOption, OptionDescription, Leadership, Config, GroupConfig, MetaConfig, \
                      Params, ParamOption, ParamValue
-from tiramisu.error import ConfigError, ConflictError, PropertiesOptionError, SlaveError, APIError
+from tiramisu.error import ConfigError, ConflictError, PropertiesOptionError, LeadershipError, APIError
 from tiramisu.storage import list_sessions
 
 
@@ -384,10 +384,10 @@ def test_meta_unconsistent():
     raises(ValueError, "MetaConfig([conf3, conf4])")
 
 
-def test_meta_master_slaves():
+def test_meta_leadership():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -410,10 +410,10 @@ def test_meta_master_slaves():
     assert conf2._config_bag.context == next(itr)._config_bag.context
 
 
-def test_meta_master_slaves_value2():
+def test_meta_leadership_value2():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -435,10 +435,10 @@ def test_meta_master_slaves_value2():
     assert meta.config('conf1').option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
 
 
-def test_meta_master_slaves_value_default():
+def test_meta_leadership_value_default():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True, default=['192.168.1.1'])
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -458,17 +458,17 @@ def test_meta_master_slaves_value_default():
     assert meta.config('conf1').option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
 
 
-def test_meta_master_slaves_owners():
+def test_meta_leadership_owners():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
     meta = MetaConfig([conf1, conf2])
     meta.owner.set(owners.meta1)
     assert meta.config('conf1').option('ip_admin_eth0.ip_admin_eth0').owner.isdefault()
-    raises(SlaveError, "meta.config('conf1').option('ip_admin_eth0.netmask_admin_eth0', 0).owner.isdefault()")
+    raises(LeadershipError, "meta.config('conf1').option('ip_admin_eth0.netmask_admin_eth0', 0).owner.isdefault()")
     #
     meta.config('conf1').option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1'])
     assert meta.config('conf1').option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.user
@@ -497,7 +497,7 @@ def test_meta_master_slaves_owners():
 def test_meta_force_default():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -535,7 +535,7 @@ def test_meta_force_default():
 def test_meta_force_dont_change_value():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -562,7 +562,7 @@ def test_meta_force_dont_change_value():
 def test_meta_force_default_if_same():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -604,7 +604,7 @@ def test_meta_force_default_if_same():
 def test_meta_force_default_if_same_and_dont_change():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -646,7 +646,7 @@ def test_meta_force_default_if_same_and_dont_change():
 def test_meta_force_default_and_dont_change():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='rconf1')
     conf2 = Config(od, session_id='rconf2')
@@ -660,7 +660,7 @@ def test_meta_properties_meta():
     ip_admin_eth0 = NetworkOption('ip_admin_eth0', "ip", multi=True, default=['192.168.1.1'])
     netmask_admin_eth0 = NetmaskOption('netmask_admin_eth0', "mask", multi=True, properties=('disabled',))
     netmask_admin_eth0.impl_add_consistency('network_netmask', ip_admin_eth0)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -675,7 +675,7 @@ def test_meta_exception_meta():
     ip_admin_eth0 = NetworkOption('ip_admin_eth0', "ip", multi=True, default=['192.168.1.1'])
     netmask_admin_eth0 = NetmaskOption('netmask_admin_eth0', "mask", multi=True, callback=raise_exception)
     netmask_admin_eth0.impl_add_consistency('network_netmask', ip_admin_eth0)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -728,12 +728,12 @@ def test_meta_callback():
     meta.option('val4').value.reset()
 
 
-def test_meta_callback_slave():
+def test_meta_callback_follower():
     val = StrOption('val', "", default='val')
     val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val)))
     val3 = StrOption('val2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)))
     val4 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)))
-    interface1 = MasterSlaves('val1', '', [val1, val3, val4])
+    interface1 = Leadership('val1', '', [val1, val3, val4])
     od = OptionDescription('root', '', [interface1])
     maconfig = OptionDescription('rootconfig', '', [val, interface1])
     cfg = Config(maconfig, session_id='cfg1')
@@ -774,7 +774,7 @@ def test_meta_callback_slave():
 def test_meta_reset():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
diff --git a/test/test_mixconfig.py b/test/test_mixconfig.py
index 4418eaf..d4162a3 100644
--- a/test/test_mixconfig.py
+++ b/test/test_mixconfig.py
@@ -5,9 +5,9 @@ from py.test import raises
 
 from tiramisu.setting import groups, owners
 from tiramisu import IntOption, StrOption, NetworkOption, NetmaskOption, \
-                     OptionDescription, MasterSlaves, Config, GroupConfig, MixConfig, \
+                     OptionDescription, Leadership, Config, GroupConfig, MixConfig, \
                      Params, ParamOption, ParamValue
-from tiramisu.error import ConfigError, ConflictError, PropertiesOptionError, SlaveError, APIError
+from tiramisu.error import ConfigError, ConflictError, PropertiesOptionError, LeadershipError, APIError
 from tiramisu.storage import list_sessions
 
 owners.addowner('mix1')
@@ -311,10 +311,10 @@ def test_mix_unconsistent():
     MixConfig(od2, [conf3, conf4])
 
 
-def test_mix_master_slaves():
+def test_mix_leadership():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -337,10 +337,10 @@ def test_mix_master_slaves():
     assert conf2._config_bag.context == next(itr)._config_bag.context
 
 
-def test_mix_master_slaves_value2():
+def test_mix_leadership_value2():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -362,10 +362,10 @@ def test_mix_master_slaves_value2():
     assert mix.config('conf1').option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
 
 
-def test_mix_master_slaves_value_default():
+def test_mix_leadership_value_default():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True, default=['192.168.1.1'])
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -385,17 +385,17 @@ def test_mix_master_slaves_value_default():
     assert mix.config('conf1').option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
 
 
-def test_mix_master_slaves_owners():
+def test_mix_leadership_owners():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
     mix = MixConfig(od, [conf1, conf2])
     mix.owner.set(owners.mix1)
     assert mix.config('conf1').option('ip_admin_eth0.ip_admin_eth0').owner.isdefault()
-    raises(SlaveError, "mix.config('conf1').option('ip_admin_eth0.netmask_admin_eth0', 0).owner.isdefault()")
+    raises(LeadershipError, "mix.config('conf1').option('ip_admin_eth0.netmask_admin_eth0', 0).owner.isdefault()")
     #
     mix.config('conf1').option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1'])
     assert mix.config('conf1').option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.user
@@ -424,7 +424,7 @@ def test_mix_master_slaves_owners():
 def test_mix_force_default():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -462,7 +462,7 @@ def test_mix_force_default():
 def test_mix_force_dont_change_value():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -489,7 +489,7 @@ def test_mix_force_dont_change_value():
 def test_mix_force_default_if_same():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -531,7 +531,7 @@ def test_mix_force_default_if_same():
 def test_mix_force_default_if_same_and_dont_change():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -573,7 +573,7 @@ def test_mix_force_default_if_same_and_dont_change():
 def test_mix_force_default_and_dont_change():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='rconf1')
     conf2 = Config(od, session_id='rconf2')
@@ -587,7 +587,7 @@ def test_mix_properties_mix():
     ip_admin_eth0 = NetworkOption('ip_admin_eth0', "ip", multi=True, default=['192.168.1.1'])
     netmask_admin_eth0 = NetmaskOption('netmask_admin_eth0', "mask", multi=True, properties=('disabled',))
     netmask_admin_eth0.impl_add_consistency('network_netmask', ip_admin_eth0)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -602,7 +602,7 @@ def test_mix_exception_mix():
     ip_admin_eth0 = NetworkOption('ip_admin_eth0', "ip", multi=True, default=['192.168.1.1'])
     netmask_admin_eth0 = NetmaskOption('netmask_admin_eth0', "mask", multi=True, callback=raise_exception)
     netmask_admin_eth0.impl_add_consistency('network_netmask', ip_admin_eth0)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     conf1 = Config(od, session_id='conf1')
     conf2 = Config(od, session_id='conf2')
@@ -635,12 +635,12 @@ def test_mix_callback():
     mix.option('val4').value.reset()
 
 
-def test_mix_callback_slave():
+def test_mix_callback_follower():
     val = StrOption('val', "", default='val')
     val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val)))
     val3 = StrOption('val2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)))
     val4 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)))
-    interface1 = MasterSlaves('val1', '', [val1, val3, val4])
+    interface1 = Leadership('val1', '', [val1, val3, val4])
     od = OptionDescription('root', '', [interface1])
     maconfig = OptionDescription('rootconfig', '', [val, interface1])
     cfg = Config(maconfig, session_id='cfg1')
@@ -681,15 +681,15 @@ def test_mix_callback_slave():
 def test_meta_reset():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od0 = OptionDescription('root', '', [interface1])
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od1 = OptionDescription('root', '', [interface1])
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "mask", multi=True, properties=('hidden',))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od2 = OptionDescription('root', '', [interface1])
     conf1 = Config(od0, session_id='conf1')
     conf2 = Config(od1, session_id='conf2')
diff --git a/test/test_option.py b/test/test_option.py
index 7cb4d16..7b9e556 100644
--- a/test/test_option.py
+++ b/test/test_option.py
@@ -195,10 +195,10 @@ def test_optiondescription_group_redefined():
     raises(ValueError, "od1.impl_set_group_type(groups.notfamily)")
 
 
-def test_optiondescription_group_masterslave():
+def test_optiondescription_group_leadership():
     i = IntOption('test', '')
     od1 = OptionDescription('od', '', [i])
-    raises(ConfigError, "od1.impl_set_group_type(groups.master)")
+    raises(ConfigError, "od1.impl_set_group_type(groups.leadership)")
 
 
 
diff --git a/test/test_option_callback.py b/test/test_option_callback.py
index afc661e..843ae30 100644
--- a/test/test_option_callback.py
+++ b/test/test_option_callback.py
@@ -7,10 +7,10 @@ from tiramisu import Config
 from tiramisu.config import KernelConfig
 from tiramisu.setting import groups, owners
 from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
-    StrOption, OptionDescription, SymLinkOption, IPOption, NetmaskOption, MasterSlaves, \
+    StrOption, OptionDescription, SymLinkOption, IPOption, NetmaskOption, Leadership, \
     undefined, Params, ParamOption, ParamValue, ParamContext
 from tiramisu.api import TIRAMISU_VERSION
-from tiramisu.error import PropertiesOptionError, ConflictError, SlaveError, ConfigError
+from tiramisu.error import PropertiesOptionError, ConflictError, LeadershipError, ConfigError
 from tiramisu.i18n import _
 from tiramisu.storage import list_sessions
 
@@ -502,11 +502,10 @@ def test_callback_multi_callback():
     assert api.option('val1.val1').value.get() == ['val1', 'val']
 
 
-def test_callback_master_and_slaves_master():
+def test_callback_leader_and_followers_leader():
     val1 = StrOption('val1', "", multi=True, callback=return_val)
     val2 = StrOption('val2', "", multi=True)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -517,11 +516,10 @@ def test_callback_master_and_slaves_master():
     assert api.option('val1.val2', 1).value.get() == None
 
 
-def test_callback_slave():
+def test_callback_follower():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, callback=return_value3, callback_params=Params(ParamValue(['string', 'new'])))
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -541,13 +539,12 @@ def test_callback_slave():
     assert api.option('val1.val2', 3).value.get() == None
 
 
-def test_callback_master_and_slaves_master2():
+def test_callback_leader_and_followers_leader2():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, default_multi='val2')
     val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val2)))
     val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
-    interface1 = MasterSlaves('val1', '', [val1, val2, val3, val4])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2, val3, val4])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -557,13 +554,12 @@ def test_callback_master_and_slaves_master2():
     assert api.option('val1.val2', 0).value.get() == 'val2'
 
 
-def test_callback_master_and_slaves_master_mandatory():
+def test_callback_leader_and_followers_leader_mandatory():
     val = StrOption('val', "", default='val')
     val1 = StrOption('val1', "", multi=True, callback=return_value2, callback_params=Params(ParamOption(val)), properties=('mandatory',))
     val3 = StrOption('val3', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
     val4 = StrOption('val4', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
-    interface1 = MasterSlaves('val1', '', [val1, val3, val4])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val3, val4])
     maconfig = OptionDescription('rootconfig', '', [val, interface1])
     api = Config(maconfig)
     api.property.read_only()
@@ -579,14 +575,13 @@ def test_callback_master_and_slaves_master_mandatory():
     raises(PropertiesOptionError, "api.option('val1.val4', 1).value.get()")
 
 
-def test_callback_master_and_slaves_master_mandatory2():
+def test_callback_leader_and_followers_leader_mandatory2():
     val = StrOption('val', "", default='val')
     val_ = StrOption('val_', "", default='val_')
     val1 = StrOption('val1', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val), {'val2': ParamOption(val_)}), properties=('mandatory',))
     val3 = StrOption('val3', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val1), {'val2': ParamOption(val_)}), properties=('mandatory',))
     val4 = StrOption('val4', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val1), {'val2': ParamOption(val_)}), properties=('mandatory',))
-    interface1 = MasterSlaves('val1', '', [val1, val3, val4])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val3, val4])
     maconfig = OptionDescription('rootconfig', '', [val, val_, interface1])
     api = Config(maconfig)
     api.property.read_only()
@@ -608,14 +603,13 @@ def test_callback_master_and_slaves_master_mandatory2():
     assert api.option('val1.val1').value.get() == ['val', 'val_', 'val3']
 
 
-def test_callback_master_and_slaves_master_mandatory3():
+def test_callback_leader_and_followers_leader_mandatory3():
     val = StrOption('val', "", default='val')
     val_ = StrOption('val_', "", default='val_')
     val1 = StrOption('val1', "", multi=True, callback=return_value2, callback_params=Params(ParamOption(val), {'val': ParamOption(val_)}), properties=('mandatory',))
     val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
     val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
-    interface1 = MasterSlaves('val1', '', [val1, val3, val4])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val3, val4])
     maconfig = OptionDescription('rootconfig', '', [val, val_, interface1])
     api = Config(maconfig)
     api.property.read_only()
@@ -636,13 +630,12 @@ def test_callback_master_and_slaves_master_mandatory3():
     assert api.option('val1.val1').value.get() == ['val', 'val_', 'val3']
 
 
-def test_callback_master_and_slaves_master_mandatory4():
+def test_callback_leader_and_followers_leader_mandatory4():
     val = StrOption('val', "", default='val')
     val1 = StrOption('val1', "", multi=True, callback=return_value2, callback_params=Params(ParamOption(val)), properties=('mandatory',))
     val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
     val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
-    interface1 = MasterSlaves('val1', '', [val1, val3, val4])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val3, val4])
     maconfig = OptionDescription('rootconfig', '', [val, interface1])
     api = Config(maconfig)
     api.property.read_only()
@@ -660,26 +653,24 @@ def test_callback_master_and_slaves_master_mandatory4():
     assert api.option('val1.val4', 1).value.get() == 'val3'
 
 
-def test_callback_master_and_slaves_master3():
+def test_callback_leader_and_followers_leader3():
     val1 = StrOption('val1', "", multi=True, properties=('mandatory', 'empty'))
     val2 = StrOption('val2', "", multi=True, default_multi='val2', properties=('expert',))
     val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val2)))
     val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
-    interface1 = MasterSlaves('val1', '', [val1, val2, val3, val4])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2, val3, val4])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
     assert list(api.value.mandatory()) == ['val1.val1']
 
 
-def test_callback_master_and_slaves_master4():
+def test_callback_leader_and_followers_leader4():
     val1 = StrOption('val1', "", ['val1'], multi=True, properties=('mandatory',))
     val2 = StrOption('val2', "", multi=True, default_multi='val2', properties=('expert', 'mandatory'))
     val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val2)))
     val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
-    interface1 = MasterSlaves('val1', '', [val1, val2, val3, val4])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2, val3, val4])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -688,7 +679,7 @@ def test_callback_master_and_slaves_master4():
     assert list(api.value.mandatory()) == []
 
 
-def test_consistency_master_and_slaves_master_mandatory_transitive():
+def test_consistency_leader_and_followers_leader_mandatory_transitive():
     #default value
     val1 = IPOption('val1', "", ['192.168.0.1'], multi=True, properties=('mandatory',))
     val2 = NetmaskOption('val2', "", multi=True, default_multi='255.255.255.0', properties=('disabled', 'mandatory'))
@@ -697,8 +688,8 @@ def test_consistency_master_and_slaves_master_mandatory_transitive():
     val3 = IPOption('val3', "", multi=True, properties=('mandatory',))
     val4 = NetmaskOption('val4', "", multi=True, default_multi='255.255.255.0', properties=('disabled', 'mandatory'))
     val4.impl_add_consistency('ip_netmask', val3)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    interface2 = MasterSlaves('val3', '', [val3, val4])
+    interface1 = Leadership('val1', '', [val1, val2])
+    interface2 = Leadership('val3', '', [val3, val4])
     maconfig = OptionDescription('rootconfig', '', [interface1, interface2])
     api = Config(maconfig)
     api.property.read_write()
@@ -712,7 +703,7 @@ def test_consistency_master_and_slaves_master_mandatory_transitive():
     assert list(api.value.mandatory()) == []
 
 
-def test_consistency_master_and_slaves_master_mandatory_non_transitive():
+def test_consistency_leader_and_followers_leader_mandatory_non_transitive():
     #no value
     val1 = IPOption('val1', "", multi=True, properties=('mandatory',))
     val2 = NetmaskOption('val2', "", multi=True, default_multi='255.255.255.0', properties=('disabled', 'mandatory'))
@@ -721,10 +712,8 @@ def test_consistency_master_and_slaves_master_mandatory_non_transitive():
     val3 = IPOption('val3', "", ['192.168.0.1'], multi=True, properties=('mandatory',))
     val4 = NetmaskOption('val4', "", multi=True, default_multi='255.255.255.0', properties=('disabled', 'mandatory'))
     val4.impl_add_consistency('ip_netmask', val3, transitive=False)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    interface2 = MasterSlaves('val3', '', [val3, val4])
-    #interface1.impl_set_group_type(groups.master)
-    #interface2.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
+    interface2 = Leadership('val3', '', [val3, val4])
     maconfig = OptionDescription('rootconfig', '', [interface1, interface2])
     api = Config(maconfig)
     api.property.read_write()
@@ -734,11 +723,10 @@ def test_consistency_master_and_slaves_master_mandatory_non_transitive():
         assert list(api.value.mandatory()) == ["val1.val1"]
 
 
-def test_callback_master_and_slaves_master_list():
+def test_callback_leader_and_followers_leader_list():
     val1 = StrOption('val1', "", multi=True, callback=return_list)
     val2 = StrOption('val2', "", multi=True)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -759,24 +747,22 @@ def test_callback_master_and_slaves_master_list():
     assert api.option('val1.val2', 0).value.get() == None
 
 
-def test_callback_master_and_slaves_master_slave_list():
+def test_callback_leader_and_followers_leader_follower_list():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, callback=return_list)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
     assert api.option('val1.val1').value.get() == []
     api.option('val1.val1').value.set(['val1'])
-    raises(SlaveError, "api.option('val1.val2', 0).value.get()")
+    raises(LeadershipError, "api.option('val1.val2', 0).value.get()")
 
 
-def test_callback_master_and_slaves_slave():
+def test_callback_leader_and_followers_follower():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, callback=return_val)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -813,21 +799,20 @@ def test_callback_master_and_slaves_slave():
     assert api.option('val1.val2', 2).value.get() == 'val'
 
 
-def test_callback_master_and_slaves():
+def test_callback_leader_and_followers():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, callback=return_val)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
 
 
-def test_callback_master_and_slaves_slave_cal():
+def test_callback_leader_and_followers_follower_cal():
     val3 = StrOption('val3', "", multi=True)
     val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
     val2 = StrOption('val2', "", multi=True, callback=return_val)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1, val3])
     api = Config(maconfig)
     api.property.read_write()
@@ -847,12 +832,12 @@ def test_callback_master_and_slaves_slave_cal():
     assert api.option('val1.val2', 0).value.get() == 'val'
     assert api.option('val1.val2', 1).value.get() == 'val'
     assert api.option('val1.val1').value.get() == ['val1', 'val2']
-    # len of slave is higher than master's one
+    # len of follower is higher than leader's one
     api.option('val1.val2', 0).value.set('val1')
     api.option('val1.val2', 1).value.set('val2')
     api.option('val3').value.set(['val1'])
     assert api.option('val1.val1').value.get() == ['val1']
-    raises(SlaveError, "api.option('val1.val2', 0).value.get()")
+    raises(LeadershipError, "api.option('val1.val2', 0).value.get()")
     #
     api.option('val3').value.set(['val1', 'val2', 'val3'])
     assert api.option('val1.val2', 0).value.get() == 'val1'
@@ -860,12 +845,11 @@ def test_callback_master_and_slaves_slave_cal():
     assert api.option('val1.val2', 2).value.get() == 'val'
 
 
-def test_callback_master_and_slaves_master_disabled():
+def test_callback_leader_and_followers_leader_disabled():
     #properties must be transitive
     val1 = StrOption('val1', "", ['val1'], multi=True, properties=('disabled',))
     val2 = StrOption('val2', "", multi=True)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -874,12 +858,11 @@ def test_callback_master_and_slaves_master_disabled():
     raises(PropertiesOptionError, "api.option('val1.val2', 0).value.get()")
 
 
-def test_callback_master_and_slaves_master_callback_disabled():
+def test_callback_leader_and_followers_leader_callback_disabled():
     val0 = StrOption('val0', "", multi=True, properties=('disabled',))
     val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val0)))
     val2 = StrOption('val2', "", multi=True)
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1, val0])
     api = Config(maconfig)
     api.property.read_write()
@@ -891,11 +874,10 @@ def test_callback_master_and_slaves_master_callback_disabled():
     assert api.option('val1.val1').value.get() == []
 
 
-def test_callback_master_and_slaves_slave_disabled():
+def test_callback_leader_and_followers_follower_disabled():
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, properties=('disabled',))
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -919,12 +901,11 @@ def test_callback_master_and_slaves_slave_disabled():
     assert api.option('val1.val2', 1).value.get() == 'no1'
 
 
-def test_callback_master_and_slaves_slave_callback_disabled():
+def test_callback_leader_and_followers_follower_callback_disabled():
     val0 = StrOption('val0', "", multi=True, properties=('disabled',))
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val0)))
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1, val0])
     api = Config(maconfig)
     api.property.read_write()
@@ -939,28 +920,27 @@ def test_callback_master_and_slaves_slave_callback_disabled():
     api.option('val1.val1').value.pop(1)
 
 
-def test_callback_master_and_slaves_value():
+def test_callback_leader_and_followers_value():
     val4 = StrOption('val4', '', multi=True, default=['val10', 'val11'])
     val1 = StrOption('val1', "", multi=True)
     val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)))
     val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamValue('yes')))
     val5 = StrOption('val5', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val4)))
     val6 = StrOption('val6', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val5)))
-    interface1 = MasterSlaves('val1', '', [val1, val2, val3, val5, val6])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2, val3, val5, val6])
     maconfig = OptionDescription('rootconfig', '', [interface1, val4])
     api = Config(maconfig)
     api.property.read_write()
     api.option('val4').value.get() == ['val10', 'val11']
     assert api.option('val1.val1').value.get() == []
-    #raises(SlaveError, "cfg.val1.val1")
-    #raises(SlaveError, "cfg.val1.val2")
-    #raises(SlaveError, "cfg.val1.val3")
-    #raises(SlaveError, "cfg.val1.val5")
-    #raises(SlaveError, "cfg.val1.val6")
+    #raises(LeadershipError, "cfg.val1.val1")
+    #raises(LeadershipError, "cfg.val1.val2")
+    #raises(LeadershipError, "cfg.val1.val3")
+    #raises(LeadershipError, "cfg.val1.val5")
+    #raises(LeadershipError, "cfg.val1.val6")
     #
     #default calculation has greater length
-    #raises(SlaveError, "api.option('val1.val1').value.set(['val1']")
+    #raises(LeadershipError, "api.option('val1.val1').value.set(['val1']")
     #
     api.option('val1.val1').value.set(['val1', 'val2'])
     assert api.option('val1.val1').value.get() == ['val1', 'val2']
@@ -968,10 +948,10 @@ def test_callback_master_and_slaves_value():
     assert api.option('val1.val2', 1).value.get() == 'val2'
     assert api.option('val1.val3', 0).value.get() == 'yes'
     assert api.option('val1.val3', 1).value.get() == 'yes'
-    raises(SlaveError, "api.option('val1.val5', 0).value.get()")
-    raises(SlaveError, "api.option('val1.val5', 1).value.get()")
-    raises(SlaveError, "api.option('val1.val6', 0).value.get()")
-    raises(SlaveError, "api.option('val1.val6', 1).value.get()")
+    raises(LeadershipError, "api.option('val1.val5', 0).value.get()")
+    raises(LeadershipError, "api.option('val1.val5', 1).value.get()")
+    raises(LeadershipError, "api.option('val1.val6', 0).value.get()")
+    raises(LeadershipError, "api.option('val1.val6', 1).value.get()")
     #
     api.option('val1.val1').value.set(['val1', 'val2', 'val3'])
     assert api.option('val1.val1').value.get() == ['val1', 'val2', 'val3']
@@ -981,8 +961,8 @@ def test_callback_master_and_slaves_value():
     assert api.option('val1.val3', 0).value.get() == 'yes'
     assert api.option('val1.val3', 1).value.get() == 'yes'
     assert api.option('val1.val3', 2).value.get() == 'yes'
-    raises(SlaveError, "api.option('val1.val5', 2).value.get()")
-    raises(SlaveError, "api.option('val1.val6', 2).value.get()")
+    raises(LeadershipError, "api.option('val1.val5', 2).value.get()")
+    raises(LeadershipError, "api.option('val1.val6', 2).value.get()")
     #
     api.option('val1.val1').value.pop(2)
     assert api.option('val1.val1').value.get() == ['val1', 'val2']
@@ -1011,10 +991,10 @@ def test_callback_master_and_slaves_value():
     assert api.option('val1.val3', 2).value.get() == 'yes'
 
 
-def test_callback_master():
+def test_callback_leader():
     val2 = StrOption('val2', "", multi=True, callback=return_value)
     val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val2)))
-    raises(ValueError, "MasterSlaves('val1', '', [val1, val2])")
+    raises(ValueError, "Leadership('val1', '', [val1, val2])")
 
 
 def test_callback_different_type():
@@ -1022,8 +1002,7 @@ def test_callback_different_type():
     val_ = IntOption('val_', "", default=3)
     val1 = IntOption('val1', "", multi=True)
     val2 = IntOption('val2', "", multi=True, callback=return_calc, callback_params=Params((ParamOption(val), ParamOption(val1)), {'k': ParamOption(val_)}))
-    interface1 = MasterSlaves('val1', '', [val1, val2])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('val1', '', [val1, val2])
     maconfig = OptionDescription('rootconfig', '', [interface1, val, val_])
     api = Config(maconfig)
     api.property.read_write()
@@ -1181,11 +1160,10 @@ def test_callback_multi_list_params_key():
     assert api.option('val2.val2').value.get() == ['val', 'val']
 
 
-def test_masterslaves_callback_description():
+def test_leadership_callback_description():
     st1 = StrOption('st1', "", multi=True)
     st2 = StrOption('st2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(st1)))
-    stm = MasterSlaves('st1', '', [st1, st2])
-    #stm.impl_set_group_type(groups.master)
+    stm = Leadership('st1', '', [st1, st2])
     st = OptionDescription('st', '', [stm])
     od = OptionDescription('od', '', [st])
     od2 = OptionDescription('od', '', [od])
diff --git a/test/test_option_consistency.py b/test/test_option_consistency.py
index 32e7cd0..cfee716 100644
--- a/test/test_option_consistency.py
+++ b/test/test_option_consistency.py
@@ -5,7 +5,7 @@ from py.test import raises
 
 from tiramisu.setting import owners, groups
 from tiramisu import IPOption, NetworkOption, NetmaskOption, IntOption,\
-    BroadcastOption, StrOption, SymLinkOption, OptionDescription, submulti, MasterSlaves,\
+    BroadcastOption, StrOption, SymLinkOption, OptionDescription, submulti, Leadership,\
     Config, undefined, Params, ParamOption
 from tiramisu.error import ConfigError, ValueWarning, PropertiesOptionError
 from tiramisu.api import TIRAMISU_VERSION
@@ -264,7 +264,7 @@ def test_consistency_mix():
     b = IntOption('b', '', multi=True)
     c = IntOption('c', '', multi=True)
     d = IntOption('d', '', multi=True)
-    od = MasterSlaves('c', '', [c, d])
+    od = Leadership('c', '', [c, d])
     od2 = OptionDescription('a', '', [b, od])
     c.impl_add_consistency('not_equal', b, d)
     cfg = Config(od2)
@@ -295,10 +295,10 @@ def test_consistency_not_equal_default_submulti():
     raises(ConfigError, "a.impl_add_consistency('not_equal', b)")
 
 
-def test_consistency_not_equal_masterslave():
+def test_consistency_not_equal_leadership():
     a = IntOption('a', '', multi=True)
     b = IntOption('b', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     od2 = OptionDescription('b', '', [od])
     a.impl_add_consistency('not_equal', b)
     api = Config(od2)
@@ -313,27 +313,27 @@ def test_consistency_not_equal_masterslave():
     api.value.dict()
 
 
-def test_consistency_not_equal_masterslave_error_multi1():
+def test_consistency_not_equal_leadership_error_multi1():
     a = IPOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
     c = NetmaskOption('c', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     od2 = OptionDescription('b', '', [od, c])
     c.impl_add_consistency('ip_netmask', a)
     raises(ConfigError, "Config(od2)")
 
 
-def test_consistency_not_equal_masterslave_error_multi2():
+def test_consistency_not_equal_leadership_error_multi2():
     a = IPOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
     c = IPOption('c', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     od2 = OptionDescription('b', '', [od, c])
     b.impl_add_consistency('ip_netmask', c)
     raises(ConfigError, "Config(od2)")
 
 
-def test_consistency_ip_netmask_masterslave_error_not_master():
+def test_consistency_ip_netmask_leadership_error_not_leader():
     a = IPOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
     od = OptionDescription('a', '', [a, b])
@@ -342,34 +342,34 @@ def test_consistency_ip_netmask_masterslave_error_not_master():
     raises(ConfigError, "Config(od2)")
 
 
-def test_consistency_ip_netmask_masterslave_error_master_and_not():
+def test_consistency_ip_netmask_leadership_error_leader_and_not():
     a = IPOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
     c = IPOption('c', '', multi=True)
     d = NetmaskOption('d', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     od2 = OptionDescription('c', '', [c, d])
     od3 = OptionDescription('b', '', [od, od2])
     d.impl_add_consistency('ip_netmask', a)
     raises(ConfigError, "Config(od3)")
 
 
-def test_consistency_ip_netmask_masterslave_error_othermaster():
+def test_consistency_ip_netmask_leadership_error_otherleader():
     a = IPOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
     c = IPOption('c', '', multi=True)
     d = NetmaskOption('d', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
-    od2 = MasterSlaves('c', '', [c, d])
+    od = Leadership('a', '', [a, b])
+    od2 = Leadership('c', '', [c, d])
     od3 = OptionDescription('b', '', [od, od2])
     d.impl_add_consistency('ip_netmask', a)
     raises(ConfigError, "Config(od2)")
 
 
-def test_consistency_not_equal_masterslaves_default():
+def test_consistency_not_equal_leadership_default():
     a = IntOption('a', '', multi=True)
     b = IntOption('b', '', multi=True, default_multi=1)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     od2 = OptionDescription('a', '', [od])
     a.impl_add_consistency('not_equal', b)
     api = Config(od2)
@@ -423,10 +423,10 @@ def test_consistency_not_equal_multi_default2():
     a.impl_add_consistency('not_equal', b)
 
 
-def test_consistency_not_equal_master_default():
+def test_consistency_not_equal_leader_default():
     a = IntOption('a', '', multi=True, default=[2, 1])
     b = IntOption('b', '', multi=True, default_multi=1)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     a.impl_add_consistency('not_equal', b)
     od2 = OptionDescription('a', '', [od])
     api = Config(od2)
@@ -586,7 +586,7 @@ def test_consistency_ip_netmask_error_multi():
 def test_consistency_ip_netmask_multi():
     a = IPOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     b.impl_add_consistency('ip_netmask', a)
     od2 = OptionDescription('od2', '', [od])
     api = Config(od2)
@@ -606,7 +606,7 @@ def test_consistency_ip_netmask_multi():
 def test_consistency_network_netmask_multi():
     a = NetworkOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     b.impl_add_consistency('network_netmask', a)
     od2 = OptionDescription('od', '', [od])
     api = Config(od2)
@@ -618,10 +618,10 @@ def test_consistency_network_netmask_multi():
     raises(ValueError, "api.option('a.a').value.set(['192.168.1.1'])")
 
 
-def test_consistency_network_netmask_multi_slave_default_multi():
+def test_consistency_network_netmask_multi_follower_default_multi():
     a = NetworkOption('a', '', default_multi=u'192.168.1.0', multi=True, properties=('mandatory',))
     b = NetmaskOption('b', '', default_multi=u'255.255.255.0', multi=True, properties=('mandatory',))
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     od2 = OptionDescription('od2', '', [od])
     b.impl_add_consistency('network_netmask', a)
     api = Config(od2)
@@ -631,10 +631,10 @@ def test_consistency_network_netmask_multi_slave_default_multi():
     assert api.option('a.b', 0).value.get() == '255.255.255.0'
 
 
-def test_consistency_network_netmask_multi_slave_default():
+def test_consistency_network_netmask_multi_follower_default():
     a = NetworkOption('a', '', multi=True, properties=('mandatory',))
     b = NetmaskOption('b', '', default_multi=u'255.255.255.0', multi=True, properties=('mandatory',))
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     b.impl_add_consistency('network_netmask', a)
     od2 = OptionDescription('od2', '', [od])
     api = Config(od2)
@@ -657,19 +657,19 @@ def return_netmask(*args, **kwargs):
     return u'255.255.255.0'
 
 
-def return_netmask2(master):
-    if master is not None:
-        if master.endswith('2.1'):
+def return_netmask2(leader):
+    if leader is not None:
+        if leader.endswith('2.1'):
             return u'255.255.255.0'
-        if not master.endswith('.0'):
+        if not leader.endswith('.0'):
             return u'255.255.255.255'
     return u'255.255.255.0'
 
 
-def test_consistency_network_netmask_multi_slave_callback():
+def test_consistency_network_netmask_multi_follower_callback():
     a = NetworkOption('a', '', multi=True, properties=('mandatory',))
     b = NetmaskOption('b', '', callback=return_netmask, multi=True, properties=('mandatory',))
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     b.impl_add_consistency('network_netmask', a)
     od2 = OptionDescription('od2', '', [od])
     api = Config(od2)
@@ -688,10 +688,10 @@ def test_consistency_network_netmask_multi_slave_callback():
     api.option('a.a').value.set(['192.168.1.0', '192.168.1.1'])
 
 
-def test_consistency_network_netmask_multi_slave_callback_value():
+def test_consistency_network_netmask_multi_follower_callback_value():
     a = NetworkOption('a', '', multi=True, properties=('mandatory',))
     b = NetmaskOption('b', '', callback=return_netmask2, callback_params=Params(ParamOption(a)), multi=True, properties=('mandatory',))
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     b.impl_add_consistency('network_netmask', a)
     od2 = OptionDescription('od2', '', [od])
     api = Config(od2)
@@ -712,10 +712,10 @@ def test_consistency_network_netmask_multi_slave_callback_value():
     api.option('a.b', 1).value.set('255.255.255.255')
 
 
-def test_consistency_ip_netmask_multi_master():
+def test_consistency_ip_netmask_multi_leader():
     a = IPOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     b.impl_add_consistency('ip_netmask', a)
     od2 = OptionDescription('od2', '', [od])
     api = Config(od2)
@@ -730,10 +730,10 @@ def test_consistency_ip_netmask_multi_master():
     api.option('a.a').value.set(['192.168.1.2', '192.168.1.3'])
 
 
-def test_consistency_network_netmask_multi_master():
+def test_consistency_network_netmask_multi_leader():
     a = NetworkOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     b.impl_add_consistency('network_netmask', a)
     od2 = OptionDescription('od2', '', [od])
     api = Config(od2)
@@ -749,7 +749,7 @@ def test_consistency_broadcast():
     a = NetworkOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
     c = BroadcastOption('c', '', multi=True)
-    od = MasterSlaves('a', '', [a, b, c])
+    od = Leadership('a', '', [a, b, c])
     b.impl_add_consistency('network_netmask', a)
     c.impl_add_consistency('broadcast', a, b)
     od2 = OptionDescription('od2', '', [od])
@@ -776,7 +776,7 @@ def test_consistency_broadcast_error():
     a = NetworkOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
     c = BroadcastOption('c', '', multi=True)
-    od = MasterSlaves('a', '', [a, b, c])
+    od = Leadership('a', '', [a, b, c])
     od2 = OptionDescription('od2', '', [od])
     b.impl_add_consistency('network_netmask', a)
     c.impl_add_consistency('broadcast', a)
@@ -825,7 +825,7 @@ def test_consistency_not_all():
     a = NetworkOption('a', '', multi=True)
     b = NetmaskOption('b', '', multi=True)
     c = BroadcastOption('c', '', multi=True)
-    od = MasterSlaves('a', '', [a, b, c])
+    od = Leadership('a', '', [a, b, c])
     b.impl_add_consistency('network_netmask', a)
     od2 = OptionDescription('od2', '', [od])
     api = Config(od2)
@@ -991,7 +991,7 @@ def test_consistency_warnings_error():
 def test_consistency_network_netmask_mandatory():
     a = NetworkOption('a', '', multi=True, properties=('mandatory',), default=[u'0.0.0.0'])
     b = NetmaskOption('b', '', multi=True, properties=('mandatory',), default_multi=u'0.0.0.0')
-    od = MasterSlaves('a', '', [a, b])
+    od = Leadership('a', '', [a, b])
     b.impl_add_consistency('network_netmask', a)
     od2 = OptionDescription('od2', '', [od])
     api = Config(od2)
diff --git a/test/test_option_default.py b/test/test_option_default.py
index 72fd0f8..31923be 100644
--- a/test/test_option_default.py
+++ b/test/test_option_default.py
@@ -7,7 +7,7 @@ from py.test import raises
 from tiramisu.setting import owners
 from tiramisu.error import PropertiesOptionError, ConfigError
 from tiramisu import IntOption, FloatOption, StrOption, ChoiceOption, \
-    BoolOption, OptionDescription, MasterSlaves, Config, undefined
+    BoolOption, OptionDescription, Leadership, Config, undefined
 from tiramisu.storage import list_sessions
 
 
@@ -112,31 +112,31 @@ def test_force_default_on_freeze_multi():
     api.option('dummy1').property.add('frozen')
 
 
-def test_force_default_on_freeze_master():
+def test_force_default_on_freeze_leader():
     dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_default_on_freeze',))
     dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
-    descr = MasterSlaves("dummy1", "", [dummy1, dummy2])
+    descr = Leadership("dummy1", "", [dummy1, dummy2])
     descr = OptionDescription("root", "", [descr])
     raises(ConfigError, "Config(descr)")
 
 
-def test_force_default_on_freeze_master_frozen():
+def test_force_default_on_freeze_leader_frozen():
     dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_default_on_freeze', 'frozen'))
     dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
-    descr = MasterSlaves("dummy1", "", [dummy1, dummy2])
+    descr = Leadership("dummy1", "", [dummy1, dummy2])
     descr = OptionDescription("root", "", [descr])
     api = Config(descr)
     raises(ConfigError, "api.option('dummy1.dummy1').property.pop('frozen')")
 
 
-def test_force_default_on_freeze_slave():
+def test_force_default_on_freeze_follower():
     dummy1 = BoolOption('dummy1', 'Test int option', multi=True)
     dummy2 = BoolOption('dummy2', 'Test string option', multi=True, properties=('force_default_on_freeze',))
-    descr = MasterSlaves("dummy1", "", [dummy1, dummy2])
+    descr = Leadership("dummy1", "", [dummy1, dummy2])
     descr = OptionDescription("root", "", [descr])
     api = Config(descr)
     api.property.read_write()
-    owners.addowner("frozenmultislave2")
+    owners.addowner("frozenmultifollower2")
     api.option('dummy1.dummy1').value.set([True])
     api.option('dummy1.dummy2', 0).value.set(False)
     assert api.option('dummy1.dummy1').value.get() == [True]
@@ -149,7 +149,7 @@ def test_force_default_on_freeze_slave():
     assert api.option('dummy1.dummy2', 0).value.get() == None
     assert api.option('dummy1.dummy1').owner.get() == 'user'
     assert api.option('dummy1.dummy2', 0).owner.isdefault()
-    raises(PropertiesOptionError, "api.option('dummy1.dummy2', 0).owner.set('frozenmultislave2')")
+    raises(PropertiesOptionError, "api.option('dummy1.dummy2', 0).owner.set('frozenmultifollower2')")
     #
     api.option('dummy1.dummy2').property.pop('frozen')
     api.option('dummy1.dummy1').value.set([True, True])
diff --git a/test/test_option_owner.py b/test/test_option_owner.py
index 33ff5a7..90f4dd6 100644
--- a/test/test_option_owner.py
+++ b/test/test_option_owner.py
@@ -5,7 +5,7 @@ from py.test import raises
 
 from tiramisu.setting import owners, groups
 from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
-    StrOption, OptionDescription, SymLinkOption, MasterSlaves, Config
+    StrOption, OptionDescription, SymLinkOption, Leadership, Config
 from tiramisu.error import ConfigError, ConstError, PropertiesOptionError, APIError
 from tiramisu.storage import list_sessions
 
@@ -165,10 +165,10 @@ def test_setowner_symlinkoption():
     raises(ConfigError, "api.option('tiramisu.symdummy').owner.set('user')")
 
 
-def test_owner_masterslaves():
+def test_owner_leadership():
     b = IntOption('int', 'Test int option', default=[0], multi=True)
     c = StrOption('str', 'Test string option', multi=True)
-    descr = MasterSlaves("int", "", [b, c])
+    descr = Leadership("int", "", [b, c])
     od = OptionDescription('od', '', [descr])
     api = Config(od)
     raises(ConfigError, "api.option('int.str', 0).owner.set('user')")
diff --git a/test/test_option_setting.py b/test/test_option_setting.py
index 7105e2d..510af2c 100644
--- a/test/test_option_setting.py
+++ b/test/test_option_setting.py
@@ -8,7 +8,7 @@ from tiramisu.i18n import _
 from tiramisu.error import display_list, ConfigError
 from tiramisu.setting import owners, groups
 from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
-    StrOption, OptionDescription, MasterSlaves, Config, undefined
+    StrOption, OptionDescription, Leadership, Config, undefined
 from tiramisu.error import PropertiesOptionError
 from tiramisu.storage import list_sessions
 
@@ -335,25 +335,25 @@ def test_multi_with_requires_that_is_multi_inverse():
     raises(ValueError, "Config(descr)")
 
 
-def test_multi_with_requires_that_is_masterslave():
+def test_multi_with_requires_that_is_leadership():
     b = IntOption('int', 'Test int option', default=[0], multi=True)
     c = StrOption('str', 'Test string option', requires=[{'option': b, 'expected': 1, 'action': 'hidden'}], multi=True)
-    descr = MasterSlaves("int", "", [b, c])
+    descr = Leadership("int", "", [b, c])
     od = OptionDescription('root', '', [descr])
     Config(od)
 
 
-def test_multi_with_requires_that_is_masterslave_master():
+def test_multi_with_requires_that_is_leadership_leader():
     b = IntOption('int', 'Test int option', multi=True)
     c = StrOption('str', 'Test string option', requires=[{'option': b, 'expected': 1, 'action': 'hidden'}], multi=True)
-    raises(ValueError, "MasterSlaves('str', '', [c, b])")
+    raises(ValueError, "Leadership('str', '', [c, b])")
 
 
-def test_multi_with_requires_that_is_masterslave_slave():
+def test_multi_with_requires_that_is_leadership_follower():
     b = IntOption('int', 'Test int option', default=[0], multi=True)
     c = StrOption('str', 'Test string option', multi=True)
     d = StrOption('str1', 'Test string option', requires=[{'option': c, 'expected': '1', 'action': 'hidden'}], multi=True)
-    descr = MasterSlaves("int", "", [b, c, d])
+    descr = Leadership("int", "", [b, c, d])
     descr2 = OptionDescription('od', '', [descr])
     api = Config(descr2)
     api.property.read_write()
@@ -375,11 +375,11 @@ def test_multi_with_requires_that_is_masterslave_slave():
     raises(PropertiesOptionError, "api.option('int.str1', 1).value.get()")
 
 
-def test_multi_with_requires_that_is_masterslave_slave_inverse():
+def test_multi_with_requires_that_is_leadership_follower_inverse():
     b = IntOption('int', 'Test int option', default=[0], multi=True)
     c = StrOption('str', 'Test string option', multi=True)
     d = StrOption('str1', 'Test string option', requires=[{'option': c, 'expected': None, 'action': 'hidden', 'inverse': True}], multi=True)
-    descr = MasterSlaves("int", "", [b, c, d])
+    descr = Leadership("int", "", [b, c, d])
     descr2 = OptionDescription('od', '', [descr])
     api = Config(descr2)
     api.property.read_write()
@@ -401,15 +401,13 @@ def test_multi_with_requires_that_is_masterslave_slave_inverse():
     raises(PropertiesOptionError, "api.option('int.str1', 1).value.get()")
 
 
-def test_multi_with_requires_that_is_not_same_masterslave():
+def test_multi_with_requires_that_is_not_same_leadership():
     b = IntOption('int', 'Test int option', default=[0], multi=True)
     c = StrOption('str', 'Test string option', requires=[{'option': b, 'expected': 1, 'action': 'hidden'}], multi=True)
-    descr1 = MasterSlaves("int", "", [b, c])
-    #descr1.impl_set_group_type(groups.master)
+    descr1 = Leadership("int", "", [b, c])
     d = IntOption('int1', 'Test int option', default=[0], multi=True)
     e = StrOption('str', 'Test string option', requires=[{'option': b, 'expected': 1, 'action': 'hidden'}], multi=True)
-    descr2 = MasterSlaves("int1", "", [d, e])
-    #descr2.impl_set_group_type(groups.master)
+    descr2 = Leadership("int1", "", [d, e])
     descr3 = OptionDescription('val', '', [descr1, descr2])
     descr3
     raises(ValueError, "Config(descr3)")
diff --git a/test/test_option_validator.py b/test/test_option_validator.py
index 75909f7..6d5e47c 100644
--- a/test/test_option_validator.py
+++ b/test/test_option_validator.py
@@ -4,7 +4,7 @@ do_autopath()
 import warnings
 from py.test import raises
 
-from tiramisu import BoolOption, StrOption, OptionDescription, MasterSlaves, Config, Params, ParamValue, ParamOption, ParamContext
+from tiramisu import BoolOption, StrOption, OptionDescription, Leadership, Config, Params, ParamValue, ParamOption, ParamContext
 from tiramisu.setting import groups
 from tiramisu.error import ValueWarning, ConfigError
 from tiramisu.i18n import _
@@ -153,33 +153,30 @@ def test_validator_params_value_values_index():
     api.option('opt1').value.set(['val1', 'val2'])
 
 
-def test_validator_params_value_values_master():
+def test_validator_params_value_values_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip reseau autorise", multi=True, validator=value_values)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-reseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
 
 
-def test_validator_params_value_values_index_master():
+def test_validator_params_value_values_index_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip reseau autorise", multi=True, validator=value_values_index)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-reseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
 
 
-def test_validator_params_value_values_slave():
+def test_validator_params_value_values_follower():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip reseau autorise", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-reseau", multi=True, validator=value_values)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
@@ -189,11 +186,10 @@ def test_validator_params_value_values_slave():
     api.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('val2')
 
 
-def test_validator_params_value_values_index_slave():
+def test_validator_params_value_values_index_follower():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip reseau autorise", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-reseau", multi=True, validator=value_values_index)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
@@ -215,8 +211,7 @@ def test_validator_params_value_values_kwargs_empty():
                                    multi=True,
                                    validator=value_empty,
                                    validator_params=Params(ParamOption(v)))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [v, interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
@@ -233,8 +228,7 @@ def test_validator_params_value_values_kwargs():
                                    multi=True,
                                    validator=value_values_auto,
                                    validator_params=Params(kwargs={'auto': ParamOption(v)}))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [v, interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
@@ -250,8 +244,7 @@ def test_validator_params_value_values_kwargs_values():
                                    multi=True,
                                    validator=value_values_auto2,
                                    validator_params=Params(kwargs={'values': ParamOption(ip_admin_eth0)}))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
@@ -268,8 +261,7 @@ def test_validator_params_value_values_kwargs2():
                                    multi=True,
                                    validator=value_values_index2,
                                    validator_params=Params(ParamValue(['val1']), {'index': ParamOption(ip_admin_eth0)}))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
@@ -285,8 +277,7 @@ def test_validator_params_value_values_kwargs_index():
                                    multi=True,
                                    validator=value_values_index2,
                                    validator_params=Params(kwargs={'index': ParamOption(ip_admin_eth0)}))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
@@ -439,14 +430,13 @@ def test_validator_warning_disabled():
     assert len(w) == 1
 
 
-def test_validator_warning_master_slave():
+def test_validator_warning_leadership():
     display_name_ip = "ip reseau autorise"
     display_name_netmask = "masque du sous-reseau"
     ip_admin_eth0 = StrOption('ip_admin_eth0', display_name_ip, multi=True, validator=return_false, warnings_only=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', display_name_netmask, multi=True, validator=return_if_val, warnings_only=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
-    assert interface1.impl_get_group_type() == groups.master
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    assert interface1.impl_get_group_type() == groups.leadership
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     warnings.simplefilter("always", ValueWarning)
@@ -489,15 +479,14 @@ def test_validator_warning_master_slave():
     assert str(w[0].message) == msg_err.format('val', ip_admin_eth0._display_name, display_name_ip, 'test error return_false')
 
 
-def test_validator_slave_param():
+def test_validator_follower_param():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip reseau autorise", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0',
                                    "masque du sous-reseau",
                                    multi=True,
                                    validator=return_true,
                                    validator_params=Params(kwargs={'param': ParamOption(ip_admin_eth0)}))
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     root = OptionDescription('root', '', [interface1])
     api = Config(root)
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
diff --git a/test/test_requires.py b/test/test_requires.py
index 47192b7..d0b1f41 100644
--- a/test/test_requires.py
+++ b/test/test_requires.py
@@ -8,7 +8,7 @@ from tiramisu.setting import groups
 from tiramisu import setting
 setting.expires_time = 1
 from tiramisu import IPOption, OptionDescription, BoolOption, IntOption, StrOption, \
-                     MasterSlaves, Config
+                     Leadership, Config
 from tiramisu.error import PropertiesOptionError, RequirementError
 from py.test import raises
 from tiramisu.storage import list_sessions, delete_session
@@ -956,11 +956,11 @@ def test_properties_conflict():
     raises(ValueError, "od1 = OptionDescription('service', '', [a], properties=('disabled',), requires=[{'option': a, 'expected': False, 'action': 'disabled'}])")
 
 
-def test_master_slave_requires():
+def test_leadership_requires():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
                                    requires=[{'option': ip_admin_eth0, 'expected': '192.168.1.1', 'action': 'disabled'}])
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -1006,46 +1006,46 @@ def test_master_slave_requires():
     del ret['ip_admin_eth0.netmask_admin_eth0']
 
 
-def test_master_slave_requires_both():
+def test_leadership_requires_both():
     ip_admin = StrOption('ip_admin_eth0', "ip réseau autorisé")
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
                               requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    raises(RequirementError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])")
+    raises(RequirementError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])")
 
 
-def test_master_slave_requires_properties_invalid():
+def test_leadership_requires_properties_invalid():
     ip_admin = StrOption('ip_admin', "ip réseau autorisé")
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
                                    requires=[{'option': ip_admin_eth0, 'expected': '192.168.1.1', 'action': 'disabled'}])
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=('disabled',), requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=('disabled',), requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])")
 
 
-def test_master_slave_requires_properties_invalid_2():
+def test_leadership_requires_properties_invalid_2():
     ip_admin = StrOption('ip_admin', "ip réseau autorisé")
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
                               requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
                                    requires=[{'option': ip_admin_eth0, 'expected': '192.168.1.1', 'action': 'disabled'}])
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=('disabled',))")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=('disabled',))")
 
 
-def test_master_slave_requires_properties():
+def test_leadership_requires_properties():
     ip_admin = StrOption('ip_admin', "ip réseau autorisé")
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
                                    requires=[{'option': ip_admin_eth0, 'expected': '192.168.1.1', 'action': 'disabled'}])
-    MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=('hidden',),
+    Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=('hidden',),
                  requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])
 
 
-def test_master_slave_requires_master():
+def test_leadership_requires_leader():
     activate = BoolOption('activate', "Activer l'accès au réseau", True)
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
                               requires=[{'option': activate, 'expected': False, 'action': 'disabled'}])
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [activate, interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -1068,11 +1068,11 @@ def test_master_slave_requires_master():
     assert api.value.dict() == {'activate': False}
 
 
-def test_master_slave_requires_masterslaves():
+def test_leadership_requires_leadership():
     activate = BoolOption('activate', "Activer l'accès au réseau", True)
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0],
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0],
                               requires=[{'option': activate, 'expected': False, 'action': 'disabled'}])
     maconfig = OptionDescription('toto', '', [activate, interface1])
     api = Config(maconfig)
@@ -1096,13 +1096,12 @@ def test_master_slave_requires_masterslaves():
     assert api.value.dict() == {'activate': False}
 
 
-def test_master_slave_requires_no_master():
+def test_leadership_requires_no_leader():
     activate = BoolOption('activate', "Activer l'accès au réseau", True)
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
                                    requires=[{'option': activate, 'expected': False, 'action': 'disabled'}])
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [activate, interface1])
     api = Config(maconfig)
     api.property.read_write()
diff --git a/test/test_state.py b/test/test_state.py
index 231b768..460bcb4 100644
--- a/test/test_state.py
+++ b/test/test_state.py
@@ -109,10 +109,10 @@ def _diff_opt(opt1, opt2):
                                         assert v[1][key][i] == val2[idx][1][key][i]
                         else:
                             assert v[1] == val2[idx][1]
-        elif attr == '_master_slaves':
-            assert val1._p_._sm_getmaster().impl_getname() == val2._p_._sm_getmaster().impl_getname()
-            sval1 = [opt.impl_getname() for opt in val1._p_._sm_getslaves()]
-            sval2 = [opt.impl_getname() for opt in val2._p_._sm_getslaves()]
+        elif attr == '_leadership':
+            assert val1._p_._sm_get_leader().impl_getname() == val2._p_._sm_get_leader().impl_getname()
+            sval1 = [opt.impl_getname() for opt in val1._p_._sm_get_followers()]
+            sval2 = [opt.impl_getname() for opt in val2._p_._sm_get_followers()]
             assert sval1 == sval2
         elif attr == '_subdyn':
             try:
@@ -124,13 +124,13 @@ def _diff_opt(opt1, opt2):
             lst1 = []
             lst2 = []
             for idx, val in enumerate(val1):
-                if isinstance(val, MasterSlaves):
-                    lst1.append(val._p_.master.impl_getname())
+                if isinstance(val, Leadership):
+                    lst1.append(val._p_.leader.impl_getname())
                 else:
                     lst1.append(val.impl_getname())
             for idx, val in enumerate(val2):
-                if isinstance(val, MasterSlaves):
-                    lst2.append(val._p_.master.impl_getname())
+                if isinstance(val, Leadership):
+                    lst2.append(val._p_.leader.impl_getname())
                 else:
                     lst2.append(val.impl_getname())
             assert set(lst1) == set(lst2), '{} - {}'.format(lst1, lst2)
diff --git a/test/test_storage.py b/test/test_storage.py
index 5c8c4cc..fd4b8d1 100644
--- a/test/test_storage.py
+++ b/test/test_storage.py
@@ -6,7 +6,7 @@ from py.test import raises
 
 from tiramisu.error import ConfigError
 from tiramisu import Config
-from tiramisu.option import BoolOption, OptionDescription, MasterSlaves
+from tiramisu.option import BoolOption, OptionDescription, Leadership
 from tiramisu.setting import groups, owners
 from tiramisu.storage import list_sessions, delete_session
 
@@ -174,11 +174,10 @@ def test_create_persistent_retrieve_owner():
         del c
 
 
-def test_create_persistent_retrieve_owner_masterslaves():
+def test_create_persistent_retrieve_owner_leadership():
     a = BoolOption('a', '', multi=True)
     b = BoolOption('b', '', multi=True)
-    o = MasterSlaves('a', '', [a, b])
-    #o.impl_set_group_type(groups.master)
+    o = Leadership('a', '', [a, b])
     o1 = OptionDescription('a', '', [o])
     try:
         c = Config(o1, session_id='test_persistent', persistent=True)
diff --git a/test/test_submulti.py b/test/test_submulti.py
index f0cb4a7..e60bbea 100644
--- a/test/test_submulti.py
+++ b/test/test_submulti.py
@@ -6,9 +6,9 @@ from py.test import raises
 
 from tiramisu.api import TIRAMISU_VERSION
 from tiramisu.setting import groups, owners
-from tiramisu import StrOption, IntOption, OptionDescription, submulti, MasterSlaves, Config, \
+from tiramisu import StrOption, IntOption, OptionDescription, submulti, Leadership, Config, \
                      MetaConfig, undefined, Params, ParamOption
-from tiramisu.error import SlaveError
+from tiramisu.error import LeadershipError
 from tiramisu.storage import list_sessions
 
 
@@ -199,33 +199,31 @@ def test_callback_submulti_list_list():
     assert api.option('multi').owner.get() == owners.default
 
 
-def test_groups_with_master_submulti():
+def test_groups_with_leader_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
-    assert interface1.impl_get_group_type() == groups.master
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    assert interface1.impl_get_group_type() == groups.leadership
 
 
-def test_groups_with_master_in_config_submulti():
+def test_groups_with_leader_in_config_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     od = OptionDescription('root', '', [interface1])
     Config(od)
-    assert interface1.impl_get_group_type() == groups.master
+    assert interface1.impl_get_group_type() == groups.leadership
 
 
-def test_values_with_master_and_slaves_submulti():
+def test_values_with_leader_and_followers_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
     owner = api.owner.get()
-    assert interface1.impl_get_group_type() == groups.master
+    assert interface1.impl_get_group_type() == groups.leadership
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == ["192.168.230.145"]
@@ -242,16 +240,15 @@ def test_values_with_master_and_slaves_submulti():
     raises(ValueError, "api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set([['255.255.255.0']])")
 
 
-def test_reset_values_with_master_and_slaves_submulti():
+def test_reset_values_with_leader_and_followers_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
     owner = api.owner.get()
-    assert interface1.impl_get_group_type() == groups.master
+    assert interface1.impl_get_group_type() == groups.leadership
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
@@ -269,15 +266,14 @@ def test_reset_values_with_master_and_slaves_submulti():
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
 
 
-def test_values_with_master_and_slaves_slave_submulti():
+def test_values_with_leader_and_followers_follower_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
-    raises(SlaveError, "api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])")
+    raises(LeadershipError, "api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])")
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
     api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
     api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0', '255.255.255.0'])
@@ -289,11 +285,10 @@ def test_values_with_master_and_slaves_slave_submulti():
     api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
 
 
-def test_values_with_master_and_slaves_master_submulti():
+def test_values_with_leader_and_leadership_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -310,11 +305,10 @@ def test_values_with_master_and_slaves_master_submulti():
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
 
 
-def test_values_with_master_owner_submulti():
+def test_values_with_leader_owner_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -327,10 +321,10 @@ def test_values_with_master_owner_submulti():
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
 
 
-def test_values_with_master_disabled_submulti():
+def test_values_with_leader_disabled_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
@@ -352,16 +346,15 @@ def test_values_with_master_disabled_submulti():
     api.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
 
 
-def test__master_is_submulti():
+def test_leader_is_submulti():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=submulti)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    #interface1.impl_set_group_type(groups.master)
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
     maconfig = OptionDescription('toto', '', [interface1])
     api = Config(maconfig)
     api.property.read_write()
     owner = api.owner.get()
-    assert interface1.impl_get_group_type() == groups.master
+    assert interface1.impl_get_group_type() == groups.leadership
     assert api.option('ip_admin_eth0.ip_admin_eth0').owner.isdefault()
     api.option('ip_admin_eth0.ip_admin_eth0').value.set([["192.168.230.145"]])
     assert api.option('ip_admin_eth0.ip_admin_eth0').value.get() == [["192.168.230.145"]]
diff --git a/test/test_symlink.py b/test/test_symlink.py
index e2b412a..e708671 100644
--- a/test/test_symlink.py
+++ b/test/test_symlink.py
@@ -4,7 +4,7 @@ from .autopath import do_autopath
 do_autopath()
 
 from tiramisu import BoolOption, StrOption, SymLinkOption, \
-    OptionDescription, MasterSlaves, Config
+    OptionDescription, Leadership, Config
 from tiramisu.error import PropertiesOptionError, ConfigError
 from tiramisu.setting import groups, owners
 from tiramisu.api import TIRAMISU_VERSION
@@ -210,55 +210,55 @@ def test_symlink_get_information():
     assert linkopt.impl_get_information('test') == 'test2'
 
 
-def test_symlink_master():
+def test_symlink_leader():
     a = StrOption('a', "", multi=True)
     ip_admin_eth0 = SymLinkOption('ip_admin_eth0', a)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "", multi=True)
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
 
 
-def test_symlink_slaves():
+def test_symlink_followers():
     a = StrOption('a', "", multi=True)
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = SymLinkOption('netmask_admin_eth0', a)
-    raises(ValueError, "MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
+    raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])")
 
 
-def test_symlink_with_master():
+def test_symlink_with_leader():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    master = SymLinkOption('master', ip_admin_eth0)
-    od = OptionDescription('root', '', [interface1, master])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    leader = SymLinkOption('leader', ip_admin_eth0)
+    od = OptionDescription('root', '', [interface1, leader])
     api = Config(od)
-    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'master': []}
+    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'leader': []}
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
-    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'master': ['val1', 'val2']}
+    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'leader': ['val1', 'val2']}
 
 
-def test_symlink_with_slave():
+def test_symlink_with_follower():
     ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
     netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
-    interface1 = MasterSlaves('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
-    slave = SymLinkOption('slave', netmask_admin_eth0)
-    od = OptionDescription('root', '', [interface1, slave])
+    interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
+    follower = SymLinkOption('follower', netmask_admin_eth0)
+    od = OptionDescription('root', '', [interface1, follower])
     api = Config(od)
-    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'slave': []}
+    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'follower': []}
     api.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
-    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'slave': [None, None]}
+    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'follower': [None, None]}
     #
     assert api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
     assert api.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == None
-    assert api.option('slave', 0).value.get() == None
-    assert api.option('slave', 1).value.get() == None
+    assert api.option('follower', 0).value.get() == None
+    assert api.option('follower', 1).value.get() == None
     #
     api.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('val3')
-    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, 'val3'], 'slave': [None, 'val3']}
+    assert api.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, 'val3'], 'follower': [None, 'val3']}
     #
     assert api.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
     assert api.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == 'val3'
-    assert api.option('slave', 0).value.get() == None
-    assert api.option('slave', 1).value.get() == 'val3'
+    assert api.option('follower', 0).value.get() == None
+    assert api.option('follower', 1).value.get() == 'val3'
 
 
 #____________________________________________________________
diff --git a/tiramisu/api.py b/tiramisu/api.py
index 3c979c6..9a58c5d 100644
--- a/tiramisu/api.py
+++ b/tiramisu/api.py
@@ -19,7 +19,7 @@ from time import time
 from typing import List, Set, Any, Optional, Callable, Union, Dict
 
 
-from .error import APIError, ConfigError, SlaveError, PropertiesOptionError
+from .error import APIError, ConfigError, LeadershipError, PropertiesOptionError
 from .i18n import _
 from .setting import ConfigBag, OptionBag, owners, groups, Undefined, undefined, \
                      FORBIDDEN_SET_PROPERTIES, SPECIAL_PROPERTIES
@@ -96,14 +96,14 @@ class CommonTiramisu(TiramisuHelp):
             self._option_bag = option_bag
             index = self._option_bag.index
             if index is not None:
-                if option.impl_is_optiondescription() or not option.impl_is_master_slaves('slave'):
-                    raise APIError('index must be set only with a slave option')
-                self._length = self._subconfig.cfgimpl_get_length_slave(self._option_bag)
+                if option.impl_is_optiondescription() or not option.impl_is_follower():
+                    raise APIError('index must be set only with a follower option')
+                self._length = self._subconfig.cfgimpl_get_length_leadership(self._option_bag)
                 if index >= self._length:
-                    raise SlaveError(_('index "{}" is higher than the master length "{}" '
-                                       'for option "{}"').format(index,
-                                                                 self._length,
-                                                                 option.impl_get_display_name()))
+                    raise LeadershipError(_('index "{}" is higher than the leadership length "{}" '
+                                            'for option "{}"').format(index,
+                                                                      self._length,
+                                                                      option.impl_get_display_name()))
             if not self._allow_optiondescription and option.impl_is_optiondescription():
                 raise APIError(_('option must not be an optiondescription'))
         return option
@@ -111,7 +111,7 @@ class CommonTiramisu(TiramisuHelp):
 
 class CommonTiramisuOption(CommonTiramisu):
     _allow_optiondescription = False
-    _slave_need_index = True
+    _follower_need_index = True
     _validate_properties = False
 
     def __init__(self,
@@ -124,15 +124,15 @@ class CommonTiramisuOption(CommonTiramisu):
         # for help()
         if option_bag is not None and self._option_bag.config_bag.context.impl_type != 'group':
             self._get_option()
-            if option_bag.config_bag is not None and self._slave_need_index:
-                self._test_slave_index()
+            if option_bag.config_bag is not None and self._follower_need_index:
+                self._test_follower_index()
 
-    def _test_slave_index(self) -> None:
+    def _test_follower_index(self) -> None:
         option = self._option_bag.option
         if not option.impl_is_optiondescription() and \
                 self._option_bag.index is None and \
-                option.impl_is_master_slaves('slave'):
-            raise APIError(_('index must be set with the slave option "{}"').format(self._option_bag.path))
+                option.impl_is_follower():
+            raise APIError(_('index must be set with the follower option "{}"').format(self._option_bag.path))
 
     def __getattr__(self, name):
         raise APIError(_('unknown method {}').format(name))
@@ -141,7 +141,7 @@ class CommonTiramisuOption(CommonTiramisu):
 class _TiramisuOptionOptionDescription(CommonTiramisuOption):
     """Manage option"""
     _allow_optiondescription = True
-    _slave_need_index = False
+    _follower_need_index = False
 
     def get(self):
         """Get Tiramisu option"""
@@ -154,10 +154,10 @@ class _TiramisuOptionOptionDescription(CommonTiramisuOption):
         type_ = type_.lower()
         return type_
 
-    def ismasterslaves(self):
-        """Test if option is a master or a slave"""
+    def isleadership(self):
+        """Test if option is a leader or a follower"""
         option = self._option_bag.option
-        return option.impl_is_master_slaves()
+        return option.impl_is_leadership()
 
     def doc(self):
         """Get option document"""
@@ -220,15 +220,15 @@ class _TiramisuOptionOption(_TiramisuOptionOptionDescription):
         option = self._option_bag.option
         return option.impl_is_submulti()
 
-    def ismaster(self):
-        """Test if option is a master"""
+    def isleader(self):
+        """Test if option is a leader"""
         option = self._option_bag.option
-        return option.impl_is_master_slaves('master')
+        return option.impl_is_leader()
 
-    def isslave(self):
-        """Test if option is a slave"""
+    def isfollower(self):
+        """Test if option is a follower"""
         option = self._option_bag.option
-        return option.impl_is_master_slaves('slave')
+        return option.impl_is_follower()
 
     def issymlinkoption(self) -> bool:
         option = self._option_bag.option
@@ -258,7 +258,7 @@ class _TiramisuOptionOption(_TiramisuOptionOptionDescription):
 class TiramisuOptionOption(CommonTiramisuOption):
     """Manage option"""
     _allow_optiondescription = True
-    _slave_need_index = False
+    _follower_need_index = False
 
     def __new__(cls,
                 name,
@@ -318,7 +318,7 @@ class TiramisuOptionOwner(CommonTiramisuOption):
 class TiramisuOptionProperty(CommonTiramisuOption):
     """Manage option's property"""
     _allow_optiondescription = True
-    _slave_need_index = False
+    _follower_need_index = False
 
     def __init__(self,
                  name: str,
@@ -334,7 +334,7 @@ class TiramisuOptionProperty(CommonTiramisuOption):
             only_raises=False):
         """Get properties for an option"""
         option = self._option_bag.option
-        self._test_slave_index()
+        self._test_follower_index()
         properties = self._option_bag.properties
         if not only_raises:
             return properties
@@ -376,7 +376,7 @@ class TiramisuOptionProperty(CommonTiramisuOption):
 class TiramisuOptionPermissive(CommonTiramisuOption):
     """Manage option's permissive"""
     _allow_optiondescription = True
-    _slave_need_index = False
+    _follower_need_index = False
 
     def __init__(self,
                  name: str,
@@ -407,7 +407,7 @@ class TiramisuOptionPermissive(CommonTiramisuOption):
 class TiramisuOptionInformation(CommonTiramisuOption):
     """Manage option's informations"""
     _allow_optiondescription = True
-    _slave_need_index = False
+    _follower_need_index = False
 
     def get(self, key, default=undefined):
         """Get information"""
@@ -443,14 +443,14 @@ class _TiramisuOptionValueOption:
     def get(self):
         """Get option's value"""
         option = self._option_bag.option
-        self._test_slave_index()
+        self._test_follower_index()
         return self._subconfig.getattr(self._name,
                                        self._option_bag)
 
     def set(self, value):
         """Change option's value"""
         option = self._option_bag.option
-        self._test_slave_index()
+        self._test_follower_index()
         values = self._option_bag.config_bag.context.cfgimpl_get_values()
         if isinstance(value, list):
             while undefined in value:
@@ -464,16 +464,16 @@ class _TiramisuOptionValueOption:
 
     def reset(self):
         """Reset value for an option"""
-        self._test_slave_index()
+        self._test_follower_index()
         self._subconfig.delattr(self._option_bag)
 
     def default(self):
         """Get default value (default of option or calculated value)"""
         option = self._option_bag.option
         values = self._option_bag.config_bag.context.cfgimpl_get_values()
-        if option.impl_is_master_slaves('slave') and self._option_bag.index is None:
+        if option.impl_is_follower() and self._option_bag.index is None:
             value = []
-            length = self._subconfig.cfgimpl_get_length_slave(self._option_bag)
+            length = self._subconfig.cfgimpl_get_length_leadership(self._option_bag)
             for idx in range(length):
                 soption_bag = OptionBag()
                 soption_bag.set_option(option,
@@ -485,16 +485,17 @@ class _TiramisuOptionValueOption:
             return values.getdefaultvalue(self._option_bag)
 
 
-class _TiramisuOptionValueMaster:
+class _TiramisuOptionValueLeader:
     def pop(self, index):
         """Pop a value"""
-        assert not self._option_bag.option.impl_is_symlinkoption(), _("can't delete a SymLinkOption")
-        self._option_bag.config_bag.context.cfgimpl_get_values().reset_master(index,
-                                                                             self._option_bag,
-                                                                             self._subconfig)
+        option_bag = self._option_bag
+        assert not option_bag.option.impl_is_symlinkoption(), _("can't delete a SymLinkOption")
+        option_bag.config_bag.context.cfgimpl_get_values().reset_leadership(index,
+                                                                            option_bag,
+                                                                            self._subconfig)
 
     def len(self):
-        """Length of master option"""
+        """Length of leadership"""
         option = self._option_bag.option
         # for example if index is None
         if '_length' not in vars(self):
@@ -508,13 +509,13 @@ class _TiramisuOptionValueGroup:
         self._option_bag.config_bag.context.reset(self._option_bag.path)
 
 
-class _TiramisuOptionValueSlave:
+class _TiramisuOptionValueFollower:
     def len(self):
-        """Length of slave option"""
+        """Length of follower option"""
         option = self._option_bag.option
         # for example if index is None
         if '_length' not in vars(self):
-            self._length = self._subconfig.cfgimpl_get_length_slave(self._option_bag)
+            self._length = self._subconfig.cfgimpl_get_length_leadership(self._option_bag)
         return self._length
 
 
@@ -550,7 +551,7 @@ class _TiramisuOptionValueOptionDescription:
 class TiramisuOptionValue(CommonTiramisuOption):
     """Manage option's value"""
     _allow_optiondescription = True
-    _slave_need_index = False
+    _follower_need_index = False
 
     def __new__(cls,
                 name,
@@ -570,14 +571,14 @@ class TiramisuOptionValue(CommonTiramisuOption):
                 types.append(_TiramisuOptionValueOption)
                 if isinstance(option, ChoiceOption):
                     types.append(_TiramisuOptionValueChoiceOption)
-                if option.impl_is_master_slaves('master'):
-                    types.append(_TiramisuOptionValueMaster)
-                elif option.impl_is_master_slaves('slave'):
-                    types.append(_TiramisuOptionValueSlave)
+                if option.impl_is_leader():
+                    types.append(_TiramisuOptionValueLeader)
+                elif option.impl_is_follower():
+                    types.append(_TiramisuOptionValueFollower)
         if option_bag.config_bag.context.impl_type == 'group':
             types.append(_TiramisuOptionValueGroup)
         new_type_dict = {'_allow_optiondescription': cls._allow_optiondescription,
-                         '_slave_need_index': cls._slave_need_index}
+                         '_follower_need_index': cls._follower_need_index}
         new_type = type('TiramisuOptionValue', tuple(types), new_type_dict)(name=name,
                                                                             subconfig=subconfig,
                                                                             option_bag=option_bag)
@@ -651,7 +652,7 @@ class _TiramisuOptionDescription(_TiramisuOption):
                                                                                self._config_bag)
             t_option = TiramisuOption(name,
                                       path,
-                                      None,  # index for a slave ?
+                                      None,  # index for a follower ?
                                       subconfig,
                                       self._config_bag)
             if first:
diff --git a/tiramisu/autolib.py b/tiramisu/autolib.py
index a1876f7..dc2af0c 100644
--- a/tiramisu/autolib.py
+++ b/tiramisu/autolib.py
@@ -21,7 +21,7 @@
 from typing import Any, Optional, Union, Callable, Dict, List
 
 
-from .error import PropertiesOptionError, ConfigError, SlaveError
+from .error import PropertiesOptionError, ConfigError, LeadershipError
 from .i18n import _
 from .setting import undefined, ConfigBag, OptionBag, Undefined
 from .storage import get_default_values_storages, get_default_settings_storages
@@ -51,12 +51,12 @@ def manager_callback(callbk: Union[ParamOption, ParamValue],
         opt = opt.to_dynoption(option.rootpath,
                                option.impl_getsuffix())
     path = opt.impl_getpath()
-    if index is not None and opt.impl_is_master_slaves() and \
-            opt.impl_get_master_slaves().in_same_group(option):
+    if index is not None and opt.impl_get_leadership() and \
+            opt.impl_get_leadership().in_same_group(option):
         if opt == option:
             index_ = None
             with_index = False
-        elif opt.impl_is_master_slaves('slave'):
+        elif opt.impl_is_follower():
             index_ = index
             with_index = False
         else:
@@ -66,7 +66,7 @@ def manager_callback(callbk: Union[ParamOption, ParamValue],
         index_ = None
         with_index = False
     if opt == option and orig_value is not undefined and \
-            (not opt.impl_is_master_slaves('slave') or index is None):
+            (not opt.impl_is_follower() or index is None):
         return orig_value
     # don't validate if option is option that we tried to validate
     config_bag = config_bag.copy()
@@ -152,17 +152,17 @@ def carry_out_calculation(option,
          opt1 == 11
          => calculate(<function func at 0x1cea320>, [11], {})
 
-       - a multi option and not master/slave:
+       - a multi option and not leadership
          opt1 == [1, 2, 3]
          => calculate(<function func at 0x223c320>, [[1, 2, 3]], {})
 
-       - option is master or slave of opt1:
+       - option is leader or follower of opt1:
          opt1 == [1, 2, 3]
          => calculate(<function func at 0x223c320>, [1], {})
          => calculate(<function func at 0x223c320>, [2], {})
          => calculate(<function func at 0x223c320>, [3], {})
 
-      - opt is a master or slave but not related to option:
+      - opt is a leader or follower but not related to option:
         opt1 == [1, 2, 3]
         => calculate(<function func at 0x11b0320>, [[1, 2, 3]], {})
 
@@ -252,20 +252,20 @@ def carry_out_calculation(option,
                     args,
                     kwargs)
     if isinstance(ret, list) and not option.impl_is_dynoptiondescription() and \
-            option.impl_is_master_slaves('slave'):
+            option.impl_is_follower():
         if args or kwargs:
-            raise SlaveError(_('function "{}" with arguments "{}" and "{}" '
-                               'return the list "{}" for the slave option "{}"'
-                               '').format(callback.__name__,
-                                          args,
-                                          kwargs,
-                                          ret,
-                                          option.impl_get_display_name()))
+            raise LeadershipError(_('function "{}" with arguments "{}" and "{}" '
+                                    'return the list "{}" for the follower option "{}"'
+                                    '').format(callback.__name__,
+                                               args,
+                                               kwargs,
+                                               ret,
+                                               option.impl_get_display_name()))
         else:
-            raise SlaveError(_('function "{}" return the list "{}" for the slave option "{}"'
-                               '').format(callback.__name__,
-                                          ret,
-                                          option.impl_getname()))
+            raise LeadershipError(_('function "{}" return the list "{}" for the follower option "{}"'
+                                    '').format(callback.__name__,
+                                               ret,
+                                               option.impl_getname()))
     return ret
 
 
diff --git a/tiramisu/config.py b/tiramisu/config.py
index 5de588f..9b2b6b0 100644
--- a/tiramisu/config.py
+++ b/tiramisu/config.py
@@ -23,10 +23,11 @@ import weakref
 from copy import copy
 
 
-from .error import PropertiesOptionError, ConfigError, ConflictError, SlaveError
-from .option import SynDynOptionDescription, DynOptionDescription, MasterSlaves
+from .error import PropertiesOptionError, ConfigError, ConflictError, \
+                   LeadershipError
+from .option import SynDynOptionDescription, DynOptionDescription, Leadership
 from .option.baseoption import BaseOption, valid_name
-from .setting import OptionBag, ConfigBag, groups, Settings, undefined
+from .setting import OptionBag, ConfigBag, Settings, undefined
 from .storage import get_storages, gen_storage_id, get_default_values_storages
 from .value import Values
 from .i18n import _
@@ -49,7 +50,7 @@ class SubConfig(object):
                  config_bag,
                  subpath=None,
                  fromconsistency=None):
-        """ Configuration option management master class
+        """ Configuration option management class
 
         :param descr: describes the configuration schema
         :type descr: an instance of ``option.OptionDescription``
@@ -58,10 +59,9 @@ class SubConfig(object):
         :type subpath: `str` with the path name
         """
         # main option description
-        error = False
-        if descr is not None and (not isinstance(descr, (BaseOption, SynDynOptionDescription)) or not descr.impl_is_optiondescription()):
-            error = True
-        if error:
+        if __debug__ and descr is not None and \
+                (not isinstance(descr, (BaseOption, SynDynOptionDescription)) or
+                 not descr.impl_is_optiondescription()):
             try:
                 msg = descr.impl_get_displayname()
             except AttributeError:
@@ -71,29 +71,28 @@ class SubConfig(object):
         self._impl_descr = descr
         self._impl_context = context
         self._impl_path = subpath
-        if descr is not None and \
-                descr.impl_get_group_type() == groups.master:
-            master = descr.getmaster()
-            masterpath = master.impl_getname()
-            full_masterpath = self._get_subpath(masterpath)
+        if descr is not None and descr.impl_is_leadership():
+            leader = descr.get_leader()
+            leaderpath = leader.impl_getname()
+            full_leaderpath = self._get_subpath(leaderpath)
             cconfig_bag = config_bag.copy()
             cconfig_bag.remove_validation()
             moption_bag = OptionBag()
-            moption_bag.set_option(master,
-                                   full_masterpath,
+            moption_bag.set_option(leader,
+                                   full_leaderpath,
                                    None,
                                    cconfig_bag)
             if fromconsistency:
                 moption_bag.fromconsistency = fromconsistency
-            value = self.getattr(masterpath,
+            value = self.getattr(leaderpath,
                                  moption_bag)
             self._impl_length = len(value)
 
     def cfgimpl_get_length(self):
         return self._impl_length
 
-    def cfgimpl_get_length_slave(self,
-                                 option_bag):
+    def cfgimpl_get_length_leadership(self,
+                                      option_bag):
         if option_bag.option.impl_is_symlinkoption():
             context = self.cfgimpl_get_context()
             path = option_bag.option.impl_getopt().impl_getpath()
@@ -238,9 +237,9 @@ class SubConfig(object):
             raise ConfigError(_("can't assign to a SymLinkOption"))
         context = option_bag.config_bag.context
         context.cfgimpl_get_settings().validate_properties(option_bag)
-        if option_bag.option.impl_is_master_slaves('master') and len(value) < self._impl_length:
-            raise SlaveError(_('cannot reduce length of the master "{}"'
-                               '').format(option_bag.option.impl_get_display_name()))
+        if option_bag.option.impl_is_leader() and len(value) < self._impl_length:
+            raise LeadershipError(_('cannot reduce length of a leader "{}"'
+                                    '').format(option_bag.option.impl_get_display_name()))
         return context.cfgimpl_get_values().setvalue(value,
                                                      option_bag,
                                                      _commit)
@@ -253,8 +252,8 @@ class SubConfig(object):
             raise TypeError(_("can't delete a SymLinkOption"))
         values = self.cfgimpl_get_values()
         if option_bag.index is not None:
-            values.reset_slave(option_bag,
-                               _commit)
+            values.reset_follower(option_bag,
+                                  _commit)
         else:
             values.reset(option_bag,
                          _commit)
@@ -313,16 +312,16 @@ class SubConfig(object):
 
         self.cfgimpl_get_settings().validate_properties(option_bag)
 
-        if option.impl_is_master_slaves('slave'):
-            length = self.cfgimpl_get_length_slave(option_bag)
-            slave_len = self.cfgimpl_get_values()._p_.get_max_length(option_bag.path)
-            if slave_len > length:
-                raise SlaveError(_('slave option "{}" has higher length "{}" than the master '
-                                   'length "{}"').format(option.impl_get_display_name(),
-                                                         slave_len,
+        if option.impl_is_follower():
+            length = self.cfgimpl_get_length_leadership(option_bag)
+            follower_len = self.cfgimpl_get_values()._p_.get_max_length(option_bag.path)
+            if follower_len > length:
+                raise LeadershipError(_('follower option "{}" has higher length "{}" than the leader '
+                                        'length "{}"').format(option.impl_get_display_name(),
+                                                         follower_len,
                                                          length,
                                                          option_bag.index))
-        if option.impl_is_master_slaves('slave') and option_bag.index is None:
+        if option.impl_is_follower() and option_bag.index is None:
             value = []
             for idx in range(length):
                 soption_bag = OptionBag()
@@ -717,7 +716,7 @@ class KernelConfig(_CommonConfig):
                  force_settings=None,
                  _duplicate=False,
                  storage=None):
-        """ Configuration option management master class
+        """ Configuration option management class
 
         :param descr: describes the configuration schema
         :type descr: an instance of ``option.OptionDescription``
@@ -730,8 +729,8 @@ class KernelConfig(_CommonConfig):
         :type persistent: `boolean`
         """
         self._impl_meta = None
-        if isinstance(descr, MasterSlaves):
-            raise ConfigError(_('cannot set masterslaves object has root optiondescription'))
+        if isinstance(descr, Leadership):
+            raise ConfigError(_('cannot set leadership object has root optiondescription'))
         if isinstance(descr, DynOptionDescription):
             raise ConfigError(_('cannot set dynoptiondescription object has root optiondescription'))
         if force_settings is not None and force_values is not None:
@@ -872,7 +871,7 @@ class KernelGroupConfig(_CommonConfig):
                                                      err._requires,
                                                      err._name,
                                                      err._orig_opt))
-                except (ValueError, SlaveError, AttributeError) as err:
+                except (ValueError, LeadershipError, AttributeError) as err:
                     ret.append(err)
         if _commit and self.impl_type != 'group':
             self.cfgimpl_get_values()._p_.commit()
@@ -1089,7 +1088,7 @@ class KernelMixConfig(KernelGroupConfig):
                                                      err._requires,
                                                      err._name,
                                                      err._orig_opt))
-                except (ValueError, SlaveError, AttributeError) as err:
+                except (ValueError, LeadershipError, AttributeError) as err:
                     ret.append(err)
 
         try:
@@ -1100,7 +1099,7 @@ class KernelMixConfig(KernelGroupConfig):
             subconfig.setattr(value,
                               option_bag,
                               _commit=False)
-        except (PropertiesOptionError, ValueError, SlaveError) as err:
+        except (PropertiesOptionError, ValueError, LeadershipError) as err:
             ret.append(err)
         return ret
 
diff --git a/tiramisu/error.py b/tiramisu/error.py
index e167413..940eee2 100644
--- a/tiramisu/error.py
+++ b/tiramisu/error.py
@@ -144,8 +144,8 @@ class RequirementError(Exception):
     pass
 
 
-class SlaveError(Exception):
-    "problem with a slave's value length"
+class LeadershipError(Exception):
+    "problem with a leadership's value length"
     pass
 
 
diff --git a/tiramisu/option/__init__.py b/tiramisu/option/__init__.py
index 78a6734..c1739af 100644
--- a/tiramisu/option/__init__.py
+++ b/tiramisu/option/__init__.py
@@ -1,7 +1,7 @@
 from .optiondescription import OptionDescription
 from .dynoptiondescription import DynOptionDescription
-from .syndynoptiondescription import SynDynOptionDescription, SynDynMasterSlaves
-from .masterslaves import MasterSlaves
+from .syndynoptiondescription import SynDynOptionDescription, SynDynLeadership
+from .leadership import Leadership
 from .baseoption import submulti
 from .symlinkoption import SymLinkOption
 from .syndynoption import SynDynOption
@@ -25,8 +25,8 @@ from .filenameoption import FilenameOption
 from .passwordoption import PasswordOption
 
 
-__all__ = ('MasterSlaves', 'OptionDescription', 'DynOptionDescription',
-           'SynDynOptionDescription', 'SynDynMasterSlaves', 'Option', 'SymLinkOption',
+__all__ = ('Leadership', 'OptionDescription', 'DynOptionDescription',
+           'SynDynOptionDescription', 'SynDynLeadership', 'Option', 'SymLinkOption',
            'SynDynOption', 'ChoiceOption', 'BoolOption', 'DateOption',
            'IntOption', 'FloatOption', 'StrOption', 'UnicodeOption',
            'IPOption', 'PortOption', 'NetworkOption', 'NetmaskOption',
diff --git a/tiramisu/option/baseoption.py b/tiramisu/option/baseoption.py
index b4c61a2..2591fd4 100644
--- a/tiramisu/option/baseoption.py
+++ b/tiramisu/option/baseoption.py
@@ -90,7 +90,7 @@ class Base:
             properties = frozenset(properties)
         if is_multi and 'empty' not in properties:
             # if option is a multi, it cannot be "empty" (None not allowed in the list)
-            # "empty" is removed for slave's option
+            # "empty" is removed for follower's option
             properties = properties | {'empty'}
         if not isinstance(properties, frozenset):
             raise TypeError(_('invalid properties type {0} for {1},'
diff --git a/tiramisu/option/dynoptiondescription.py b/tiramisu/option/dynoptiondescription.py
index 9e9e2c3..87135da 100644
--- a/tiramisu/option/dynoptiondescription.py
+++ b/tiramisu/option/dynoptiondescription.py
@@ -52,7 +52,7 @@ class DynOptionDescription(OptionDescription):
         # check children + set relation to this dynoptiondescription
         for child in children:
             if isinstance(child, OptionDescription):
-                if __debug__ and child.impl_get_group_type() != groups.master:
+                if __debug__ and child.impl_get_group_type() != groups.leadership:
                     raise ConfigError(_('cannot set optiondescription in a '
                                         'dynoptiondescription'))
                 for chld in child.get_children(config_bag=undefined):
diff --git a/tiramisu/option/masterslaves.py b/tiramisu/option/leadership.py
similarity index 59%
rename from tiramisu/option/masterslaves.py
rename to tiramisu/option/leadership.py
index 0828474..4303976 100644
--- a/tiramisu/option/masterslaves.py
+++ b/tiramisu/option/leadership.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-"master slaves support"
+"Leadership support"
 # Copyright (C) 2014-2019 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -28,16 +28,16 @@ from ..i18n import _
 from ..setting import groups, undefined, OptionBag, Settings
 from ..value import Values
 from .optiondescription import OptionDescription
-from .syndynoptiondescription import SynDynMasterSlaves
+from .syndynoptiondescription import SynDynLeadership
 from .baseoption import BaseOption
 from .option import Option
-from ..error import SlaveError, PropertiesOptionError, RequirementError
+from ..error import RequirementError
 from ..function import ParamOption
 
 
-class MasterSlaves(OptionDescription):
-    __slots__ = ('master',
-                 'slaves')
+class Leadership(OptionDescription):
+    __slots__ = ('leader',
+                 'followers')
 
     def __init__(self,
                  name: str,
@@ -46,86 +46,86 @@ class MasterSlaves(OptionDescription):
                  requires=None,
                  properties=None) -> None:
 
-        super(MasterSlaves, self).__init__(name,
-                                           doc,
-                                           children,
-                                           requires=requires,
-                                           properties=properties)
-        self._group_type = groups.master
-        slaves = []
+        super().__init__(name,
+                         doc,
+                         children,
+                         requires=requires,
+                         properties=properties)
+        self._group_type = groups.leadership
+        followers = []
         if len(children) < 2:
-            raise ValueError(_('a master and a slave are mandatories in masterslaves "{}"'
+            raise ValueError(_('a leader and a follower are mandatories in leadership "{}"'
                                '').format(name))
-        master = children[0]
+        leader = children[0]
         for idx, child in enumerate(children):
             if __debug__:
                 if child.impl_is_symlinkoption():
-                    raise ValueError(_('masterslaves "{0}" shall not have '
+                    raise ValueError(_('leadership "{0}" shall not have '
                                        "a symlinkoption").format(self.impl_get_display_name()))
                 if not isinstance(child, Option):
-                    raise ValueError(_('masterslaves "{0}" shall not have '
+                    raise ValueError(_('leadership "{0}" shall not have '
                                        'a subgroup').format(self.impl_get_display_name()))
                 if not child.impl_is_multi():
-                    raise ValueError(_('only multi option allowed in masterslaves "{0}" but option '
+                    raise ValueError(_('only multi option allowed in leadership "{0}" but option '
                                        '"{1}" is not a multi'
                                        '').format(self.impl_get_display_name(),
                                                   child.impl_get_display_name()))
                 if idx != 0 and child.impl_getdefault() != []:
-                    raise ValueError(_('not allowed default value for slave option "{0}" '
-                                       'in masterslaves "{1}"'
+                    raise ValueError(_('not allowed default value for follower option "{0}" '
+                                       'in leadership "{1}"'
                                        '').format(child.impl_get_display_name(),
                                                   self.impl_get_display_name()))
             if idx != 0:
-                # remove empty property for slave
+                # remove empty property for follower
                 child_properties = list(child._properties)
                 child_properties.remove('empty')
                 child._properties = frozenset(child_properties)
-                slaves.append(child)
+                followers.append(child)
             child._add_dependency(self)
-            child._master_slaves = weakref.ref(self)
-        callback, callback_params = master.impl_get_callback()
+            child._leadership = weakref.ref(self)
+        callback, callback_params = leader.impl_get_callback()
         if callback is not None and callback_params is not None:
             for callbk in chain(callback_params.args, callback_params.kwargs.values()):
-                if isinstance(callbk, ParamOption) and callbk.option in slaves:
-                    raise ValueError(_("callback of master's option shall "
-                                       "not refered to a slave's ones"))
-        # master should not have requires, only MasterSlaves should have
-        # so move requires to MasterSlaves
-        # if MasterSlaves has requires too, cannot manage this move so raises
-        master_requires = getattr(master, '_requires', None)
-        if master_requires:
+                if isinstance(callbk, ParamOption) and callbk.option in followers:
+                    raise ValueError(_("callback of leader's option shall "
+                                       "not refered to a follower's ones"))
+        # leader should not have requires, only Leadership should have
+        # so move requires to Leadership
+        # if Leadership has requires too, cannot manage this move so raises
+        leader_requires = getattr(leader, '_requires', None)
+        if leader_requires:
             if __debug__ and self.impl_getrequires():
-                raise RequirementError(_('master {} have requirement, but MasterSlaves {} too'
-                                         '').format(master.impl_getname(),
+                raise RequirementError(_('leader {} have requirement, but Leadership {} too'
+                                         '').format(leader.impl_getname(),
                                                     self.impl_getname()))
-            master_calproperties = getattr(master, '_calc_properties', None)
-            if master_calproperties:
+            leader_calproperties = getattr(leader, '_calc_properties', None)
+            if leader_calproperties:
                 if __debug__ and properties is not None:
-                    self.validate_properties(name, master_calproperties, frozenset(properties))
-                setattr(self, '_calc_properties', master_calproperties)
-                setattr(self, '_requires', master_requires)
-                delattr(master, '_requires')
+                    self.validate_properties(name, leader_calproperties, frozenset(properties))
+                setattr(self, '_calc_properties', leader_calproperties)
+                setattr(self, '_requires', leader_requires)
+                delattr(leader, '_requires')
         if __debug__:
             for requires_ in getattr(self, '_requires', ()):
                 for require in requires_:
                     for require_opt, values in require[0]:
-                        if require_opt.impl_is_multi() and require_opt.impl_is_master_slaves():
+                        if require_opt.impl_is_multi() and require_opt.impl_get_leadership():
                             raise ValueError(_('malformed requirements option "{0}" '
-                                               'must not be in slave for "{1}"').format(
+                                               'must not be in follower for "{1}"').format(
                                                    require_opt.impl_getname(),
                                                    self.impl_getname()))
 
-    def is_master(self,
+    def is_leader(self,
                   opt: Option) -> bool:
-        master = self.getmaster()
-        return opt == master or (opt.impl_is_dynsymlinkoption() and opt.opt == master)
+        leader = self.get_leader()
+        return opt == leader or (opt.impl_is_dynsymlinkoption() and opt.opt == leader)
 
-    def getmaster(self) -> Option:
+    def get_leader(self) -> Option:
         return self._children[1][0]
 
-    def getslaves(self) -> Iterator[Option]:
-        for slave in self._children[1][1:]:
-            yield slave
+    def get_followers(self) -> Iterator[Option]:
+        for follower in self._children[1][1:]:
+            yield follower
 
     def in_same_group(self,
                       opt: Option) -> bool:
@@ -139,11 +139,11 @@ class MasterSlaves(OptionDescription):
               _commit: bool=True) -> None:
         config_bag = option_bag.config_bag.copy()
         config_bag.remove_validation()
-        for slave in self.getslaves():
-            slave_path = slave.impl_getpath()
+        for follower in self.get_followers():
+            follower_path = follower.impl_getpath()
             soption_bag = OptionBag()
-            soption_bag.set_option(slave,
-                                   slave_path,
+            soption_bag.set_option(follower,
+                                   follower_path,
                                    None,
                                    config_bag)
             values.reset(soption_bag,
@@ -153,31 +153,31 @@ class MasterSlaves(OptionDescription):
             values: Values,
             index: int,
             option_bag: OptionBag,
-            slaves: Optional[List[Option]]=undefined) -> None:
-        if slaves is undefined:
-            # slaves is not undefined only in SynDynMasterSlaves
-            slaves = self.getslaves()
+            followers: Optional[List[Option]]=undefined) -> None:
+        if followers is undefined:
+            # followers are not undefined only in SynDynLeadership
+            followers = self.get_followers()
         config_bag = option_bag.config_bag.copy()
         config_bag.remove_validation()
-        for slave in slaves:
-            slave_path = slave.impl_getpath()
-            slavelen = values._p_.get_max_length(slave_path)
+        for follower in followers:
+            follower_path = follower.impl_getpath()
+            followerlen = values._p_.get_max_length(follower_path)
             soption_bag = OptionBag()
-            soption_bag.set_option(slave,
-                                   slave_path,
+            soption_bag.set_option(follower,
+                                   follower_path,
                                    index,
                                    config_bag)
             # do not check force_default_on_freeze
             soption_bag.properties = set()
             if not values.is_default_owner(soption_bag,
-                                           validate_meta=False) and slavelen > index:
-                values._p_.resetvalue_index(slave_path,
+                                           validate_meta=False) and followerlen > index:
+                values._p_.resetvalue_index(follower_path,
                                             index,
                                             True)
-            if slavelen > index + 1:
-                for idx in range(index + 1, slavelen):
-                    if values._p_.hasvalue(slave_path, idx):
-                        values._p_.reduce_index(slave_path,
+            if followerlen > index + 1:
+                for idx in range(index + 1, followerlen):
+                    if values._p_.hasvalue(follower_path, idx):
+                        values._p_.reduce_index(follower_path,
                                                 idx)
 
     def reset_cache(self,
@@ -186,16 +186,16 @@ class MasterSlaves(OptionDescription):
                     settings: Settings,
                     resetted_opts: List[Option]) -> None:
         self._reset_cache(path,
-                          self.getmaster(),
-                          self.getslaves(),
+                          self.get_leader(),
+                          self.get_followers(),
                           values,
                           settings,
                           resetted_opts)
 
     def _reset_cache(self,
                      path: str,
-                     master: Option,
-                     slaves: List[Option],
+                     leader: Option,
+                     followers: List[Option],
                      values: Values,
                      settings: Settings,
                      resetted_opts: List[Option]) -> None:
@@ -203,24 +203,24 @@ class MasterSlaves(OptionDescription):
                             values,
                             settings,
                             resetted_opts)
-        master.reset_cache(master.impl_getpath(),
+        leader.reset_cache(leader.impl_getpath(),
                            values,
                            settings,
                            None)
-        for slave in slaves:
-            spath = slave.impl_getpath()
-            slave.reset_cache(spath,
-                              values,
-                              settings,
-                              None)
+        for follower in followers:
+            spath = follower.impl_getpath()
+            follower.reset_cache(spath,
+                                 values,
+                                 settings,
+                                 None)
             resetted_opts.append(spath)
 
-    def impl_is_master_slaves(self) -> None:
+    def impl_is_leadership(self) -> None:
         return True
 
     def to_dynoption(self,
                      rootpath: str,
-                     suffix: str) -> SynDynMasterSlaves:
-        return SynDynMasterSlaves(self,
-                                  rootpath,
-                                  suffix)
+                     suffix: str) -> SynDynLeadership:
+        return SynDynLeadership(self,
+                                rootpath,
+                                suffix)
diff --git a/tiramisu/option/option.py b/tiramisu/option/option.py
index a04c96e..51433c7 100644
--- a/tiramisu/option/option.py
+++ b/tiramisu/option/option.py
@@ -52,7 +52,7 @@ class Option(BaseOption):
                  #calcul
                  '_val_call',
                  #
-                 '_master_slaves',
+                 '_leadership',
                  '_choice_values',
                  '_choice_values_params',
                 )
@@ -381,24 +381,27 @@ class Option(BaseOption):
         pass
 
     #__________________________________________________________________________
-    # master/slaves
+    # leadership
+    # def impl_is_leadership(self):
+    #     return self.impl_get_leadership() is not None
 
-    def impl_is_master_slaves(self,
-                              type_: str='both') -> bool:
-        master_slaves = self.impl_get_master_slaves()
-        if master_slaves is not None:
-            if type_ == 'both':
-                return True
-            is_master = master_slaves.is_master(self)
-            if (type_ == 'master' and is_master) or (type_ == 'slave' and not is_master):
-                return True
-        return False
+    def impl_is_leader(self):
+        leadership = self.impl_get_leadership()
+        if leadership is None:
+            return leadership
+        return self.impl_get_leadership().is_leader(self)
 
-    def impl_get_master_slaves(self):
-        masterslave = getattr(self, '_master_slaves', None)
-        if masterslave is None:
-            return masterslave
-        return masterslave()
+    def impl_is_follower(self):
+        leadership = self.impl_get_leadership()
+        if leadership is None:
+            return leadership
+        return not leadership.is_leader(self)
+
+    def impl_get_leadership(self):
+        leadership = getattr(self, '_leadership', None)
+        if leadership is None:
+            return leadership
+        return leadership()
 
     #____________________________________________________________
     # consistencies
@@ -662,7 +665,7 @@ class Option(BaseOption):
         if func in ALLOWED_CONST_LIST:
             index = None
             index_ = None
-        elif current_option.impl_is_master_slaves('master'):
+        elif current_option.impl_is_leader():
             index = option_bag.index
             index_ = None
         else:
@@ -681,8 +684,8 @@ class Option(BaseOption):
         current_value = option_bag.config_bag.context.getattr(path,
                                                               coption_bag)
         if index_ is None and index is not None:
-            #if self is a slave and current_option is a master and func not in ALLOWED_CONST_LIST
-            #return only the value of the master for isolate slave
+            #if self is a follower and current_option is a leader and func not in ALLOWED_CONST_LIST
+            #return only the value of the leader for isolate follower
             current_value = current_value[index]
         return current_value
 
diff --git a/tiramisu/option/optiondescription.py b/tiramisu/option/optiondescription.py
index 1203a1d..2944dbe 100644
--- a/tiramisu/option/optiondescription.py
+++ b/tiramisu/option/optiondescription.py
@@ -26,7 +26,7 @@ from ..i18n import _
 from ..setting import ConfigBag, OptionBag, groups, undefined, owners, Undefined
 from .baseoption import BaseOption
 from .option import ALLOWED_CONST_LIST
-from .syndynoptiondescription import SynDynOptionDescription, SynDynMasterSlaves
+from .syndynoptiondescription import SynDynOptionDescription, SynDynLeadership
 from ..error import ConfigError, ConflictError
 
 
@@ -80,9 +80,9 @@ class CacheOptionDescription(BaseOption):
                     properties = option.impl_getproperties()
                     if 'force_store_value' in properties:
                         if __debug__:
-                            if option.impl_is_master_slaves('slave'):
+                            if option.impl_is_follower():
                                 # problem with index
-                                raise ConfigError(_('the slave "{0}" cannot have '
+                                raise ConfigError(_('the follower "{0}" cannot have '
                                                     '"force_store_value" property').format(
                                                         option.impl_get_display_name()))
                             if option.issubdyn():
@@ -92,28 +92,28 @@ class CacheOptionDescription(BaseOption):
                         force_store_values.append((subpath, option))
                     if __debug__ and 'force_default_on_freeze' in properties and \
                             'frozen' not in properties and \
-                            option.impl_is_master_slaves('master'):
-                        raise ConfigError(_('a master ({0}) cannot have '
+                            option.impl_is_leader():
+                        raise ConfigError(_('a leader ({0}) cannot have '
                                             '"force_default_on_freeze" property without "frozen"'
                                             '').format(subpath))
                 for cons_id, func, all_cons_opts, params in option.get_consistencies():
                     option._valid_consistencies(all_cons_opts[1:], init=False)
                     if func not in ALLOWED_CONST_LIST and is_multi:
-                        if __debug__ and not option.impl_is_master_slaves():
+                        if __debug__ and not option.impl_get_leadership():
                             raise ConfigError(_('malformed consistency option "{0}" '
-                                               'must be a masterslaves').format(
+                                               'must be a leadership').format(
                                                    option.impl_getname()))
-                        masterslaves = option.impl_get_master_slaves()
+                        leadership = option.impl_get_leadership()
                     for weak_opt in all_cons_opts:
                         opt = weak_opt()
                         if __debug__ and func not in ALLOWED_CONST_LIST and is_multi:
-                            if not opt.impl_is_master_slaves():
+                            if not opt.impl_get_leadership():
                                 raise ConfigError(_('malformed consistency option "{0}" '
                                                    'must not be a multi for "{1}"').format(
                                                        option.impl_getname(), opt.impl_getname()))
-                            elif masterslaves != opt.impl_get_master_slaves():
+                            elif leadership != opt.impl_get_leadership():
                                 raise ConfigError(_('malformed consistency option "{0}" '
-                                                   'must be in same masterslaves as "{1}"').format(
+                                                   'must be in same leadership as "{1}"').format(
                                                        option.impl_getname(), opt.impl_getname()))
                         _consistencies.setdefault(weak_opt,
                                                   []).append((_consistencies_id,
@@ -126,25 +126,25 @@ class CacheOptionDescription(BaseOption):
                     self._add_dependency(option)
 
                 if __debug__:
-                    is_slave = None
+                    is_follower = None
                     if is_multi:
                         all_requires = option.impl_getrequires()
                         for requires in all_requires:
                             for require in requires:
                                 #if option in require is a multi:
-                                # * option in require must be a master or a slave
-                                # * current option must be a slave (and only a slave)
-                                # * option in require and current option must be in same masterslaves
+                                # * option in require must be a leader or a follower
+                                # * current option must be a follower (and only a follower)
+                                # * option in require and current option must be in same leadership
                                 for require_opt, values in require[0]:
                                     if require_opt.impl_is_multi():
-                                        if is_slave is None:
-                                            is_slave = option.impl_is_master_slaves('slave')
-                                            if is_slave:
-                                                masterslaves = option.impl_get_master_slaves()
-                                        if is_slave and require_opt.impl_is_master_slaves():
-                                            if masterslaves != require_opt.impl_get_master_slaves():
+                                        if is_follower is None:
+                                            is_follower = option.impl_is_follower()
+                                            if is_follower:
+                                                leadership = option.impl_get_leadership()
+                                        if is_follower and require_opt.impl_get_leadership():
+                                            if leadership != require_opt.impl_get_leadership():
                                                 raise ValueError(_('malformed requirements option "{0}" '
-                                                                   'must be in same masterslaves for "{1}"').format(
+                                                                   'must be in same leadership for "{1}"').format(
                                                                        require_opt.impl_getname(), option.impl_getname()))
                                         else:
                                             raise ValueError(_('malformed requirements option "{0}" '
@@ -311,7 +311,7 @@ class OptionDescription(OptionDescriptionWalk):
     def impl_is_dynoptiondescription(self) -> bool:
         return False
 
-    def impl_is_master_slaves(self) -> bool:
+    def impl_is_leadership(self) -> bool:
         return False
 
     # ____________________________________________________________
@@ -319,7 +319,7 @@ class OptionDescription(OptionDescriptionWalk):
                             group_type: groups.GroupType) -> None:
         """sets a given group object to an OptionDescription
 
-        :param group_type: an instance of `GroupType` or `MasterGroupType`
+        :param group_type: an instance of `GroupType` or `LeadershipGroupType`
                               that lives in `setting.groups`
         """
         if self._group_type != groups.default:
@@ -329,8 +329,8 @@ class OptionDescription(OptionDescriptionWalk):
         if not isinstance(group_type, groups.GroupType):
             raise ValueError(_('group_type: {0}'
                                ' not allowed').format(group_type))
-        if isinstance(group_type, groups.MasterGroupType):
-            raise ConfigError('please use MasterSlaves object instead of OptionDescription')
+        if isinstance(group_type, groups.LeadershipGroupType):
+            raise ConfigError('please use Leadership object instead of OptionDescription')
         self._group_type = group_type
 
     def impl_get_group_type(self) -> groups.GroupType:
diff --git a/tiramisu/option/syndynoptiondescription.py b/tiramisu/option/syndynoptiondescription.py
index 450ef12..32e12e2 100644
--- a/tiramisu/option/syndynoptiondescription.py
+++ b/tiramisu/option/syndynoptiondescription.py
@@ -104,28 +104,27 @@ class SynDynOptionDescription:
         return self._opt.impl_get_display_name() + self._suffix
 
 
-class SynDynMasterSlaves(SynDynOptionDescription):
+class SynDynLeadership(SynDynOptionDescription):
+    def get_leader(self) -> SynDynOption:
+        return self._opt.get_leader().to_dynoption(self.impl_getpath(),
+                                                   self._suffix)
 
-    def getmaster(self) -> SynDynOption:
-        return self._opt.getmaster().to_dynoption(self.impl_getpath(),
-                                                  self._suffix)
-
-    def getslaves(self) -> Iterator[SynDynOption]:
+    def get_followers(self) -> Iterator[SynDynOption]:
         subpath = self.impl_getpath()
-        for slave in self._opt.getslaves():
-            yield slave.to_dynoption(subpath,
-                                     self._suffix)
+        for follower in self._opt.get_followers():
+            yield follower.to_dynoption(subpath,
+                                        self._suffix)
 
     def reset_cache(self,
                     path: str,
                     values: Values,
                     settings: Settings,
                     resetted_opts: List[str]) -> None:
-        master = self.getmaster()
-        slaves = self.getslaves()
+        leader = self.get_leader()
+        followers = self.get_followers()
         self._reset_cache(path,
-                          master,
-                          slaves,
+                          leader,
+                          followers,
                           values,
                           settings,
                           resetted_opts)
@@ -134,5 +133,5 @@ class SynDynMasterSlaves(SynDynOptionDescription):
             *args,
             **kwargs) -> None:
         self._opt.pop(*args,
-                      slaves=self.getslaves(),
+                      followers=self.get_followers(),
                       **kwargs)
diff --git a/tiramisu/setting.py b/tiramisu/setting.py
index b6c9a83..a0f5d39 100644
--- a/tiramisu/setting.py
+++ b/tiramisu/setting.py
@@ -75,7 +75,7 @@ everything_frozen
     property)
 
 empty
-    raise mandatory PropertiesOptionError if multi or master have empty value
+    raise mandatory PropertiesOptionError if multi or leader have empty value
 
 validator
     launch validator set by user in option (this property has no effect
@@ -258,7 +258,7 @@ class GroupModule(_NameSpace):
     "emulates a module to manage unique group (OptionDescription) names"
     class GroupType(str):
         """allowed normal group (OptionDescription) names
-        *normal* means : groups that are not master
+        *normal* means : groups that are not leader
         """
         pass
 
@@ -266,9 +266,9 @@ class GroupModule(_NameSpace):
         """groups that are default (typically 'default')"""
         pass
 
-    class MasterGroupType(GroupType):
+    class LeadershipGroupType(GroupType):
         """allowed normal group (OptionDescription) names
-        *master* means : groups that have the 'master' attribute set
+        *leadership* means : groups that have the 'leadership' attribute set
         """
         pass
 
@@ -301,12 +301,12 @@ groups = GroupModule()
         default group set when creating a new optiondescription"""
 groups.default = groups.DefaultGroupType('default')
 
-"""groups.master
-        master group is a special optiondescription, all suboptions should be
-        multi option and all values should have same length, to find master's
-        option, the optiondescription's name should be same than de master's
+"""groups.leadership
+        leadership group is a special optiondescription, all suboptions should be
+        multi option and all values should have same length, to find leader's
+        option, the optiondescription's name should be same than de leader's
         option"""
-groups.master = groups.MasterGroupType('master')
+groups.leadership = groups.LeadershipGroupType('leadership')
 
 """    groups.family
         example of group, no special behavior with this group's type"""
@@ -520,7 +520,7 @@ class Settings(object):
                                                  "'{1}'").format(option_bag.path, reqpath))
                     idx = None
                     is_indexed = False
-                    if option.impl_is_master_slaves('slave'):
+                    if option.impl_is_follower():
                         idx = option_bag.index
                     elif option.impl_is_multi() and option_bag.index is not None:
                         is_indexed = True
@@ -638,13 +638,13 @@ class Settings(object):
                               "").format(opt.impl_get_display_name()))
         if 'force_default_on_freeze' in properties and \
                 'frozen' not in properties and \
-                opt.impl_is_master_slaves('master'):
-            raise ConfigError(_('a master ({0}) cannot have '
+                opt.impl_is_leader():
+            raise ConfigError(_('a leader ({0}) cannot have '
                                 '"force_default_on_freeze" property without "frozen"'
                                 '').format(opt.impl_get_display_name()))
         self._p_.setproperties(path,
                                properties)
-        #values too because of slave values could have a PropertiesOptionError has value
+        # values too because of follower values could have a PropertiesOptionError has value
         context.cfgimpl_reset_cache(option_bag)
         if option_bag is not None:
             del option_bag.properties
diff --git a/tiramisu/storage/util.py b/tiramisu/storage/util.py
index 27d2027..49a7637 100644
--- a/tiramisu/storage/util.py
+++ b/tiramisu/storage/util.py
@@ -36,7 +36,7 @@ class Cache(DictCache):
 
     def setcache(self, path, index, val, self_props, props):
         """add val in cache for a specified path
-        if slave, add index
+        if follower, add index
         """
         if 'cache' in props or 'cache' in self_props:
             if DEBUG:
diff --git a/tiramisu/value.py b/tiramisu/value.py
index 38cb424..d8e4ecf 100644
--- a/tiramisu/value.py
+++ b/tiramisu/value.py
@@ -98,15 +98,15 @@ class Values(object):
         """actually retrieves the value
 
         :param path: the path of the `Option`
-        :param index: index for a slave `Option`
+        :param index: index for a follower `Option`
 
         :returns: value
         """
         # get owner and value from store
-        # index allowed only for slave
+        # index allowed only for follower
         index = option_bag.index
-        is_slave = option_bag.option.impl_is_master_slaves('slave')
-        if index is None or not is_slave:
+        is_follower = option_bag.option.impl_is_follower()
+        if index is None or not is_follower:
             _index = None
         else:
             _index = index
@@ -231,7 +231,7 @@ class Values(object):
             else:
                 allow_empty_list = opt.impl_allow_empty_list()
                 if allow_empty_list is undefined:
-                    allow_empty_list = opt.impl_is_master_slaves('slave')
+                    allow_empty_list = opt.impl_is_follower()
             isempty = value is None or (not allow_empty_list and value == []) or \
                 None in value or empty in value
         else:
@@ -315,11 +315,11 @@ class Values(object):
         meta = context.cfgimpl_get_meta()
         if meta is None:
             return None
-        if option_bag.option.impl_is_master_slaves('slave'):
-            master = option_bag.option.impl_get_master_slaves().getmaster()
-            masterp = master.impl_getpath()
-            # slave could be a "meta" only if master hasn't value
-            if self._p_.hasvalue(masterp,
+        if option_bag.option.impl_is_follower():
+            leader = option_bag.option.impl_get_leadership().get_leader()
+            leaderpath = leader.impl_getpath()
+            # follower could be a "meta" only if leader hasn't value
+            if self._p_.hasvalue(leaderpath,
                                  index=None):
                 return None
         doption_bag = option_bag.copy()
@@ -432,10 +432,10 @@ class Values(object):
             fake_value.setvalue_validation(value,
                                            soption_bag)
         opt = option_bag.option
-        if opt.impl_is_master_slaves('master'):
-            opt.impl_get_master_slaves().reset(self,
-                                               option_bag,
-                                               _commit=_commit)
+        if opt.impl_is_leader():
+            opt.impl_get_leadership().reset(self,
+                                            option_bag,
+                                            _commit=_commit)
         if hasvalue:
             if 'force_store_value' in option_bag.properties:
                 value = self.getdefaultvalue(option_bag)
@@ -449,9 +449,9 @@ class Values(object):
                                     _commit)
             context.cfgimpl_reset_cache(option_bag)
 
-    def reset_slave(self,
-                    option_bag,
-                    _commit=True):
+    def reset_follower(self,
+                       option_bag,
+                       _commit=True):
 
         if self._p_.hasvalue(option_bag.path, index=option_bag.index):
             context = option_bag.config_bag.context
@@ -463,7 +463,7 @@ class Values(object):
                 config_bag.context = fake_context
                 soption_bag = option_bag.copy()
                 soption_bag.config_bag = config_bag
-                fake_value.reset_slave(soption_bag)
+                fake_value.reset_follower(soption_bag)
                 value = fake_value.getdefaultvalue(soption_bag)
                 fake_value.setvalue_validation(value,
                                                soption_bag)
@@ -472,10 +472,10 @@ class Values(object):
                                       _commit)
             context.cfgimpl_reset_cache(option_bag)
 
-    def reset_master(self,
-                     index,
-                     option_bag,
-                     subconfig):
+    def reset_leadership(self,
+                         index,
+                         option_bag,
+                         subconfig):
 
         current_value = self.get_cached_value(option_bag)
         length = len(current_value)
@@ -552,7 +552,7 @@ class Values(object):
             elif not option.impl_is_symlinkoption():
                 # don't verifying symlink
                 try:
-                    if not option.impl_is_master_slaves('slave'):
+                    if not option.impl_is_follower():
                         option_bag = OptionBag()
                         option_bag.set_option(option,
                                               path,