def main(): config = load_config() metrics.init(config, 'iris-process-retention', stats_reset) retention_settings = config.get('retention', {}) if not retention_settings.get('enabled'): logger.info('Retention not enabled, bailing') return engine = create_engine(config['db']['conn']['str'] % config['db']['conn']['kwargs'], **config['db']['kwargs']) max_days = int(retention_settings['max_days']) if max_days < 1: logger.error('Max days needs to at least be 1') return cooldown_time = int(retention_settings['cooldown_time']) batch_size = int(retention_settings['batch_size']) run_interval = int(retention_settings['run_interval']) archive_path = retention_settings['archive_path'] spawn(metrics.emit_forever) while True: logger.info('Starting retention loop (kill messages+incidents older than %d days)', max_days) try: process_retention(engine, max_days=max_days, cooldown_time=cooldown_time, batch_size=batch_size, archive_path=archive_path) except Exception: logger.exception('Hit problem while running retention') logger.info('Waiting %d seconds until next iteration..', run_interval) sleep(run_interval)
def main(): config = load_config() metrics.init(config, 'iris-sync-targets', stats_reset) default_nap_time = 3600 try: nap_time = int(config.get('sync_script_nap_time', default_nap_time)) except ValueError: nap_time = default_nap_time engine = create_engine( config['db']['conn']['str'] % config['db']['conn']['kwargs'], **config['db']['kwargs']) # Initialize these to zero at the start of the app, and don't reset them at every # metrics interval metrics.set('users_found', 0) metrics.set('teams_found', 0) metrics_task = spawn(metrics.emit_forever) while True: if not bool(metrics_task): logger.error('metrics task failed, %s', metrics_task.exception) metrics_task = spawn(metrics.emit_forever) sync(config, engine) logger.info('Sleeping for %d seconds' % nap_time) sleep(nap_time)
def main(): global ldap_timeout config = load_config() metrics.init(config, 'iris-sync-targets', stats_reset) default_ldap_timeout = 20 default_nap_time = 3600 ldap_timeout = int( config.get('sync_script_ldap_timeout', default_ldap_timeout)) try: nap_time = int(config.get('sync_script_nap_time', default_nap_time)) except ValueError: nap_time = default_nap_time engine = create_engine( config['db']['conn']['str'] % config['db']['conn']['kwargs'], **config['db']['kwargs']) # Optionally, maintain an internal list of mailing lists from ldap that can also be # used as targets. ldap_lists = config.get('ldap_lists') # Initialize these to zero at the start of the app, and don't reset them at every # metrics interval metrics.set('users_found', 0) metrics.set('teams_found', 0) metrics.set('ldap_lists_found', 0) metrics.set('ldap_memberships_found', 0) metrics_task = spawn(metrics.emit_forever) while True: if not bool(metrics_task): logger.error('metrics task failed, %s', metrics_task.exception) metrics_task = spawn(metrics.emit_forever) sync_from_oncall(config, engine) # Do ldap mailing list sync *after* we do the normal sync, to ensure we have the users # which will be in ldap already populated. if ldap_lists: if 'ldap_cert_path' in ldap_lists: ldap_cert_path = ldap_lists['ldap_cert_path'] if not os.access(ldap_cert_path, os.R_OK): logger.error("Failed to read ldap_cert_path certificate") raise IOError else: ldap_lists['cert_path'] = ldap_cert_path list_run_start = time.time() sync_ldap_lists(ldap_lists, engine) logger.info('Ldap mailing list sync took %.2f seconds', time.time() - list_run_start) logger.info('Sleeping for %d seconds' % nap_time) sleep(nap_time)
def main(): config = load_config() metrics.init(config, 'iris-application-stats', stats_reset) app_stats_settings = config.get('app-stats', {}) run_interval = int(app_stats_settings['run_interval']) spawn(metrics.emit_forever) db.init(config) while True: logger.info('Starting app stats calculation loop') stats_task() logger.info('Waiting %d seconds until next iteration..', run_interval) sleep(run_interval)
def main(): signal.signal(signal.SIGINT, sigint_handler) from iris.api import get_api, load_config config = load_config() app = get_api(config) server = config['server'] print 'LISTENING: %(host)s:%(port)d' % server server = WSGIServer((server['host'], server['port']), app) if HAS_INOTIFY: fd = inotify.init() for dirname, subfolders, _ in os.walk('.'): if '.git' in subfolders: subfolders.remove('.git') inotify.add_watch(fd, dirname, inotify.IN_MODIFY) gevent.spawn(event_producer, fd, server) else: print 'Missing inotify, disable watch support.' server.serve_forever()
def main(): global config config = load_config() is_master = config['sender'].get('is_master', False) logger.info('[-] bootstraping sender (master: %s)...', is_master) init_sender(config) init_plugins(config.get('plugins', {})) init_vendors(config.get('vendors', []), config.get('applications', [])) send_task = spawn(send) worker_tasks = [spawn(worker) for x in xrange(100)] if is_master: if should_mock_gwatch_renewer: spawn(mock_gwatch_renewer) else: spawn(gwatch_renewer) spawn(prune_old_audit_logs_worker) rpc.init(config['sender'], dict(send_message=send_message)) rpc.run(config['sender']) interval = 60 logger.info('[*] sender bootstrapped') while True: runtime = int(time.time()) logger.info('--> sender looop started.') cache.refresh() cache.purge() if is_master: try: escalate() deactivate() poll() aggregate(runtime) except Exception: metrics.incr('task_failure') logger.exception("Exception occured in main loop.") # check status for all background greenlets and respawn if necessary if not bool(send_task): logger.error("send task failed, %s", send_task.exception) metrics.incr('task_failure') send_task = spawn(send) bad_workers = [] for i, task in enumerate(worker_tasks): if not bool(task): logger.error("worker task failed, %s", task.exception) metrics.incr('task_failure') bad_workers.append(i) for i in bad_workers: worker_tasks[i] = spawn(worker) spawn(metrics.emit) now = time.time() elapsed_time = now - runtime nap_time = max(0, interval - elapsed_time) logger.info( '--> sender loop finished in %s seconds - sleeping %s seconds', elapsed_time, nap_time) sleep(nap_time)
def main(): global config config = load_config() start_time = time.time() logger.info('[-] bootstraping sender...') init_sender(config) init_plugins(config.get('plugins', {})) init_vendors(config.get('vendors', []), config.get('applications', [])) send_task = spawn(send) worker_tasks = [spawn(worker) for x in xrange(100)] rpc.init(config['sender'], dict(send_message=send_message)) rpc.run(config['sender']) spawn(coordinator.update_forever) gwatch_renewer_task = None prune_audit_logs_task = None interval = 60 logger.info('[*] sender bootstrapped') while True: runtime = int(time.time()) logger.info('--> sender looop started.') cache.refresh() cache.purge() # If we're currently a master, ensure our master-greenlets are running # and we're doing the master duties if coordinator.am_i_master(): if not bool(gwatch_renewer_task): if should_mock_gwatch_renewer: gwatch_renewer_task = spawn(mock_gwatch_renewer) else: gwatch_renewer_task = spawn(gwatch_renewer) if not bool(prune_audit_logs_task): prune_audit_logs_task = spawn(prune_old_audit_logs_worker) try: escalate() deactivate() poll() aggregate(runtime) except Exception: metrics.incr('task_failure') logger.exception("Exception occured in main loop.") # If we're not master, don't do the master tasks and make sure those other # greenlets are stopped if they're running else: logger.info('I am not the master so I am not doing master sender tasks.') # Stop these task greenlets if they're running. Technically this should # never happen because if we're the master, we'll likely only stop being the # master if our process exits, which would kill these greenlets anyway. if bool(gwatch_renewer_task): logger.info('I am not master anymore so stopping the gwatch renewer') gwatch_renewer_task.kill() if bool(prune_audit_logs_task): logger.info('I am not master anymore so stopping the audit logs worker') prune_audit_logs_task.kill() # check status for all background greenlets and respawn if necessary if not bool(send_task): logger.error("send task failed, %s", send_task.exception) metrics.incr('task_failure') send_task = spawn(send) bad_workers = [] for i, task in enumerate(worker_tasks): if not bool(task): logger.error("worker task failed, %s", task.exception) metrics.incr('task_failure') bad_workers.append(i) for i in bad_workers: worker_tasks[i] = spawn(worker) now = time.time() metrics.set('sender_uptime', int(now - start_time)) spawn(metrics.emit) elapsed_time = now - runtime nap_time = max(0, interval - elapsed_time) logger.info('--> sender loop finished in %s seconds - sleeping %s seconds', elapsed_time, nap_time) sleep(nap_time)
def main(): global ldap_timeout global ldap_pagination_size global update_sleep config = load_config() metrics.init(config, 'iris-sync-targets', stats_reset) default_ldap_timeout = 60 default_ldap_pagination_size = 400 default_update_sleep = 0 default_ldap_nap_time = 3600 default_oncall_nap_time = 60 ldap_timeout = int(config.get('sync_script_ldap_timeout', default_ldap_timeout)) ldap_pagination_size = int(config.get('sync_script_ldap_pagination_size', default_ldap_pagination_size)) update_sleep = float(config.get('target_update_pause', default_update_sleep)) try: ldap_nap_time = int(config.get('sync_script_ldap_nap_time', default_ldap_nap_time)) oncall_nap_time = int(config.get('sync_script_oncall_nap_time', default_oncall_nap_time)) except ValueError: ldap_nap_time = default_ldap_nap_time oncall_nap_time = default_oncall_nap_time # check if we are using special connection settings for this script if config.get('db_target_sync'): engine = create_engine(config['db_target_sync']['conn']['str'] % config['db_target_sync']['conn']['kwargs'], **config['db_target_sync']['kwargs']) else: engine = create_engine(config['db']['conn']['str'] % config['db']['conn']['kwargs'], **config['db']['kwargs']) # Optionally, maintain an internal list of mailing lists from ldap that can also be # used as targets. ldap_lists = config.get('ldap_lists') # Initialize these to zero at the start of the app, and don't reset them at every # metrics interval metrics.set('users_found', 0) metrics.set('teams_found', 0) metrics.set('ldap_lists_found', 0) metrics.set('ldap_memberships_found', 0) metrics_task = spawn(metrics.emit_forever) oncall_task = spawn(oncall_sync_loop, config, engine, oncall_nap_time) if ldap_lists: if 'ldap_cert_path' in ldap_lists: ldap_cert_path = ldap_lists['ldap_cert_path'] if not os.access(ldap_cert_path, os.R_OK): logger.error("Failed to read ldap_cert_path certificate") raise IOError else: ldap_lists['cert_path'] = ldap_cert_path ldap_task = spawn(ldap_sync_loop, ldap_lists, engine, ldap_nap_time) while True: if not bool(metrics_task): metrics.incr('failed_tasks') logger.error('metrics task failed, %s', metrics_task.exception) spawn(metrics.emit_forever) if not bool(oncall_task): metrics.incr('failed_tasks') logger.error('oncall task failed, %s', oncall_task.exception) metrics_task = spawn(oncall_sync_loop, config, engine, oncall_nap_time) if ldap_lists: if not bool(ldap_task): metrics.incr('failed_tasks') logger.error('ldap task failed, %s', ldap_task.exception) ldap_task = spawn(ldap_sync_loop, ldap_lists, engine, ldap_nap_time) sleep(10)