def main(): cti_config.init_cli_config(sys.argv[1:]) cti_config.init_config_file() cti_config.init_auth_config() xivo_dao.init_db_from_config(config) cti_config.update_db_config() user = config.get('user') if user: change_user(user) setup_logging(config['logfile'], config['foreground'], config['debug']) silence_loggers( ['amqp', 'urllib3', 'Flask-Cors', 'kombu', 'stevedore.extension'], logging.WARNING) xivo_uuid = get_xivo_uuid(logger) register_class.setup(xivo_uuid) ctid = context.get('cti_server') ctid.setup() with ServiceCatalogRegistration('xivo-ctid', xivo_uuid, config['consul'], config['service_discovery'], config['bus'], partial(self_check, config)): ctid.run()
def run(self): self.services = plugin_manager.load_services( self.config, self.config['enabled_plugins']['services'], self._source_manager, self.bus, self, ) plugin_manager.load_views( self.config, self.config['enabled_plugins']['views'], self.services, self.auth_client, self.status_aggregator, ) self._source_manager.set_source_service(self.services['source']) self.status_aggregator.add_provider(self.bus.provide_status) signal.signal(signal.SIGTERM, _signal_handler) with self.token_renewer: with ServiceCatalogRegistration( *self._service_registration_params): self.bus.start() try: self.rest_api.run() finally: plugin_manager.unload_views() plugin_manager.unload_services() self._source_manager.unload_sources() self.bus.stop()
def run(self): logger.info('wazo-calld starting...') self.token_renewer.subscribe_to_token_change(self.token_status.token_change_callback) self.status_aggregator.add_provider(self.ari.provide_status) self.status_aggregator.add_provider(self.bus_consumer.provide_status) self.status_aggregator.add_provider(self.token_status.provide_status) collectd_thread = Thread(target=self.collectd.run, name='collectd_thread') collectd_thread.start() ari_thread = Thread(target=self.ari.run, name='ari_thread') ari_thread.start() asyncio_thread = Thread(target=self.asyncio.run, name='asyncio_thread') asyncio_thread.start() try: with self.token_renewer: with self.bus_consumer: with ServiceCatalogRegistration(*self._service_registration_params): self.http_server.run() finally: logger.info('wazo-calld stopping...') self._pubsub.publish('stopping', None) self.asyncio.stop() self.ari.stop() self.collectd.stop() logger.debug('joining asyncio thread') asyncio_thread.join() logger.debug('joining ari thread') ari_thread.join() logger.debug('joining collectd thread') collectd_thread.join() logger.debug('done joining')
def run(self): logger.info('wazo-confd running...') xivo_dao.init_db_from_config(self.config) signal.signal(signal.SIGTERM, partial(_sigterm_handler, self)) with self.token_renewer: with ServiceCatalogRegistration(*self._service_discovery_args): self.http_server.run()
def run(self): signal.signal(signal.SIGTERM, partial(_sigterm_handler, self)) with bus.publisher_thread(self._bus_publisher): with ServiceCatalogRegistration(*self._service_discovery_args): self._expired_token_remover.run() local_token_renewer = self._get_local_token_renewer() self._config['local_token_renewer'] = local_token_renewer self._rest_api.run() local_token_renewer.revoke_token()
def run(self): logger.info('wazo-chatd starting...') self.status_aggregator.add_provider(self.bus_consumer.provide_status) self.status_aggregator.add_provider(auth.provide_status) signal.signal(signal.SIGTERM, partial(_sigterm_handler, self)) with self.thread_manager: with self.token_renewer: with self.bus_consumer: with ServiceCatalogRegistration( *self._service_discovery_args): self.rest_api.run()
def run(self): logger.info('wazo-setupd starting...') signal.signal(signal.SIGTERM, partial(_sigterm_handler, self)) self.stopper_thread.start() try: with ServiceCatalogRegistration(*self._service_discovery_args): self.rest_api.run() finally: logger.info('wazo-setupd stopping...') logger.debug('joining stopper thread') self.stopper.cancel() self.stopper_thread.join()
def run(self): logger.debug('xivo-confd running...') xivo_dao.init_db_from_config(self.config) app = setup_app(self.config) with ServiceCatalogRegistration('xivo-confd', self.config['uuid'], self.config['consul'], self.config['service_discovery'], self.config['bus'], partial(self_check, self.config)): run_server(app)
def run(self): logger.info('wazo-webhookd starting...') signal.signal(signal.SIGTERM, partial(_sigterm_handler, self)) bus_consumer_thread = Thread(target=self._bus_consumer.run, name='bus_consumer_thread') bus_consumer_thread.start() try: with ServiceCatalogRegistration(*self._service_discovery_args): self.rest_api.run() finally: logger.info('wazo-webhookd stopping...') self._bus_consumer.should_stop = True self._celery_process.terminate() logger.debug('waiting for remaining threads/subprocesses...') bus_consumer_thread.join() self._celery_process.join() logger.debug('all threads and subprocesses stopped.')
def main(): advertise_address = os.getenv('ADVERTISE_ADDR', 'auto') enabled = os.getenv('DISABLED', '0') == '0' logger.debug('advertise addr: %s', advertise_address) logger.debug('enabled: %s', enabled) config = { 'consul': { 'host': 'consul', 'port': 8500, 'token': 'the_one_ring' }, 'service_discovery': { 'advertise_address': advertise_address, 'advertise_address_interface': 'eth0', 'advertise_port': 6262, 'ttl_interval': 30, 'refresh_interval': 27, 'retry_interval': 2, }, 'bus': { 'username': '******', 'password': '******', 'host': 'rabbitmq', 'port': 5672, 'exchange_name': 'xivo', 'exchange_type': 'topic', }, 'uuid': UUID, } if not enabled: config['service_discovery']['enabled'] = False signal.signal(signal.SIGTERM, handler) with ServiceCatalogRegistration( 'myservice', config['uuid'], config['consul'], config['service_discovery'], config['bus'], self_check, ): app.run(host="0.0.0.0", port=6262)
def run(self): logger.info('xivo-ctid-ng starting...') self.token_renewer.subscribe_to_token_change( self.token_status.token_change_callback) self.status_aggregator.add_provider(self.ari.provide_status) self.status_aggregator.add_provider(self.bus_consumer.provide_status) self.status_aggregator.add_provider(self.token_status.provide_status) bus_producer_thread = Thread(target=self.bus_publisher.run, name='bus_producer_thread') bus_producer_thread.start() collectd_thread = Thread(target=self.collectd.run, name='collectd_thread') collectd_thread.start() bus_consumer_thread = Thread(target=self.bus_consumer.run, name='bus_consumer_thread') bus_consumer_thread.start() ari_thread = Thread(target=self.ari.run, name='ari_thread') ari_thread.start() try: with self.token_renewer: with ServiceCatalogRegistration( *self._service_registration_params): self.rest_api.run() finally: logger.info('xivo-ctid-ng stopping...') self.ari.stop() self.bus_consumer.should_stop = True self.collectd.stop() self.bus_publisher.stop() logger.debug('joining ari thread') ari_thread.join() logger.debug('joining bus consumer thread') bus_consumer_thread.join() logger.debug('joining collectd thread') collectd_thread.join() logger.debug('joining bus producer thread') bus_producer_thread.join() logger.debug('joining rest api threads') self.rest_api.join() logger.debug('done joining')
def run(self): logger.debug('starting http server') signal.signal(signal.SIGTERM, _signal_handler) publisher_thread = Thread(target=self._publisher.run) publisher_thread.start() with ServiceCatalogRegistration( 'wazo-plugind', self._xivo_uuid, self._consul_config, self._service_discovery_config, self._bus_config, partial(self_check, self._listen_port), ): try: self._server.start() except (KeyboardInterrupt, SystemExit): logger.info('Main process stopping') finally: self._server.stop() self._executor.shutdown() self._publisher.stop() publisher_thread.join()
def run(self): signal.signal(signal.SIGTERM, partial(_sigterm_handler, self)) with db_ready( timeout=self._config['db_connect_retry_timeout_seconds']): self._default_policy_service.update_policies() self._all_users_service.update_policies() self._default_policy_service.delete_orphan_policies() http.init_top_tenant(self.dao) if self._config['bootstrap_user_on_startup']: bootstrap.create_initial_user( self._config['db_uri'], self._config['bootstrap_user_username'], self._config['bootstrap_user_password'], self._config.get('bootstrap_user_purpose') or bootstrap.PURPOSE, self._config.get('bootstrap_user_policy_slug') or bootstrap.DEFAULT_POLICY_SLUG, ) with bus.publisher_thread(self._bus_publisher): with ServiceCatalogRegistration(*self._service_discovery_args): self._expired_token_remover.start() self._rest_api.run()
def _run(config): _init_signal() xivo_uuid = config['uuid'] agent_dao = AgentDAOAdapter(orig_agent_dao) queue_dao = QueueDAOAdapter(orig_queue_dao) exten_features_dao = ExtenFeaturesDAOAdapter(asterisk_conf_dao) amid_client = AmidClient(**config['amid']) auth_client = AuthClient(**config['auth']) token_renewer = TokenRenewer(auth_client) token_renewer.subscribe_to_token_change(amid_client.set_token) token_renewer.subscribe_to_token_change(auth_client.set_token) bus_consumer = BusConsumer(**config['bus']) bus_publisher = BusPublisherWithQueue(**config['bus'], service_uuid=xivo_uuid) blf_manager = BLFManager(amid_client, exten_features_dao) queue_log_manager = QueueLogManager(queue_log_dao) add_to_queue_action = AddToQueueAction(amid_client, agent_status_dao) login_action = LoginAction( amid_client, queue_log_manager, blf_manager, agent_status_dao, line_dao, user_dao, agent_dao, bus_publisher, ) pause_action = PauseAction(amid_client) pause_manager = PauseManager(pause_action, agent_dao) logoff_action = LogoffAction( amid_client, queue_log_manager, blf_manager, pause_manager, agent_status_dao, user_dao, agent_dao, bus_publisher, ) remove_from_queue_action = RemoveFromQueueAction(amid_client, agent_status_dao) update_penalty_action = UpdatePenaltyAction(amid_client, agent_status_dao) add_member_manager = AddMemberManager( add_to_queue_action, amid_client, agent_status_dao, queue_member_dao ) login_manager = LoginManager(login_action, agent_status_dao, context_dao, line_dao) logoff_manager = LogoffManager(logoff_action, agent_dao, agent_status_dao) on_agent_deleted_manager = OnAgentDeletedManager(logoff_manager, agent_status_dao) on_agent_updated_manager = OnAgentUpdatedManager( add_to_queue_action, remove_from_queue_action, update_penalty_action, agent_status_dao, ) on_queue_added_manager = OnQueueAddedManager(add_to_queue_action, agent_status_dao) on_queue_deleted_manager = OnQueueDeletedManager(agent_status_dao) on_queue_updated_manager = OnQueueUpdatedManager( add_to_queue_action, remove_from_queue_action, agent_status_dao ) on_queue_agent_paused_manager = OnQueueAgentPausedManager( agent_status_dao, user_dao, agent_dao, bus_publisher ) relog_manager = RelogManager( login_action, logoff_action, agent_dao, agent_status_dao ) remove_member_manager = RemoveMemberManager( remove_from_queue_action, amid_client, agent_status_dao, queue_member_dao ) service_proxy = ServiceProxy() service_proxy.login_handler = LoginHandler(login_manager, agent_dao) service_proxy.logoff_handler = LogoffHandler(logoff_manager, agent_status_dao) service_proxy.membership_handler = MembershipHandler( add_member_manager, remove_member_manager, agent_dao, queue_dao ) service_proxy.on_agent_handler = OnAgentHandler( on_agent_deleted_manager, on_agent_updated_manager, agent_dao ) service_proxy.on_queue_handler = OnQueueHandler( on_queue_added_manager, on_queue_updated_manager, on_queue_deleted_manager, on_queue_agent_paused_manager, queue_dao, agent_dao, ) service_proxy.pause_handler = PauseHandler(pause_manager, agent_status_dao) service_proxy.relog_handler = RelogHandler(relog_manager) service_proxy.status_handler = StatusHandler(agent_dao, agent_status_dao, xivo_uuid) _init_bus_consume(bus_consumer, service_proxy) http_iface = http.HTTPInterface(config, service_proxy, auth_client) service_discovery_args = [ 'wazo-agentd', xivo_uuid, config['consul'], config['service_discovery'], config['bus'], partial(self_check, config['rest_api']), ] try: with token_renewer: with bus_consumer, bus_publisher: with ServiceCatalogRegistration(*service_discovery_args): http_iface.run() finally: logger.info('wazo-agentd stopping...')
def _run(config): _init_signal() xivo_uuid = config['uuid'] agent_dao = AgentDAOAdapter(orig_agent_dao) queue_dao = QueueDAOAdapter(orig_queue_dao) auth_client = AuthClient(**config['auth']) token_renewer = TokenRenewer(auth_client) token_renewer.subscribe_to_token_change(auth_client.set_token) with _new_ami_client(config) as ami_client: with _new_bus_connection(config) as producer_conn, _new_bus_connection( config) as consumer_conn: bus_exchange = Exchange(config['bus']['exchange_name'], type=config['bus']['exchange_type']) bus_producer = Producer(producer_conn, exchange=bus_exchange, auto_declare=True) bus_marshaler = Marshaler(xivo_uuid) bus_publisher = Publisher(bus_producer, bus_marshaler) queue_log_manager = QueueLogManager(queue_log_dao) add_to_queue_action = AddToQueueAction(ami_client, agent_status_dao) login_action = LoginAction(ami_client, queue_log_manager, agent_status_dao, line_dao, user_dao, bus_publisher) logoff_action = LogoffAction(ami_client, queue_log_manager, agent_status_dao, user_dao, bus_publisher) pause_action = PauseAction(ami_client) remove_from_queue_action = RemoveFromQueueAction( ami_client, agent_status_dao) update_penalty_action = UpdatePenaltyAction( ami_client, agent_status_dao) add_member_manager = AddMemberManager(add_to_queue_action, ami_client, agent_status_dao, queue_member_dao) login_manager = LoginManager(login_action, agent_status_dao, context_dao) logoff_manager = LogoffManager(logoff_action, agent_status_dao) on_agent_deleted_manager = OnAgentDeletedManager( logoff_manager, agent_status_dao) on_agent_updated_manager = OnAgentUpdatedManager( add_to_queue_action, remove_from_queue_action, update_penalty_action, agent_status_dao) on_queue_added_manager = OnQueueAddedManager( add_to_queue_action, agent_status_dao) on_queue_deleted_manager = OnQueueDeletedManager(agent_status_dao) on_queue_updated_manager = OnQueueUpdatedManager( add_to_queue_action, remove_from_queue_action, agent_status_dao) on_queue_agent_paused_manager = OnQueueAgentPausedManager( agent_status_dao, user_dao, bus_publisher) pause_manager = PauseManager(pause_action) relog_manager = RelogManager(login_action, logoff_action, agent_dao, agent_status_dao) remove_member_manager = RemoveMemberManager( remove_from_queue_action, ami_client, agent_status_dao, queue_member_dao) service_proxy = ServiceProxy() service_proxy.login_handler = LoginHandler(login_manager, agent_dao) service_proxy.logoff_handler = LogoffHandler( logoff_manager, agent_status_dao) service_proxy.membership_handler = MembershipHandler( add_member_manager, remove_member_manager, agent_dao, queue_dao) service_proxy.on_agent_handler = OnAgentHandler( on_agent_deleted_manager, on_agent_updated_manager, agent_dao) service_proxy.on_queue_handler = OnQueueHandler( on_queue_added_manager, on_queue_updated_manager, on_queue_deleted_manager, on_queue_agent_paused_manager, queue_dao, agent_dao) service_proxy.pause_handler = PauseHandler(pause_manager, agent_status_dao) service_proxy.relog_handler = RelogHandler(relog_manager) service_proxy.status_handler = StatusHandler( agent_dao, agent_status_dao, xivo_uuid) amqp_iface = amqp.AMQPInterface(consumer_conn, bus_exchange, service_proxy) http_iface = http.HTTPInterface(config, service_proxy, auth_client) amqp_iface.start() try: with token_renewer: with ServiceCatalogRegistration( 'xivo-agentd', xivo_uuid, config['consul'], config['service_discovery'], config['bus'], partial(self_check, config['rest_api']['https']['port'])): http_iface.run() finally: amqp_iface.stop()