def main():
"""Função principal da aplicação."""
manager = Manager(
loop=asyncio.get_event_loop(),
host=ASTERISK_IP,
port=ASTERISK_PORT,
username=ASTERISK_USER,
secret=ASTERISK_PASSWORD,
)
@manager.register_event("QueueCallerLeave")
@manager.register_event("AgentCalled")
@manager.register_event("AgentConnect")
@manager.register_event("AgentComplete")
@manager.register_event("AgentDump")
# @manager.register_event("AgentRingNoAnswer")
@manager.register_event("MessageWaiting")
# @manager.register_event('UserEvent')
async def callback_agent(manager, message):
fire(message)
@manager.register_event("Hangup")
async def callback_hangup(manager, message):
# hangup from queue, external only
if message.context == "ext-queues":
fire(message)
manager.connect()
try:
manager.loop.run_forever()
except KeyboardInterrupt:
manager.loop.close()
def attach(self, amihost):
"""
attach amihost to a ChannelManager.
Args:
amihost (dict): A dictionary containing the connection settings for
an AMI host.
"""
# Create Panoramisk asterisk AMI manager.
amimgr = Manager(loop=self.loop,
host=amihost['host'],
port=amihost['port'],
username=amihost['username'],
secret=amihost['password'],
ssl=False,
encoding='utf8',
log=self.logger)
# Create our own channel manager.
channel_manager = self.channel_manager(reporter=self.reporter, )
# Tell Panoramisk to which events we want to listen.
for event_name in channel_manager.INTERESTING_EVENTS:
amimgr.register_event(event_name, self.on_event)
# Record them for later use.
self.amimgrs[amimgr] = channel_manager
# Tell asyncio what to work on.
asyncio.ensure_future(amimgr.connect())
async def start(self):
# Set process name
salt.utils.process.appendproctitle(self.__class__.__name__)
manager_disconnected = asyncio.Event()
# Ok let's connect to Asterisk and process events.
self.loop = asyncio.get_event_loop()
# Create event loop to receive actions as events.
self.loop.create_task(self.action_event_loop())
host = __salt__['config.get']('ami_host', 'localhost')
port = int(__salt__['config.get']('ami_port', '5038'))
login = __salt__['config.get']('ami_login', 'salt')
self.manager = Manager(
loop=self.loop,
host=host,
port=port,
username=login,
secret=__salt__['config.get']('ami_secret', 'stack'),
forgetable_actions=('ping', 'login'),
)
log.info('AMI connecting to %s@%s:%s...', login, host, port)
# Register events
for ev_name in __salt__['config.get']('ami_register_events', []):
log.info('Registering for AMI event %s', ev_name)
self.manager.register_event(ev_name, self.on_asterisk_event)
try:
await self.manager.connect()
log.info('Connected to AMI.')
except Exception as e:
log.error('Cannot connect to Asterisk AMI: %s', e)
await manager_disconnected.wait()
def __init__(self, bot):
self.bot = bot
self.bot.asterirc = self
self.config = config = dict(
host='127.0.0.1',
port=5038,
http_port='8088',
protocol='http',
debug=True,
)
config.update(bot.config.get('asterisk', {}))
self.log = logging.getLogger('irc3.ast')
self.ilog = logging.getLogger('irc.asterirc')
self.ilog.set_irc_targets(bot, self.config['channel'])
self.log.info('Channel is set to {channel}'.format(**config))
self.rooms = defaultdict(dict)
self.http = None
self.resolver = irc3.utils.maybedotted(self.config['resolver'])
self.manager = Manager(log=logging.getLogger('irc3.ast.manager'),
**config)
self.manager.register_event('Shutdown', self.handle_shutdown)
self.manager.register_event('Meet*', self.handle_meetme)
if config.get('debug'):
self.manager.register_event('*', self.handle_event)
if isinstance(self.resolver, type):
self.resolver = self.resolver(bot)
def queue_status():
manager = Manager(loop=asyncio.get_event_loop(),
host='127.0.0.1', port=5039,
username='******', secret='mysecret')
yield from manager.connect()
queues_details = yield from manager.send_action({'Action': 'QueueStatus', 'Queue': 'queue_name'})
manager.close()
pprint(queues_details)
def extension_status():
manager = Manager(loop=asyncio.get_event_loop(),
host='127.0.0.1', port=5039,
username='******', secret='password')
yield from manager.connect()
extension = yield from manager.send_action({'Action': 'ExtensionState',
'Exten': '2001',
'Context': 'default'})
manager.close()
pprint(extension)
def originate():
manager = Manager(loop=asyncio.get_event_loop(), host='127.0.0.1', username='******', secret='password')
yield from manager.connect()
result = yield from manager.send_action_via_manager({'Action': 'Originate',
'Channel': 'SIP/gawel',
'WaitTime': 20,
'CallerID': 'gawel',
'Exten': '0299999999',
'Context': 'default',
'Priority': 1,})
pprint(result)
def queue_status():
MANAGER = Manager(loop=asyncio.get_event_loop(),
host='127.0.0.1',
username='******',
secret='password')
yield from MANAGER.connect()
queues_details = yield from MANAGER.send_action_via_manager({
'Action':
'QueueStatus',
'Queue':
'queue_name'
})
pprint(queues_details)
async def ping(lp, username, secret):
manager = Manager(loop=lp,
host='127.0.0.1',
port=5038,
username=username,
secret=secret)
await manager.connect()
while True:
p = await manager.send_action({'Action': 'ping'})
# p = await manager.send_action({'Action': 'SIPpeers'})
pprint(p)
await asyncio.sleep(1)
manager.close()
def ping(lp, username, secret):
manager = Manager(loop=lp,
host='127.0.0.1',
port=5038,
username=username,
secret=secret,
forgetable_actions=('login', ))
yield from manager.connect()
while True:
p = yield from manager.send_action({'Action': 'ping'})
# p = yield from manager.send_action({'Action': 'SIPpeers'})
pprint(p)
yield from asyncio.sleep(1)
manager.close()
async def test_reconnection_without_lost(event_loop):
unused_tcp_port = unused_tcp_port_factory()
print('Start server on %s' % unused_tcp_port)
manager = Manager(loop=event_loop,
host='127.0.0.1',
port=unused_tcp_port,
username='******',
secret='secret')
server = Asterisk(event_loop, unused_tcp_port)
await server.start()
await manager.connect()
await server.data_received()
print(server.actions)
login = server.actions[0]
assert login['action'] == 'Login'
unused_tcp_port = unused_tcp_port_factory()
print('Restart server on %s' % unused_tcp_port)
server.port = unused_tcp_port
manager.config['port'] = unused_tcp_port
await server.stop()
manager.send_action({'Action': 'Ping'})
f = manager.send_action({'Action': 'Test', 'Command': 'test'})
fully_booted = Event('FullyBooted')
await asyncio.sleep(.1)
assert manager.awaiting_actions
await server.start()
await asyncio.sleep(2)
assert manager.awaiting_actions
manager.dispatch(fully_booted)
await asyncio.sleep(.5)
assert not manager.awaiting_actions
resp = await f
await server.stop()
login2 = server.actions[0]
assert login2['action'] == 'Login'
assert login['actionid'] != login2['actionid']
test_action = server.actions[-1]
assert test_action.id == resp.id
assert test_action['action'] == 'Test'
def __init__(self, loop):
self.manager = Manager(loop=loop,
host='178.248.87.116',
port=1709,
username='******',
secret='100')
self.callManager = CallBaseManager()
self.httpclient = HttpClientTornado()
self.manager.register_event('FullyBooted', self.FullyBooted)
self.manager.register_event('BridgeEnter', self.BridgeEnter)
self.manager.register_event('Hangup', self.Hangup)
self.manager.connect()
try:
self.manager.loop.run_forever()
except KeyboardInterrupt:
self.manager.loop.close()
def attach(self, asterisk):
"""
Set up a connection to the specified Asterisk
Args:
asterisk (str): A connection string
"""
ami_host = urlparse(asterisk)
# Create Panoramisk asterisk AMI manager.
manager = Manager(loop=self.loop,
host=ami_host.hostname,
port=ami_host.port,
username=ami_host.username,
secret=ami_host.password,
ssl=ami_host.scheme in ('ssl', 'tls'),
encoding='utf8',
log=self.logger)
# Create our own channel manager.
event_handler = self.event_handler(
reporter=self.reporter,
hostname=ami_host.hostname,
logger=self.logger,
)
# Tell Panoramisk to which events we want to listen.
if event_handler.FILTER_EVENTS:
for event_name in event_handler.event_handlers().keys():
manager.register_event(event_name, self.on_event)
else:
manager.register_event('*', self.on_event)
# Record them for later use.
self.ami_managers[manager] = event_handler
# Tell asyncio what to work on.
asyncio.ensure_future(manager.connect())
def putCids(lp, args, config):
auth = HTTPBasicAuth(config['carddav']['user'], config['carddav']['pass'])
url = config['carddav']['url']
# connect to asterisk
ami = Manager(host=config['ami']['host'],
port=config['ami']['port'],
username=config['ami']['user'],
secret=config['ami']['pass'])
yield from ami.connect()
# get phone numbers from vcard
for vurl in getAllVcardLinks(url, auth):
r = requests.request("GET", vurl, auth=auth)
try:
vcard = vobject.readOne(r.text)
except ParseError as e:
print(e)
continue
if "tel" in vcard.contents:
for telno in vcard.contents['tel']:
num = tidyPhoneNumber(config, telno.value)
if num and "fn" in vcard.contents:
name = vcard.fn.value
print("Adding/updating Number: %s Name: %s" % (num, name),
end="... ")
if not args.no_update:
ami_result = yield from ami.send_action({
"Action": "DBPut",
"Family": "cidname",
"Key": num,
"Val": name
})
print(ami_result.Response)
else:
print("no-update")
ami.close()
AMI_USER = os.environ.get('AMI_USER', 'asterisk')
AMI_SECRET = os.environ.get('AMI_SECRET', 'secret')
stats = statsd.StatsClient(*STATSD_HOST.split(':'))
loop = asyncio.get_event_loop()
logging.basicConfig()
logger = logging.getLogger(__name__)
logger.setLevel(level=logging.DEBUG)
# Asterisk AMI manager client
manager = Manager(loop=loop,
host=AMI_HOST, port=AMI_PORT,
username=AMI_USER,
secret=AMI_SECRET,
ping_interval=10, # Periodically ping AMI (dead or alive)
reconnect_timeout=2, # Timeout reconnect if connection lost
)
manager.loop.set_debug(True)
channels_current = {} # Current channels gauge
sip_reachable_peers = set()
iax_reachable_peers = set()
sip_total_peers = 0
iax_total_peers = 0
def main():
logger.info('Connecting to {}:{}.'.format(AMI_HOST, AMI_PORT))
'call_posted_time': '',
'call_finished': False,
'call_registred': False,
'call_record_attached': False
}
}
if not DEBUG:
logging.config.dictConfig(LOGGING)
logger = logging.getLogger('ParkLogger')
manager = Manager(
host=os.getenv('AMI_HOST', '127.0.0.1'),
port=os.getenv('AMI_PORT', 5038),
username=os.getenv('AMI_USERNAME', 'user'),
secret=os.getenv('AMI_SECRET', 'password'),
ping_delay=10, # Delay after start
ping_interval=10, # Periodically ping AMI (dead or alive)
reconnect_timeout=2, # Timeout reconnect if connection lost
)
def grab_bx_users(bx24):
return {
user['UF_PHONE_INNER']: user['ID']
for user in bx24.callMethod('user.get') if user['UF_PHONE_INNER']
}
def on_connect(mngr: Manager):
logging.info('Connected to %s:%s AMI socket successfully' %
import os
import django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'call_center.settings')
django.setup()
from django.conf import settings
from crm.models import Call, Client
from django.utils import timezone
import asyncio
import pytz
import requests
from datetime import datetime, timedelta
from panoramisk import Manager
manager = Manager(loop=asyncio.get_event_loop(),
host=settings.IP,
username=settings.ASTER_USER,
secret=settings.ASTER_PASS)
# Получение необходимой группы номеров.
def groups_phone_numbers():
url = settings.GROUP_PHONE_NUMBER_URL
phones_json = requests.get(url, verify=False).json()
return phones_json[settings.NAME_GROUP_PHONE_NUMBER].split('-')
numbers = groups_phone_numbers()
@manager.register_event('Hangup')
#
# AMI CONF in ASTERISK
#
# add this below, adapting permit and deny accordingly
# to /etc/asterisk/manager_custom.conf
# [queue_alert_user]
# secret=queue_alert_pwd
# deny=0.0.0.0/0.0.0.0
# permit=0.0.0.0/0.0.0.0
# read = all
# eventfilter=Event: QueueCallerAbandon
manager = Manager(
loop=asyncio.get_event_loop(),
host="localhost",
username="******",
secret="queue_alert_pwd",
)
#
# you need to create the above webhook in Rocket.Chat
# and paste the Script from incoming.webhook.Rocket.Chat.js
# this is the webhook url
incoming_endpoint = (
"http://localhost:3000/hooks/" +
"620e9615701ffe000986a1c8/8fRecuRk5Muyf3mtsGtDGFgJDkZ8wuEjm5qNqNFqxuCLaErE"
)
# this is an example.
# you can filter the callback by different method
# or inside the method, using message.event
# you can also duplicate the code below, and send different
import asyncio
from panoramisk import Manager
import json
from pprint import pprint
sipLog = 'sipLog.txt'
manager = Manager(loop=asyncio.get_event_loop(),
host='192.168.2.62',
username='',
secret='')
# This will print NewChannel Events.
# AppData='hangupcall, CallerIDName='test2' CallerIDNum='112' Channel='PJSIP/112-0000004a' ChannelState='6',
# ChannelState='6' ChannelStateDesc='Up' ConnectedLineName='Test1' ConnectedLineNum='111' Context='ext-local' Event='Newexten'
#
#
@manager.register_event('Newexten')
def callback(manager, message):
# resp = yield from manager.send_action({'Action': 'Status'})
# print(resp)
state = int(message.get('ChannelState')) if message.get('Application') != 'Hangup' and message.get('Application') != 'Finished' else message.get('Application')
callStateSwitcher = {
4: 'Incoming',
5: 'Ringing',
6: 'Answered',
7: 'Busy',
'Hangup': 'Hangup',
'Finished': 'NoAnswer',
}
import asyncio
from panoramisk import Manager
manager = Manager(loop=asyncio.get_event_loop(),
host='ip',
username='******',
secret='secret')
@manager.register_event('*')
def callback(event, manager):
if "FullyBooted" not in manager.event:
"""This will print every event, but the FullyBooted events as these
will continuously spam your screen"""
print(manager)
"""
# This will print NewChannel Events
@manager.register_event('NewChannel')
def callback(event, manager):
print(manager)
# This will print Hangup Events
@manager.register_event('Hangup')
def callback(event, manager):
print(manager)
"""
AMI_HOST = os.environ.get('AMI_HOST', 'localhost')
AMI_PORT = os.environ.get('AMI_PORT', '5038')
AMI_USER = os.environ.get('AMI_USER', 'asterisk')
AMI_SECRET = os.environ.get('AMI_SECRET', 'secret')
stats = statsd.StatsClient(*STATSD_HOST.split(':'))
loop = asyncio.get_event_loop()
logging.basicConfig()
logger = logging.getLogger(__name__)
logger.setLevel(level=logging.DEBUG)
# Asterisk AMI manager client
manager = Manager(loop=loop,
host=AMI_HOST, port=AMI_PORT,
username=AMI_USER,
secret=AMI_SECRET)
manager.loop.set_debug(True)
channels_current = {} # Current channels gauge
sip_reachable_peers = set()
def main():
logger.info('Connecting to {}:{}.'.format(AMI_HOST, AMI_PORT))
manager.connect()
try:
loop.run_forever()
except KeyboardInterrupt:
loop.close()
maxNumTries = int(config['attacker']['maxNumTries'])
maxNumInvitesWithoutAuth = int(config['attacker']['maxNumInvites'])
BLExpireTime = int(config['attacker']['BLExpireTime'])
WLExpireTime = int(config['attacker']['WLExpireTime'])
TLExpireTime = int(config['attacker']['TLExpireTime'])
iptablesChain = config['attacker']['iptablesChain']
else:
maxNumTries = 5
BLExpireTime = 86400
WLExpireTime = 21600
TLExpireTime = 3600
iptablesChain = "INPUT"
# We connect into a Asterisk Manager (Asterisk 11 or newer with Security permissions to read)
manager = Manager(loop=asyncio.get_event_loop(), host=managerHost, port=managerPort, username=managerUser, secret=managerPass)
# Set the logging system to dump everything we do
logging.basicConfig(filename=logFile,level=logging.DEBUG,format='%(asctime)s %(levelname)s: %(message)s')
Log = logging.getLogger()
level = logging.getLevelName(logLevel)
Log.setLevel(level)
logging.debug("Configured Blacklist expire time: "+str(BLExpireTime))
logging.debug("Configured Whitelist expire time: "+str(WLExpireTime))
logging.debug("Configured Templist expire time: "+str(TLExpireTime))
# We set the lists where we storage the addresses.
templist={} # Suspected addresses
whitelist={} # Trusted addresses
blacklist={} # Attackers addresses
