def __init__(self, config):
self.config = config
self._bus_consumer = BusConsumer(config['bus'])
self._service_discovery_args = [
'wazo-confd',
config['uuid'],
config['consul'],
config['service_discovery'],
config['bus'],
partial(self_check, config),
]
self.http_server = HTTPServer(config)
auth_client = AuthClient(**config['auth'])
self.token_renewer = TokenRenewer(auth_client)
if not app.config['auth'].get('master_tenant_uuid'):
self.token_renewer.subscribe_to_next_token_details_change(
auth.init_master_tenant)
pjsip_doc = PJSIPDoc(config['pjsip_config_doc_filename'])
plugin_helpers.load(
namespace='wazo_confd.plugins',
names=config['enabled_plugins'],
dependencies={
'api': api,
'config': config,
'token_changed_subscribe':
self.token_renewer.subscribe_to_token_change,
'bus_consumer': self._bus_consumer,
'auth_client': auth_client,
'pjsip_doc': pjsip_doc,
},
)
def __init__(self, config):
self.config = config
self._service_discovery_args = [
'wazo-confd',
config['uuid'],
config['consul'],
config['service_discovery'],
config['bus'],
partial(self_check, config),
]
auth_client = AuthClient(**config['auth'])
self.token_renewer = TokenRenewer(auth_client)
self.http_server = HTTPServer(config)
plugin_helpers.load(
namespace='wazo_confd.plugins',
names=config['enabled_plugins'],
dependencies={
'api':
api,
'config':
config,
'token_changed_subscribe':
self.token_renewer.subscribe_to_token_change,
},
)
def __init__(self, config):
self._service_discovery_args = [
'wazo-webhookd',
config.get('uuid'),
config['consul'],
config['service_discovery'],
config['bus'],
lambda: True,
]
self._bus_consumer = CoreBusConsumer(config)
self._celery_worker = CoreCeleryWorker(config)
self._celery_process = Process(target=self._celery_worker.run,
name='celery_process')
self.rest_api = CoreRestApi(config)
self._service_manager = plugin_helpers.load(
namespace='wazo_webhookd.services',
names=config['enabled_services'],
dependencies={
'api': api,
'bus_consumer': self._bus_consumer,
'celery': celery_app,
'config': config,
})
plugin_helpers.load(namespace='wazo_webhookd.plugins',
names=config['enabled_plugins'],
dependencies={
'api': api,
'bus_consumer': self._bus_consumer,
'config': config,
'service_manager': self._service_manager,
})
def __init__(self, config):
self.server = Server(config)
plugin_helpers.load(namespace='wazo_admin_ui.plugins',
names=config['enabled_plugins'],
dependencies={
'config': config,
'flask': self.server.get_app(),
})
def __init__(self, config):
self.server = CoreHTTP(config)
self.websocket_consumer = websocket.Consumer(config)
self.thread_manager = ThreadManager()
plugin_helpers.load(namespace='wazo_demo_programmable.plugins',
names=config['enabled_plugins'],
dependencies={
'config': config,
'websocket_consumer': self.websocket_consumer,
'flask': self.server.get_app(),
})
init_db(config['db_uri'])
def load(self, dependencies):
enabled_plugins = dependencies['config_plugins']['enabled_plugins']
app = dependencies['flask']
plugin_helpers.load(namespace='wazo_engine.plugins',
names=enabled_plugins,
dependencies={
'flask': app,
'clients': engine_clients
})
ErrorExtractor.register_url_to_name_resources(URL_TO_NAME_RESOURCES)
ErrorTranslator.register_resources(RESOURCES)
ConfdErrorExtractor.register_generic_patterns(GENERIC_PATTERN_ERRORS)
ConfdErrorExtractor.register_specific_patterns(SPECIFIC_PATTERN_ERRORS)
register_destination_form('application', l_('Application'),
ApplicationDestination)
register_destination_form('hangup', l_('Hangup'), HangupDestination)
register_destination_form('custom', l_('Custom'), CustomDestination)
register_destination_form('none',
l_('None'),
NoneDestination,
position=0)
register_destination_form_application(
'callback_disa',
l_('CallBack DISA'),
ApplicationCallBackDISADestination,
)
register_destination_form_application(
'directory',
l_('Directory'),
ApplicationDirectoryDestination,
)
register_destination_form_application(
'disa',
l_('DISA'),
ApplicationDISADestination,
)
register_destination_form_application(
'fax_to_mail',
l_('Fax to Mail'),
ApplicationFaxToMailDestination,
)
register_destination_form_application(
'voicemail',
l_('Voicemail'),
ApplicationVoicemailDestination,
)
def __init__(self, config):
self.config = config
set_xivo_uuid(config, logger)
self.bus_consumer = CoreBusConsumer(config)
self.status_aggregator = StatusAggregator()
self.http_server = HTTPServer(self.config)
self.http_server.app.config['authorized_subnets'] = self.config[
'rest_api']['authorized_subnets']
auth_client = AuthClient(**config['auth'])
auth_verifier.set_client(auth_client)
self.token_renewer = TokenRenewer(auth_client)
self.token_renewer.subscribe_to_token_change(self._on_token_change)
self.token_status = TokenStatus()
self.token_renewer.subscribe_to_token_change(
self.token_status.token_change_callback)
self.phone_plugins = []
self.plugin_manager = plugin_helpers.load(
namespace='wazo_phoned.plugins',
names=config['enabled_plugins'],
dependencies={
'config': config,
'app': self.http_server.app,
'token_changed_subscribe':
self.token_renewer.subscribe_to_token_change,
'bus_consumer': self.bus_consumer,
'status_aggregator': self.status_aggregator,
'phone_plugins': self.phone_plugins,
},
)
def __init__(self, config):
init_db(config['db_uri'])
self._service_discovery_args = [
'wazo-chatd',
config['uuid'],
config['consul'],
config['service_discovery'],
config['bus'],
lambda: True,
]
self.status_aggregator = StatusAggregator()
self.rest_api = CoreRestApi(config)
self.bus_consumer = BusConsumer(name='chatd.consumer', **config['bus'])
self.bus_publisher = BusPublisher(name='chatd.publisher',
service_uuid=config['uuid'],
**config['bus'])
self.thread_manager = ThreadManager()
auth_client = AuthClient(**config['auth'])
self.token_renewer = TokenRenewer(auth_client)
if not app.config['auth'].get('master_tenant_uuid'):
self.token_renewer.subscribe_to_next_token_details_change(
auth.init_master_tenant)
plugin_helpers.load(
namespace='wazo_chatd.plugins',
names=config['enabled_plugins'],
dependencies={
'api':
api,
'config':
config,
'dao':
DAO(),
'bus_consumer':
self.bus_consumer,
'bus_publisher':
self.bus_publisher,
'status_aggregator':
self.status_aggregator,
'thread_manager':
self.thread_manager,
'token_changed_subscribe':
self.token_renewer.subscribe_to_token_change,
'next_token_changed_subscribe':
self.token_renewer.subscribe_to_next_token_change,
},
)
def __init__(self, config):
xivo_uuid = get_xivo_uuid(logger)
auth_config = dict(config['auth'])
auth_config.pop('key_file', None)
auth_client = AuthClient(**auth_config)
self.ari = CoreARI(config['ari'])
self.bus_publisher = CoreBusPublisher(config)
self.bus_consumer = CoreBusConsumer(config)
self.collectd = CoreCollectd(config)
self.rest_api = CoreRestApi(config)
self.status_aggregator = StatusAggregator()
self.token_renewer = TokenRenewer(auth_client)
self.token_status = TokenStatus()
self._service_registration_params = [
'xivo-ctid-ng', xivo_uuid, config['consul'],
config['service_discovery'], config['bus'],
partial(self_check, config['rest_api']['port'])
]
plugin_helpers.load(
namespace='xivo_ctid_ng.plugins',
names=config['enabled_plugins'],
dependencies={
'api':
api,
'adapter_api':
adapter_api,
'ari':
self.ari,
'bus_publisher':
self.bus_publisher,
'bus_consumer':
self.bus_consumer,
'collectd':
self.collectd,
'config':
config,
'status_aggregator':
self.status_aggregator,
'token_changed_subscribe':
self.token_renewer.subscribe_to_token_change,
'next_token_changed_subscribe':
self.token_renewer.subscribe_to_next_token_change,
})
def setUp(self, config):
self.authentication_service = Mock(services.AuthenticationService)
self.user_service = Mock(services.UserService)
self.policy_service = Mock()
self.tenant_service = Mock(services.TenantService)
token_service = Mock()
group_service = Mock()
self.email_service = Mock(services.EmailService)
external_auth_service = Mock()
self.tokens = Mock()
self.users = Mock()
self.session_service = Mock()
self.status_aggregator = Mock()
self.template_formatter = Mock()
app = Flask('wazo-auth')
app.config['token_service'] = token_service
app.config['user_service'] = self.user_service
api = Api(app, prefix='/0.1')
dependencies = {
'api': api,
'authentication_service': self.authentication_service,
'config': config,
'backends': s.backends,
'policy_service': self.policy_service,
'token_service': token_service,
'user_service': self.user_service,
'tenant_service': self.tenant_service,
'group_service': group_service,
'email_service': self.email_service,
'external_auth_service': external_auth_service,
'tokens': self.tokens,
'users': self.users,
'session_service': self.session_service,
'status_aggregator': self.status_aggregator,
'template_formatter': self.template_formatter,
}
plugin_helpers.load(
namespace='wazo_auth.http',
names=config['enabled_http_plugins'],
dependencies=dependencies,
)
self.app = app.test_client()
def __init__(self, config):
xivo_uuid = get_xivo_uuid(logger)
auth_client = AuthClient(**config['auth'])
self.ari = CoreARI(config['ari'])
self.asyncio = CoreAsyncio()
self.bus_consumer = CoreBusConsumer(**config['bus'])
self.bus_publisher = CoreBusPublisher(service_uuid=config['uuid'], **config['bus'])
self.collectd = CoreCollectd(config)
self.http_server = HTTPServer(config)
self.status_aggregator = StatusAggregator()
self.token_renewer = TokenRenewer(auth_client)
self.token_status = TokenStatus()
self._service_registration_params = ['wazo-calld',
xivo_uuid,
config['consul'],
config['service_discovery'],
config['bus'],
partial(self_check, config)]
self._pubsub = pubsub.Pubsub()
plugin_helpers.load(
namespace='wazo_calld.plugins',
names=config['enabled_plugins'],
dependencies={
'api': api,
'ari': self.ari,
'asyncio': self.asyncio,
'bus_publisher': self.bus_publisher,
'bus_consumer': self.bus_consumer,
'collectd': self.collectd,
'config': config,
'status_aggregator': self.status_aggregator,
'pubsub': self._pubsub,
'token_changed_subscribe': self.token_renewer.subscribe_to_token_change,
'next_token_changed_subscribe': self.token_renewer.subscribe_to_next_token_change,
}
)
if not config['auth'].get('master_tenant_uuid'):
self.token_renewer.subscribe_to_next_token_details_change(
init_master_tenant
)
def __init__(self, config):
self._service_discovery_args = [
'wazo-setupd',
config.get('uuid'),
config['consul'],
config['service_discovery'],
config['bus'],
lambda: True,
]
self.rest_api = CoreRestApi(config)
self.stopper = Stopper(config['self_stop_delay'], self)
plugin_helpers.load(
namespace='wazo_setupd.plugins',
names=config['enabled_plugins'],
dependencies={
'api': api,
'config': config,
'stopper': self.stopper
},
)
self.stopper_thread = threading.Thread(target=self.stopper.wait)
def __init__(self, config):
# NOTE(sileht): Celery must be spawned before anything else, to ensure
# we don't fork the process after some database/rabbitmq connection
# have been established
celery.configure(config)
self._celery_process = celery.spawn_workers(config)
self._service_discovery_args = [
'wazo-webhookd',
config.get('uuid'),
config['consul'],
config['service_discovery'],
config['bus'],
lambda: True,
]
self._auth_client = AuthClient(**config['auth'])
self._bus_consumer = CoreBusConsumer(config)
self.rest_api = CoreRestApi(config)
self._service_manager = plugin_helpers.load(
namespace='wazo_webhookd.services',
names=config['enabled_services'],
dependencies={
'api': api,
'bus_consumer': self._bus_consumer,
'config': config,
'auth_client': self._auth_client,
},
)
plugin_helpers.load(
namespace='wazo_webhookd.plugins',
names=config['enabled_plugins'],
dependencies={
'api': api,
'bus_consumer': self._bus_consumer,
'config': config,
'service_manager': self._service_manager,
},
)
def __init__(self, config):
auth_client = AuthClient(**config['auth'])
cel_fetcher = CELFetcher()
confd_client = ConfdClient(**config['confd'])
generator = CallLogsGenerator(
confd_client,
[
LocalOriginateCELInterpretor(confd_client),
DispatchCELInterpretor(
CallerCELInterpretor(confd_client),
CalleeCELInterpretor(confd_client),
),
],
)
writer = CallLogsWriter()
self.token_renewer = TokenRenewer(auth_client)
self.token_renewer.subscribe_to_token_change(confd_client.set_token)
self.token_renewer.subscribe_to_next_token_details_change(
generator.set_default_tenant_uuid)
self._publisher = BusPublisher(config)
self.manager = CallLogsManager(cel_fetcher, generator, writer,
self._publisher)
self.bus_client = BusClient(config)
self.rest_api = CoreRestApi(config)
self.status_aggregator = StatusAggregator()
self.token_status = TokenStatus()
plugin_helpers.load(
namespace='wazo_call_logd.plugins',
names=config['enabled_plugins'],
dependencies={
'api': api,
'config': config,
'token_renewer': self.token_renewer,
'status_aggregator': self.status_aggregator,
},
)
def __init__(self, config):
init_db(config['db_uri'],
max_connections=config['rest_api']['max_threads'])
self._config = config
_check_required_config_for_other_threads(config)
self._service_discovery_args = [
'wazo-auth',
config.get('uuid'),
config['consul'],
config['service_discovery'],
config['amqp'],
partial(self_check, config),
]
self.status_aggregator = StatusAggregator()
template_formatter = services.helpers.TemplateFormatter(config)
self._bus_publisher = bus.BusPublisher(config)
self.dao = queries.DAO.from_defaults()
self._tenant_tree = services.helpers.TenantTree(self.dao.tenant)
self._backends = BackendsProxy()
authentication_service = services.AuthenticationService(
self.dao, self._backends)
email_service = services.EmailService(self.dao, self._tenant_tree,
config, template_formatter)
enabled_external_auth_plugins = [
name
for name, value in config['enabled_external_auth_plugins'].items()
if value is True
]
external_auth_service = services.ExternalAuthService(
self.dao,
self._tenant_tree,
config,
self._bus_publisher,
enabled_external_auth_plugins,
)
group_service = services.GroupService(self.dao, self._tenant_tree)
policy_service = services.PolicyService(self.dao, self._tenant_tree)
session_service = services.SessionService(self.dao, self._tenant_tree,
self._bus_publisher)
self._user_service = services.UserService(self.dao, self._tenant_tree)
self._token_service = services.TokenService(config, self.dao,
self._tenant_tree,
self._bus_publisher,
self._user_service)
self._tenant_service = services.TenantService(
self.dao,
self._tenant_tree,
config['all_users_policies'],
self._bus_publisher,
)
self._default_policy_service = services.DefaultPolicyService(
self.dao,
config['default_policies'],
)
self._all_users_service = services.AllUsersService(
self.dao,
config['all_users_policies'],
)
ldap_service = services.LDAPService(self.dao, self._tenant_tree)
self._metadata_plugins = plugin_helpers.load(
namespace='wazo_auth.metadata',
names=self._config['enabled_metadata_plugins'],
dependencies={
'user_service': self._user_service,
'group_service': group_service,
'tenant_service': self._tenant_service,
'token_service': self._token_service,
'backends': self._backends,
'config': config,
},
)
self._purposes = Purposes(self._config['purpose_metadata_mapping'],
self._metadata_plugins)
backends = plugin_helpers.load(
namespace='wazo_auth.backends',
names=self._config['enabled_backend_plugins'],
dependencies={
'user_service': self._user_service,
'group_service': group_service,
'tenant_service': self._tenant_service,
'ldap_service': ldap_service,
'purposes': self._purposes,
'config': config,
},
)
self._backends.set_backends(backends)
self._config['loaded_plugins'] = self._loaded_plugins_names(
self._backends)
dependencies = {
'api': api,
'status_aggregator': self.status_aggregator,
'authentication_service': authentication_service,
'backends': self._backends,
'config': config,
'email_service': email_service,
'external_auth_service': external_auth_service,
'group_service': group_service,
'user_service': self._user_service,
'token_service': self._token_service,
'token_manager': self._token_service, # For compatibility only
'policy_service': policy_service,
'tenant_service': self._tenant_service,
'session_service': session_service,
'template_formatter': template_formatter,
'ldap_service': ldap_service,
}
Tenant.setup(self._token_service, self._user_service,
self._tenant_service)
Token.setup(self._token_service)
plugin_helpers.load(
namespace='wazo_auth.http',
names=config['enabled_http_plugins'],
dependencies=dependencies,
)
manager = plugin_helpers.load(
namespace='wazo_auth.external_auth',
names=config['enabled_external_auth_plugins'],
dependencies=dependencies,
)
config['external_auth_plugin_info'] = {}
if manager:
for extension in manager:
plugin_info = getattr(extension.obj, 'plugin_info', {})
config['external_auth_plugin_info'][
extension.name] = plugin_info
self._rest_api = CoreRestApi(config, self._token_service,
self._user_service)
self._expired_token_remover = token.ExpiredTokenRemover(
config, self.dao, self._bus_publisher)
def __init__(self, config):
self._config = config
_check_required_config_for_other_threads(config)
self._service_discovery_args = [
'wazo-auth',
config.get('uuid'), config['consul'], config['service_discovery'],
config['amqp'],
partial(self_check, config['rest_api']['https']['port'])
]
template_formatter = services.helpers.TemplateFormatter(config)
self._bus_publisher = bus.BusPublisher(config)
dao = queries.DAO.from_config(self._config)
self._tenant_tree = services.helpers.CachedTenantTree(dao.tenant)
self._token_service = services.TokenService(config, dao,
self._tenant_tree,
self._bus_publisher)
self._backends = BackendsProxy()
email_service = services.EmailService(dao, self._tenant_tree, config,
template_formatter)
external_auth_service = services.ExternalAuthService(
dao, self._tenant_tree, config, self._bus_publisher,
config['enabled_external_auth_plugins'])
group_service = services.GroupService(dao, self._tenant_tree)
policy_service = services.PolicyService(dao, self._tenant_tree)
session_service = services.SessionService(dao, self._tenant_tree)
self._user_service = services.UserService(dao, self._tenant_tree)
self._tenant_service = services.TenantService(dao, self._tenant_tree,
self._bus_publisher)
self._metadata_plugins = plugin_helpers.load(
namespace='wazo_auth.metadata',
names=self._config['enabled_metadata_plugins'],
dependencies={
'user_service': self._user_service,
'group_service': group_service,
'tenant_service': self._tenant_service,
'token_service': self._token_service,
'backends': self._backends,
'config': config,
},
)
self._purposes = Purposes(
self._config['purpose_metadata_mapping'],
self._metadata_plugins,
)
backends = plugin_helpers.load(
namespace='wazo_auth.backends',
names=self._config['enabled_backend_plugins'],
dependencies={
'user_service': self._user_service,
'group_service': group_service,
'tenant_service': self._tenant_service,
'purposes': self._purposes,
'config': config,
},
)
self._backends.set_backends(backends)
self._config['loaded_plugins'] = self._loaded_plugins_names(
self._backends)
dependencies = {
'api': api,
'backends': self._backends,
'config': config,
'email_service': email_service,
'external_auth_service': external_auth_service,
'group_service': group_service,
'user_service': self._user_service,
'token_service': self._token_service,
'token_manager': self._token_service, # For compatibility only
'policy_service': policy_service,
'tenant_service': self._tenant_service,
'session_service': session_service,
'template_formatter': template_formatter,
}
Tenant.setup(self._token_service, self._user_service,
self._tenant_service)
plugin_helpers.load(
namespace='wazo_auth.http',
names=config['enabled_http_plugins'],
dependencies=dependencies,
)
manager = plugin_helpers.load(
namespace='wazo_auth.external_auth',
names=config['enabled_external_auth_plugins'],
dependencies=dependencies,
)
config['external_auth_plugin_info'] = {}
if manager:
for extension in manager:
plugin_info = getattr(extension.obj, 'plugin_info', {})
config['external_auth_plugin_info'][
extension.name] = plugin_info
self._rest_api = CoreRestApi(config, self._token_service,
self._user_service)
self._expired_token_remover = token.ExpiredTokenRemover(
config, dao, self._bus_publisher)
def __init__(self, config):
self.config = config
DBSession = new_db_session(config['db_uri'])
CELDBSession = new_db_session(config['cel_db_uri'])
self.dao = DAO(DBSession, CELDBSession)
writer = CallLogsWriter(self.dao)
# NOTE(afournier): it is important to load the tasks before configuring the Celery app
self.celery_task_manager = plugin_helpers.load(
namespace='wazo_call_logd.celery_tasks',
names=config['enabled_celery_tasks'],
dependencies={
'config': self.config,
'dao': self.dao,
'app': celery.app,
},
)
celery.configure(config)
self._celery_process = celery.spawn_workers(config)
auth_client = AuthClient(**config['auth'])
confd_client = ConfdClient(**config['confd'])
generator = CallLogsGenerator(
confd_client,
[
LocalOriginateCELInterpretor(),
DispatchCELInterpretor(
CallerCELInterpretor(),
CalleeCELInterpretor(),
),
],
)
self.token_renewer = TokenRenewer(auth_client)
self.token_renewer.subscribe_to_token_change(confd_client.set_token)
self.token_renewer.subscribe_to_next_token_details_change(
generator.set_default_tenant_uuid)
self.bus_publisher = BusPublisher(service_uuid=config['uuid'],
**config['bus'])
self.bus_consumer = BusConsumer(**config['bus'])
self.manager = CallLogsManager(self.dao, generator, writer,
self.bus_publisher)
self._bus_subscribe()
self.http_server = HTTPServer(config)
if not app.config['auth'].get('master_tenant_uuid'):
self.token_renewer.subscribe_to_next_token_details_change(
init_master_tenant)
self.status_aggregator = StatusAggregator()
self.token_status = TokenStatus()
plugin_helpers.load(
namespace='wazo_call_logd.plugins',
names=config['enabled_plugins'],
dependencies={
'api': api,
'config': config,
'dao': self.dao,
'token_renewer': self.token_renewer,
'status_aggregator': self.status_aggregator,
'bus_publisher': self.bus_publisher,
},
)