def test_on_created(self):
"""Test _servers.ServersWatch._on_created."""
# Access protected module
# pylint: disable=W0212
dirwatcher = dirwatch.DirWatcher()
dispatcher = dirwatch.DirWatcherDispatcher(dirwatcher)
added_servers = set()
def _server_added(server_info):
added_servers.add(server_info['hostname'])
watch = servers.ServersWatch(dispatcher, self.root, 'partition1',
_server_added)
watch.sync()
path = os.path.join(self.servers_dir, 'server1.ad.com')
with io.open(path, 'w') as f:
yaml.dump(
{
servers.DC_KEY: 'dc.ad.com',
servers.DN_KEY: 'CN=server1,DC=AD,DC=COM',
'partition': 'partition1'
}, f)
watch._on_created(path)
self.assertEqual(added_servers, set(['server1.ad.com']))
def _configure(self):
"""Configures the dispatcher with the monitor actions defined in
the config directory.
"""
config = {}
for name in os.listdir(self._config_dir):
path = os.path.join(self._config_dir, name)
if not os.path.isfile(path):
continue
_LOGGER.debug('Configuring for file: %s', path)
with io.open(path) as f:
for line in f.readlines():
parts = line.rstrip().split(';', 2)
if len(parts) < 2:
_LOGGER.warning('skiping config line %s', line)
continue
try:
handler = plugin_manager.load(_TOMESTONES_PLUGINS,
parts[1])
except KeyError:
_LOGGER.warning('Tomestone handler does not exist: %r',
parts[1])
continue
params = {}
if len(parts) > 2:
params = json.loads(parts[2])
impl = handler(self._tm_env, params)
config[parts[0]] = impl
self._dirwatcher = dirwatch.DirWatcher()
self._dispatcher = dirwatch.DirWatcherDispatcher(self._dirwatcher)
self._tombstones = collections.deque()
for path, handler in six.iteritems(config):
fs.mkdir_safe(path)
self._dirwatcher.add_dir(path)
self._dispatcher.register(
path, {
dirwatch.DirWatcherEvent.CREATED:
lambda p, h=handler: self._on_created(p, h)
})
_LOGGER.info('Watching %s with handler %r', path, handler)
for name in os.listdir(path):
self._on_created(os.path.join(path, name), handler)
_LOGGER.info('Monitor configured')
def test_sync(self):
"""Test _servers.ServersWatch.sync."""
with io.open(os.path.join(self.servers_dir, 'server1.ad.com'),
'w') as f:
yaml.dump({
servers.DC_KEY: 'dc.ad.com',
servers.DN_KEY: 'CN=server1,DC=AD,DC=COM',
'partition': 'partition1'
}, f)
with io.open(os.path.join(self.servers_dir, 'server2.ad.com'),
'w') as f:
yaml.dump({
servers.DC_KEY: 'dc.ad.com',
servers.DN_KEY: 'CN=server2,DC=AD,DC=COM',
'partition': 'partition1'
}, f)
with io.open(os.path.join(self.servers_dir, 'server3.ad.com'),
'w') as f:
yaml.dump({
servers.DC_KEY: 'dc.ad.com',
servers.DN_KEY: 'CN=server3,DC=AD,DC=COM',
'partition': 'partition2'
}, f)
with io.open(os.path.join(self.servers_dir, 'server3.other.com'),
'w') as f:
yaml.dump({
'a': '1',
'b': '2',
'partition': 'partition1'
}, f)
dirwatcher = dirwatch.DirWatcher()
dispatcher = dirwatch.DirWatcherDispatcher(dirwatcher)
added_servers = set()
def _server_added(server_info):
added_servers.add(server_info['hostname'])
watch = servers.ServersWatch(dispatcher, self.root, 'partition1',
_server_added)
watch.sync()
self.assertEqual(added_servers, set(['server1.ad.com',
'server2.ad.com']))
server_info = watch.get_server_info('server1.ad.com')
self.assertEqual(server_info[servers.DN_KEY],
'CN=server1,DC=AD,DC=COM')
self.assertEqual(2, len(watch.get_all_server_info()))
def __init__(self, fsroot):
self.fsroot = fsroot
# pylint: disable=C0103
self.ChildrenWatch = self._childrenwatch
self._dirwatcher = dirwatch.DirWatcher()
self._dirwatch_dispatcher = dirwatch.DirWatcherDispatcher(
self._dirwatcher)
thread = threading.Thread(target=self._run_dirwatcher)
thread.daemon = True
thread.start()
super(FsBackend, self).__init__()
def test_on_modified(self):
"""Test _servers.ServersWatch._on_modified."""
# Access protected module
# pylint: disable=W0212
path = os.path.join(self.servers_dir, 'server1.ad.com')
with io.open(path, 'w') as f:
yaml.dump(
{
servers.DC_KEY: 'dc.ad.com',
servers.DN_KEY: 'CN=server1,DC=AD,DC=COM',
'partition': 'partition1'
}, f)
dirwatcher = dirwatch.DirWatcher()
dispatcher = dirwatch.DirWatcherDispatcher(dirwatcher)
added_servers = set()
def _server_added(server_info):
added_servers.add(server_info[servers.DC_KEY])
watch = servers.ServersWatch(dispatcher, self.root, 'partition1',
_server_added)
watch.sync()
self.assertEqual(added_servers, set(['dc.ad.com']))
server_info = watch.get_server_info('server1.ad.com')
self.assertEqual(server_info[servers.DC_KEY], 'dc.ad.com')
with io.open(path, 'w') as f:
yaml.dump(
{
servers.DC_KEY: 'dc2.ad.com',
servers.DN_KEY: 'CN=server1,DC=AD,DC=COM',
'partition': 'partition1'
}, f)
watch._on_modified(path)
# server_added was not called a second time
self.assertEqual(added_servers, set(['dc.ad.com']))
server_info = watch.get_server_info('server1.ad.com')
self.assertEqual(server_info[servers.DC_KEY], 'dc2.ad.com')
def __init__(self, fs_root, partition, group_ou, group_pattern):
self._config = GMSAConfig(group_ou, group_pattern)
fs_root = os.path.realpath(fs_root)
self._placement_path = os.path.join(fs_root, 'placement')
self._dirwatcher = dirwatch.DirWatcher(self._placement_path)
self._dirwatch_dispatcher = dirwatch.DirWatcherDispatcher(
self._dirwatcher)
self._dirwatch_dispatcher.register(self._placement_path, {
dirwatch.DirWatcherEvent.CREATED: self._on_created_server,
dirwatch.DirWatcherEvent.DELETED: self._on_deleted_server,
})
self._dirwatch_dispatcher.register(self._placement_path + '/*', {
dirwatch.DirWatcherEvent.CREATED: self._on_created_placement,
dirwatch.DirWatcherEvent.DELETED: self._on_deleted_placement,
})
self._servers_watch = servers.ServersWatch(self._dirwatch_dispatcher,
fs_root, partition,
self._add_server,
self._remove_server)
self._proids = {}
self._servers = set()
self._synced = False
def test_trigger_handler(self):
"""Test handlers."""
# Access protected module
# pylint: disable=W0212
dirwatcher = mock.Mock()
dispatcher = dirwatch.DirWatcherDispatcher(dirwatcher)
last_called = set()
def _created1(_path):
last_called.add('_created1')
def _created2(_path):
last_called.add('_created2')
def _created3(_path):
last_called.add('_created3')
def _modified1(_path):
last_called.add('_modified1')
def _modified2(_path):
last_called.add('_modified2')
def _deleted1(_path):
last_called.add('_deleted1')
dispatcher.register('/path/to/server', {
dirwatch.DirWatcherEvent.CREATED: _created1,
dirwatch.DirWatcherEvent.MODIFIED: _modified1,
dirwatch.DirWatcherEvent.DELETED: _deleted1,
})
dispatcher.register('/path/to/placement', {
dirwatch.DirWatcherEvent.CREATED: _created2,
dirwatch.DirWatcherEvent.MODIFIED: _modified2,
})
dispatcher.register('/path/to/placement/*', {
dirwatch.DirWatcherEvent.CREATED: _created3,
})
dispatcher._on_created('/path/to/server/test')
self.assertEqual(last_called, set(['_created1']))
last_called.clear()
dispatcher._on_modified('/path/to/server/test')
self.assertEqual(last_called, set(['_modified1']))
last_called.clear()
dispatcher._on_deleted('/path/to/server/test')
self.assertEqual(last_called, set(['_deleted1']))
last_called.clear()
dispatcher._on_created('/path/to/placement/test')
self.assertEqual(last_called, set(['_created2']))
last_called.clear()
dispatcher._on_modified('/path/to/placement/test')
self.assertEqual(last_called, set(['_modified2']))
last_called.clear()
dispatcher._on_deleted('/path/to/placement/test')
self.assertEqual(last_called, set())
dispatcher._on_created('/path/to/placement/test/one')
self.assertEqual(last_called, set(['_created3']))
last_called.clear()
