def run(self):
"""Runs the master (once it is elected leader)."""
lock = zkutils.make_lock(self.backend.zkclient,
z.path.election(__name__))
_LOGGER.info('Waiting for leader lock.')
with lock:
self.run_loop()
def cleanup(interval, trace_service_events_max_count, trace_batch_size,
trace_expire_after, trace_history_max_count,
finished_batch_size, finished_expire_after,
finished_history_max_count, no_lock):
"""Cleans up old traces."""
def _cleanup():
"""Do cleanup."""
while True:
zk.prune_trace(context.GLOBAL.zk.conn,
trace_service_events_max_count)
zk.cleanup_trace(context.GLOBAL.zk.conn, trace_batch_size,
trace_expire_after)
zk.cleanup_finished(context.GLOBAL.zk.conn,
finished_batch_size, finished_expire_after)
zk.cleanup_trace_history(context.GLOBAL.zk.conn,
trace_history_max_count)
zk.cleanup_finished_history(context.GLOBAL.zk.conn,
finished_history_max_count)
_LOGGER.info('Finished cleanup, sleep %s sec', interval)
time.sleep(interval)
if no_lock:
_cleanup()
else:
lock = zkutils.make_lock(context.GLOBAL.zk.conn,
z.path.election(__name__))
_LOGGER.info('Waiting for leader lock.')
with lock:
_cleanup()
def run(self, once=False, has_lock=True):
"""Runs the master (once it is elected leader)."""
if has_lock:
lock = zkutils.make_lock(self.backend.zkclient,
z.path.election(__name__))
_LOGGER.info('Waiting for leader lock.')
with lock:
self.run_loop(once)
else:
self.run_loop(once)
def top(no_lock):
"""Sync LDAP data with Zookeeper data."""
if not no_lock:
lock = zkutils.make_lock(context.GLOBAL.zk.conn,
z.path.election(__name__))
_LOGGER.info('Waiting for leader lock.')
with lock:
_run_sync()
else:
_LOGGER.info('Running without lock.')
_run_sync()
def top(no_lock, api, approot, once):
"""Sync LDAP data with Zookeeper data."""
tm_env = appenv.AppEnvironment(root=approot)
if not no_lock:
lock = zkutils.make_lock(context.GLOBAL.zk.conn,
z.path.election(__name__))
_LOGGER.info('Waiting for leader lock.')
with lock:
_run_sync(api, tm_env.alerts_dir, once)
else:
_LOGGER.info('Running without lock.')
_run_sync(api, tm_env.alerts_dir, once)
def run(out_dir, interval, no_lock):
"""Export scheduler reports from ZooKeeper to disk."""
zkclient = context.GLOBAL.zk.conn
out_dir = out_dir or '.'
fs.mkdir_safe(out_dir, mode=0o755)
if interval:
if no_lock:
run_reactor(out_dir, interval, zkclient)
else:
lock = zkutils.make_lock(zkclient, z.path.election(__name__))
_LOGGER.info('Waiting for leader lock.')
with lock:
run_reactor(out_dir, interval, zkclient)
else:
export_reports(out_dir, zkclient)
def run(no_lock):
"""Run Treadmill master scheduler."""
zkclient = context.GLOBAL.zk.conn
zkclient.ensure_path(z.CRON_JOBS)
if no_lock:
_do_watch(zkclient)
reactor.run()
else:
lock = zkutils.make_lock(
zkclient, z.path.election(__name__)
)
_LOGGER.info('Waiting for leader lock.')
with lock:
_do_watch(zkclient)
reactor.run()
def gmsa_sync(fs_root, partition, group_ou, group_pattern, no_lock):
"""Sync placements GMSA groups."""
# keep sleeping until zksync ready
zksync_utils.wait_for_ready(fs_root)
watch = gmsa.HostGroupWatch(fs_root, partition, group_ou,
group_pattern)
if not no_lock:
lock = zkutils.make_lock(context.GLOBAL.zk.conn,
z.path.election(__name__))
_LOGGER.info('Waiting for leader lock.')
with lock:
watch.run()
else:
_LOGGER.info('Running without lock.')
watch.run()
def cleanup(interval, no_lock):
"""Cleans up old tasks."""
def _cleanup():
"""Do cleanup."""
while True:
zk.cleanup(context.GLOBAL.zk.conn)
_LOGGER.info('Finished cleanup, sleep %s sec', interval)
time.sleep(interval)
if no_lock:
_cleanup()
else:
lock = zkutils.make_lock(context.GLOBAL.zk.conn,
z.path.election(__name__))
_LOGGER.info('Waiting for leader lock.')
with lock:
_cleanup()
def run(no_lock, proid, root):
"""Run Treadmill DNS endpoint engine.
"""
zkclient = context.GLOBAL.zk.conn
zkendpointpath = z.join_zookeeper_path(z.ENDPOINTS, proid)
zkclient.ensure_path(zkendpointpath)
zk2fs_endpointpath = '{}{}'.format(root, zkendpointpath)
if not os.path.isabs(zk2fs_endpointpath):
_LOGGER.error('Invalid path: %s', zk2fs_endpointpath)
sys.exit(1)
if no_lock:
_do_watch(zkclient=zkclient,
zkfs_dir=zk2fs_endpointpath)
else:
lock = zkutils.make_lock(
zkclient, z.path.election(__name__)
)
_LOGGER.info('Waiting for leader lock.')
with lock:
_do_watch(zkclient=zkclient,
zkfs_dir=zk2fs_endpointpath)
