def load(self, dependencies):
api = dependencies['api']
ari = dependencies['ari']
bus_consumer = dependencies['bus_consumer']
bus_publisher = dependencies['bus_publisher']
collectd = dependencies['collectd']
token_changed_subscribe = dependencies['token_changed_subscribe']
config = dependencies['config']
amid_client = AmidClient(**config['amid'])
token_changed_subscribe(amid_client.set_token)
auth_client = AuthClient(**config['auth'])
confd_client = ConfdClient(**config['confd'])
token_changed_subscribe(confd_client.set_token)
dial_echo_manager = DialEchoManager()
calls_service = CallsService(amid_client, config['ari']['connection'], ari.client, confd_client, dial_echo_manager)
ari.register_application(DEFAULT_APPLICATION_NAME)
calls_stasis = CallsStasis(ari.client, collectd, bus_publisher, calls_service, config['uuid'], amid_client)
calls_stasis.subscribe()
calls_bus_event_handler = CallsBusEventHandler(amid_client, ari.client, collectd, bus_publisher, calls_service, config['uuid'], dial_echo_manager)
calls_bus_event_handler.subscribe(bus_consumer)
api.add_resource(CallsResource, '/calls', resource_class_args=[calls_service])
api.add_resource(MyCallsResource, '/users/me/calls', resource_class_args=[auth_client, calls_service])
api.add_resource(CallResource, '/calls/<call_id>', resource_class_args=[calls_service])
api.add_resource(MyCallResource, '/users/me/calls/<call_id>', resource_class_args=[auth_client, calls_service])
api.add_resource(ConnectCallToUserResource, '/calls/<call_id>/user/<user_uuid>', resource_class_args=[calls_service])
def load(self, dependencies):
api = dependencies['api']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
token_changed_subscribe = dependencies['token_changed_subscribe']
auth_client = AuthClient(**config['auth'])
ctid_client = CtidClient(**config['ctid'])
websocketd_client = WebsocketdClient(**config['websocketd'])
token_changed_subscribe(websocketd_client.set_token)
local_xivo_uuid = config['uuid']
ctid_ng_client_factory = CtidNgClientFactory(
config['consul'], config['remote_credentials'])
user_presences_service = UserPresencesService(
bus_publisher, websocketd_client, local_xivo_uuid, ctid_ng_client_factory)
line_presences_service = LinePresencesService(
ctid_client, config['ctid'], local_xivo_uuid, ctid_ng_client_factory)
api.add_resource(UserPresencesResource,
'/users/<user_uuid>/presences',
resource_class_args=[user_presences_service])
api.add_resource(UserMePresencesResource,
'/users/me/presences',
resource_class_args=[auth_client, user_presences_service])
api.add_resource(LinePresencesResource,
'/lines/<int:line_id>/presences',
resource_class_args=[line_presences_service])
def _generate_call_logs():
parser = argparse.ArgumentParser(description='Call logs generator')
options = parse_args(parser)
key_config = load_key_file(DEFAULT_CONFIG)
config = ChainMap(key_config, DEFAULT_CONFIG)
auth_client = AuthClient(**config['auth'])
confd_client = ConfdClient(**config['confd'])
token_renewer = TokenRenewer(auth_client)
token_renewer.subscribe_to_token_change(confd_client.set_token)
cel_fetcher = CELFetcher()
generator = CallLogsGenerator([
LocalOriginateCELInterpretor(confd_client),
DispatchCELInterpretor(CallerCELInterpretor(confd_client),
CalleeCELInterpretor(confd_client))
])
writer = CallLogsWriter()
publisher = BusPublisher(config)
manager = CallLogsManager(cel_fetcher, generator, writer, publisher)
options = vars(options)
with token_renewer:
if options.get('action') == 'delete':
if options.get('all'):
manager.delete_all()
elif options.get('days'):
manager.delete_from_days(options['days'])
else:
if options.get('days'):
manager.generate_from_days(days=options['days'])
else:
manager.generate_from_count(cel_count=options['cel_count'])
def load(self, dependencies):
adapter_api = dependencies['adapter_api']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
auth_client = AuthClient(**config['auth'])
message_callback_service = MessageCallbackService(
bus_publisher, config['uuid'], ChatsContexts)
adapter_api.add_resource(
MessageCallbackResource,
'/mongooseim/message_callback',
resource_class_args=[message_callback_service])
presence_callback_service = PresenceCallbackService(
bus_publisher, config['uuid'])
adapter_api.add_resource(
PresenceCallbackResource,
'/mongooseim/presence_callback',
resource_class_args=[presence_callback_service])
adapter_api.add_resource(CheckPasswordResource,
'/mongooseim/authentication/check_password',
resource_class_args=[auth_client])
adapter_api.add_resource(UserExistsResource,
'/mongooseim/authentication/user_exists')
def load(self, dependencies):
api = dependencies['api']
ari = dependencies['ari']
bus_consumer = dependencies['bus_consumer']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
status_aggregator = dependencies['status_aggregator']
token_changed_subscribe = dependencies['token_changed_subscribe']
auth_client = AuthClient(**config['auth'])
confd_client = ConfdClient(**config['confd'])
token_changed_subscribe(confd_client.set_token)
voicemail_storage = new_filesystem_storage()
self._voicemail_cache = new_cache(voicemail_storage)
try:
self._voicemail_cache.refresh_cache()
except Exception:
logger.exception('fail to refresh voicemail cache')
voicemails_service = VoicemailsService(ari.client, confd_client,
voicemail_storage)
voicemails_bus_event_handler = VoicemailsBusEventHandler(
confd_client, bus_publisher, self._voicemail_cache)
voicemails_bus_event_handler.subscribe(bus_consumer)
status_aggregator.add_provider(self._provide_status)
api.add_resource(VoicemailResource,
'/voicemails/<voicemail_id>',
resource_class_args=[voicemails_service])
api.add_resource(VoicemailFolderResource,
'/voicemails/<voicemail_id>/folders/<folder_id>',
resource_class_args=[voicemails_service])
api.add_resource(VoicemailMessageResource,
'/voicemails/<voicemail_id>/messages/<message_id>',
resource_class_args=[voicemails_service])
api.add_resource(
VoicemailRecordingResource,
'/voicemails/<voicemail_id>/messages/<message_id>/recording',
resource_class_args=[voicemails_service])
api.add_resource(UserVoicemailResource,
'/users/me/voicemails',
resource_class_args=[auth_client, voicemails_service])
api.add_resource(UserVoicemailFolderResource,
'/users/me/voicemails/folders/<folder_id>',
resource_class_args=[auth_client, voicemails_service])
api.add_resource(UserVoicemailMessageResource,
'/users/me/voicemails/messages/<message_id>',
resource_class_args=[auth_client, voicemails_service])
api.add_resource(
UserVoicemailRecordingResource,
'/users/me/voicemails/messages/<message_id>/recording',
resource_class_args=[auth_client, voicemails_service])
def __init__(self, config):
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.token_renewer = TokenRenewer(auth_client)
self._load_plugins(config)
def load_token(token):
try:
response = AuthClient(**auth_config).token.get(token)
except HTTPError:
return None
except requests.ConnectionError:
logger.warning('Wazo authentication server connection error')
return None
token = response.get('token')
if not token:
return None
return UserUI(token, response.get('auth_id'))
def _on_login_pass(self, password, cti_connection):
if cti_connection != self._connection:
return
LoginPass.deregister_callback(self._on_login_pass)
self._auth_client = AuthClient(username=self._username,
password=password,
**self._auth_config)
self._async_runner.run_with_cb(self._on_auth_success,
self._create_token, self._auth_client,
self._auth_backend, self._username)
def load(self, dependencies):
api = dependencies['api']
ari = dependencies['ari']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
token_changed_subscribe = dependencies['token_changed_subscribe']
amid_client = AmidClient(**config['amid'])
auth_client = AuthClient(**config['auth'])
confd_client = ConfdClient(**config['confd'])
token_changed_subscribe(amid_client.set_token)
token_changed_subscribe(confd_client.set_token)
state_persistor = StatePersistor(ari.client)
transfer_lock = TransferLock()
transfers_service = TransfersService(amid_client, ari.client,
confd_client, state_factory,
state_persistor, transfer_lock)
ari.register_application(DEFAULT_APPLICATION_NAME)
transfers_stasis = TransfersStasis(amid_client, ari.client,
transfers_service, state_factory,
state_persistor, config['uuid'])
transfers_stasis.subscribe()
notifier = TransferNotifier(bus_publisher)
state_factory.set_dependencies(amid_client, ari.client, notifier,
transfers_service, state_persistor,
transfer_lock)
api.add_resource(TransfersResource,
'/transfers',
resource_class_args=[transfers_service])
api.add_resource(TransferResource,
'/transfers/<transfer_id>',
resource_class_args=[transfers_service])
api.add_resource(TransferCompleteResource,
'/transfers/<transfer_id>/complete',
resource_class_args=[transfers_service])
api.add_resource(UserTransfersResource,
'/users/me/transfers',
resource_class_args=[auth_client, transfers_service])
api.add_resource(UserTransferResource,
'/users/me/transfers/<transfer_id>',
resource_class_args=[auth_client, transfers_service])
api.add_resource(UserTransferCompleteResource,
'/users/me/transfers/<transfer_id>/complete',
resource_class_args=[auth_client, transfers_service])
def load(self, dependencies):
api = dependencies['api']
config = dependencies['config']
auth_client = AuthClient(**config['auth'])
dao = CallLogDAO(new_db_session(config['db_uri']))
service = CDRService(dao)
api.add_resource(CDRResource, '/cdr', resource_class_args=[service])
api.add_resource(CDRUserResource,
'/users/<uuid:user_uuid>/cdr',
resource_class_args=[service])
api.add_resource(CDRUserMeResource,
'/users/me/cdr',
resource_class_args=[auth_client, service])
def load(self, dependencies):
api = dependencies['api']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
auth_client = AuthClient(**config['auth'])
chats_service = ChatsService(bus_publisher, config['uuid'])
api.add_resource(ChatsResource,
'/chats',
resource_class_args=[chats_service])
api.add_resource(UserChatsResource,
'/users/me/chats',
resource_class_args=[auth_client, chats_service])
def load(self, dependencies):
api = dependencies['api']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
auth_client = AuthClient(**config['auth'])
mongooseim_client = MongooseIMClient(**config['mongooseim'])
chats_service = ChatsService(config['uuid'], mongooseim_client,
ChatsContexts, bus_publisher)
api.add_resource(ChatsResource,
'/chats',
resource_class_args=[chats_service])
api.add_resource(UserChatsResource,
'/users/me/chats',
resource_class_args=[auth_client, chats_service])
def load(self, dependencies):
api = dependencies['api']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
auth_client = AuthClient(**config['auth'])
ctid_client = CtidClient(**config['ctid'])
presences_service = PresencesService(bus_publisher, ctid_client,
config['ctid'])
api.add_resource(PresencesResource,
'/users/<user_uuid>/presences',
resource_class_args=[presences_service])
api.add_resource(UserPresencesResource,
'/users/me/presences',
resource_class_args=[auth_client, presences_service])
def load(self, dependencies):
api = dependencies['api']
ari = dependencies['ari']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
token_changed_subscribe = dependencies['token_changed_subscribe']
auth_client = AuthClient(**config['auth'])
confd_client = ConfdClient(**config['confd'])
token_changed_subscribe(auth_client.set_token)
token_changed_subscribe(confd_client.set_token)
switchboards_notifier = SwitchboardsNotifier(bus_publisher)
switchboards_service = SwitchboardsService(ari.client, confd_client, switchboards_notifier)
ari.register_application(DEFAULT_APPLICATION_NAME)
switchboards_stasis = SwitchboardsStasis(ari.client, confd_client, switchboards_notifier, switchboards_service)
switchboards_stasis.subscribe()
api.add_resource(
SwitchboardCallsQueuedResource,
'/switchboards/<switchboard_uuid>/calls/queued',
resource_class_args=[switchboards_service],
)
api.add_resource(
SwitchboardCallQueuedAnswerResource,
'/switchboards/<switchboard_uuid>/calls/queued/<call_id>/answer',
resource_class_args=[auth_client, switchboards_service],
)
api.add_resource(
SwitchboardCallsHeldResource,
'/switchboards/<switchboard_uuid>/calls/held',
resource_class_args=[switchboards_service],
)
api.add_resource(
SwitchboardCallHeldResource,
'/switchboards/<switchboard_uuid>/calls/held/<call_id>',
resource_class_args=[switchboards_service],
)
api.add_resource(
SwitchboardCallHeldAnswerResource,
'/switchboards/<switchboard_uuid>/calls/held/<call_id>/answer',
resource_class_args=[auth_client, switchboards_service],
)
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 main():
auth_client = AuthClient(HOST, username=USERNAME, password=PASSWORD, verify_certificate=False)
token = auth_client.token.new(AUTH_BACKEND, expiration=TOKEN_EXPIRATION)['token']
confd_client = ConfdClient(HOST, token=token, verify_certificate=False)
for i in range(N):
user_data = dict(
firstname=' '.join([FIRSTNAME_PREFIX, str(i)]),
)
exten_data = dict(
exten=str(FIRST_EXTEN + i),
context=CONTEXT,
)
print('Creating ', user_data, '...')
user = confd_client.users.create(user_data)
exten = confd_client.extensions.create(exten_data)
line = confd_client.lines_sip.create({'context': CONTEXT})
confd_client.users(user).add_line(line)
confd_client.lines(line).add_extension(exten)
def __init__(self, config):
auth_config = dict(config['auth'])
auth_config.pop('key_file', None)
auth_client = AuthClient(**auth_config)
cel_fetcher = CELFetcher()
confd_client = ConfdClient(**config['confd'])
generator = CallLogsGenerator([
LocalOriginateCELInterpretor(confd_client),
DispatchCELInterpretor(CallerCELInterpretor(confd_client),
CalleeCELInterpretor(confd_client))
])
writer = CallLogsWriter()
self._publisher = BusPublisher(config)
self.manager = CallLogsManager(cel_fetcher, generator, writer,
self._publisher)
self.bus_client = BusClient(config)
self.rest_api = CoreRestApi(config)
self.token_renewer = TokenRenewer(auth_client)
self.token_renewer.subscribe_to_token_change(confd_client.set_token)
self._load_plugins(config)
def get_token(self, xivo_uuid):
token = self._auth_tokens.get(xivo_uuid)
if not self._is_valid(token):
credentials = self._credentials.get(xivo_uuid)
if not credentials:
raise MissingCredentials(xivo_uuid)
auth_config = self.find_service_config('wazo-auth', xivo_uuid)
if not auth_config:
raise WazoAuthUnreachable(xivo_uuid, 'no running service found')
client = AuthClient(username=credentials['service_id'],
password=credentials['service_key'],
host=auth_config['Address'],
port=auth_config['Port'],
verify_certificate=False)
try:
self._auth_tokens[xivo_uuid] = token = client.token.new()
except requests.RequestException:
raise InvalidCredentials(xivo_uuid)
return token['token']
def load(self, dependencies):
api = dependencies['api']
ari = dependencies['ari']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
token_changed_subscribe = dependencies['token_changed_subscribe']
amid_client = AmidClient(**config['amid'])
auth_client = AuthClient(**config['auth'])
confd_client = ConfdClient(**config['confd'])
token_changed_subscribe(amid_client.set_token)
token_changed_subscribe(confd_client.set_token)
relocates = RelocateCollection()
state_factory = StateFactory(state_index, amid_client, ari.client)
notifier = RelocatesNotifier(bus_publisher)
relocates_service = RelocatesService(amid_client, ari.client,
confd_client, notifier, relocates,
state_factory)
ari.register_application(DEFAULT_APPLICATION_NAME)
relocates_stasis = RelocatesStasis(ari.client, relocates)
relocates_stasis.subscribe()
api.add_resource(UserRelocatesResource,
'/users/me/relocates',
resource_class_args=[auth_client, relocates_service])
api.add_resource(UserRelocateResource,
'/users/me/relocates/<relocate_uuid>',
resource_class_args=[auth_client, relocates_service])
api.add_resource(UserRelocateCompleteResource,
'/users/me/relocates/<relocate_uuid>/complete',
resource_class_args=[auth_client, relocates_service])
api.add_resource(UserRelocateCancelResource,
'/users/me/relocates/<relocate_uuid>/cancel',
resource_class_args=[auth_client, relocates_service])
def load(self, dependencies):
api = dependencies['api']
bus_consumer = dependencies['bus_consumer']
config = dependencies['config']
service_manager = dependencies['service_manager']
auth_client = AuthClient(**config['auth'])
service = SubscriptionService(config)
api.add_resource(SubscriptionsResource,
'/subscriptions',
resource_class_args=[service])
api.add_resource(SubscriptionResource,
'/subscriptions/<subscription_uuid>',
resource_class_args=[service])
api.add_resource(UserSubscriptionsResource,
'/users/me/subscriptions',
resource_class_args=[auth_client, service])
api.add_resource(UserSubscriptionResource,
'/users/me/subscriptions/<subscription_uuid>',
resource_class_args=[auth_client, service])
SubscriptionBusEventHandler(bus_consumer, service_manager,
service).subscribe(bus_consumer)
def _get_auth_client(config):
client = g.get('auth_client')
if not client:
client = g.auth_client = AuthClient(**config)
return client
def create_auth(cls):
return AuthClient(host='localhost',
port=cls.service_port(9497, 'auth'),
verify_certificate=False)
def load(self, dependencies):
api = dependencies['api']
ari = dependencies['ari']
config = dependencies['config']
bus_publisher = dependencies['bus_publisher']
config = dependencies['config']
token_changed_subscribe = dependencies['token_changed_subscribe']
next_token_changed_subscribe = dependencies[
'next_token_changed_subscribe']
auth_client = AuthClient(**config['auth'])
confd_client = ConfdClient(**config['confd'])
amid_client = AmidClient(**config['amid'])
token_changed_subscribe(amid_client.set_token)
token_changed_subscribe(auth_client.set_token)
token_changed_subscribe(confd_client.set_token)
notifier = ApplicationNotifier(bus_publisher)
service = ApplicationService(ari.client, confd_client, amid_client,
notifier)
stasis = ApplicationStasis(ari, confd_client, service, notifier)
next_token_changed_subscribe(stasis.initialize)
api.add_resource(
ApplicationItem,
'/applications/<uuid:application_uuid>',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallList,
'/applications/<uuid:application_uuid>/calls',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallItem,
'/applications/<uuid:application_uuid>/calls/<call_id>',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallHoldStartList,
'/applications/<uuid:application_uuid>/calls/<call_id>/hold/start',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallHoldStopList,
'/applications/<uuid:application_uuid>/calls/<call_id>/hold/stop',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallMohStopList,
'/applications/<uuid:application_uuid>/calls/<call_id>/moh/stop',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallMohStartList,
'/applications/<uuid:application_uuid>/calls/<call_id>/moh/<uuid:moh_uuid>/start',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallMuteStartList,
'/applications/<uuid:application_uuid>/calls/<call_id>/mute/start',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallMuteStopList,
'/applications/<uuid:application_uuid>/calls/<call_id>/mute/stop',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallPlaybackList,
'/applications/<uuid:application_uuid>/calls/<call_id>/playbacks',
resource_class_args=[service],
)
api.add_resource(
ApplicationCallSnoopList,
'/applications/<uuid:application_uuid>/calls/<call_id>/snoops',
resource_class_args=[service],
)
api.add_resource(
ApplicationNodeList,
'/applications/<uuid:application_uuid>/nodes',
resource_class_args=[service],
)
api.add_resource(
ApplicationNodeItem,
'/applications/<uuid:application_uuid>/nodes/<uuid:node_uuid>',
resource_class_args=[service],
)
api.add_resource(
ApplicationNodeCallList,
'/applications/<uuid:application_uuid>/nodes/<uuid:node_uuid>/calls',
resource_class_args=[service],
)
api.add_resource(
ApplicationNodeCallItem,
'/applications/<uuid:application_uuid>/nodes/<uuid:node_uuid>/calls/<call_id>',
resource_class_args=[service],
)
api.add_resource(
ApplicationPlaybackItem,
'/applications/<uuid:application_uuid>/playbacks/<uuid:playback_uuid>',
resource_class_args=[service],
)
api.add_resource(
ApplicationSnoopList,
'/applications/<uuid:application_uuid>/snoops',
resource_class_args=[service],
)
api.add_resource(
ApplicationSnoopItem,
'/applications/<uuid:application_uuid>/snoops/<uuid:snoop_uuid>',
resource_class_args=[service],
)
def new_auth_client():
username = config['auth']['service_id']
password = config['auth']['service_key']
return AuthClient(username=username, password=password, **config['auth'])
def get_auth_client():
auth_client = g.get('auth_client')
if not auth_client:
auth_client = g.auth_client = AuthClient(**current_app.config['auth'])
return auth_client
