def create_ami_factory(self, count=1, username="******", secret="mysecret",
port=5038):
"""Create n instances of AMI. Each AMI instance will attempt to connect
to a previously created instance of Asterisk. When a connection is
complete, the ami_connect method will be called.
Keyword arguments:
count The number of instances of AMI to create
username The username to login with
secret The password to login with
port The port to connect over
"""
def on_reconnect(login_deferred):
"""Called if the connection is lost and re-made"""
login_deferred.addCallbacks(self._ami_connect, self.ami_login_error)
for i, ast_config in enumerate(self.get_asterisk_hosts(count)):
host = ast_config.get('host')
ami_config = ast_config.get('ami', {})
actual_user = ami_config.get('username', username)
actual_secret = ami_config.get('secret', secret)
actual_port = ami_config.get('port', port)
self.ami.append(None)
LOGGER.info("Creating AMIFactory %d to %s" % ((i + 1), host))
try:
ami_factory = manager.AMIFactory(actual_user, actual_secret, i,
on_reconnect=on_reconnect)
except:
ami_factory = manager.AMIFactory(actual_user, actual_secret, i)
deferred = ami_factory.login(ip=host, port=actual_port)
deferred.addCallbacks(self._ami_connect, self.ami_login_error)
def __init__(self,
on_login,
on_error,
timeout=60,
user="******",
secret="mysecret",
host="127.0.0.1",
port=5038):
"""Constructor
Keyword Arguments:
on_login Deferred callback to be called when user logs into AMI
on_error Deferred callback to be called if an error occurs while logging
into AMI
timeout Time to wait before failing login attempts
user User to connect as
secret Password for the user
host Asterisk instance to connect to
port Port to connect on
"""
self.on_login = on_login
self.on_error = on_error
self.login_timeout = timeout
self.host = host
self.port = port
self._attempts = 0
self._start = None
self.ami = None
try:
self.ami_factory = manager.AMIFactory(
user, secret, on_reconnect=self.on_reconnect)
except:
# Try without reconnects
self.ami_factory = manager.AMIFactory(user, secret)
def main():
"""Asterisk Manager Interface Login"""
print("Main")
f = manager.AMIFactory('aswin', '12345678')
df = f.login(ip='192.168.5.86')
df.addCallbacks(on_login, on_failure)
return df
def started(self):
# database handling
self.store = Store(self.path("db").child("storage").path)
# the recordings path
self.recordingsPath = self.path("db").child("recordings")
if not self.recordingsPath.exists(): self.recordingsPath.createDirectory()
# start AGI service
f = fastagi.FastAGIFactory(self.connected)
reactor.listenTCP( 4573, f, 50, '127.0.0.1')
# start web server
web.WebMixIn.started(self)
f = manager.AMIFactory('admin', 'admin')
def r(proto):
self.admin = proto
self.admin.registerEvent("ConferenceDTMF", self.conferenceDTMF)
self.admin.registerEvent("ConferenceJoin", self.conferenceJoin)
self.admin.registerEvent("ConferenceLeave", self.conferenceLeave)
f.login("127.0.0.1", 5038).addCallback(r)
self.sessions = {}
self.recentlyDisconnected = {}
t = task.LoopingCall(self.cleanRecentlyDisconnected)
t.start(30)
def connect(self):
from obelisk.config import config
self.connected = True
self._f = manager.AMIFactory(config['ami']['user'],
config['ami']['password'])
#logging.basicConfig()
#manager.log.setLevel( logging.DEBUG )
host = config['ami'].get('host', 'localhost')
port = config['ami'].get('port', 5038)
df = self._f.login(host, port)
df.addCallback(self.onLogin)
df.addErrback(self.onLoginError)
def connect():
def onConnect(ami):
global ami_instance
ami_instance = ami
ami.registerEvent('Cdr', onCdr)
ami.registerEvent('Agentlogin', onAgentLogin)
ami.registerEvent('Agentcallbacklogin', onAgentLogin)
ami.registerEvent('Agentlogoff', onAgentLogout)
ami.registerEvent('Agentcallbacklogoff', onAgentLogout)
f = manager.AMIFactory(settings.AMI_USR, settings.AMI_SECRET)
df = f.login(settings.ASTERISK_IP, settings.AMI_PORT, 30.0)
df.addCallback(onConnect)
def login(self):
def on_login_success(self, ami):
self.ami_factory.ping().addCallback(ping_response)
return ami
def on_login_error(self, reason):
print('Failed to log into AMI')
return reason
def ping_response(self, ami):
print('Got a ping response!')
return ami
self.ami_factory = manager.AMIFactory(g_amiId, g_amiPass)
self.ami_factory.login(g_amiIp, g_amiPort).addCallbacks(on_login_success, on_login_error)
def create_ami_factory(self,
count=1,
username="******",
secret="mysecret",
port=5038):
"""Create n instances of AMI. Each AMI instance will attempt to connect
to a previously created instance of Asterisk. When a connection is
complete, the ami_connect method will be called.
Keyword arguments:
count The number of instances of AMI to create
username The username to login with
secret The password to login with
port The port to connect over
"""
for i in range(count):
host = "127.0.0.%d" % (i + 1)
self.ami.append(None)
LOGGER.info("Creating AMIFactory %d" % (i + 1))
ami_factory = manager.AMIFactory(username, secret, i)
deferred = ami_factory.login(ip=host, port=port)
deferred.addCallbacks(self._ami_connect, self.ami_login_error)
def main(channel='sip/1001', connectTo=('phones', '1001', '1')):
f = manager.AMIFactory('aswin', '12345678')
df = f.login(ip='192.168.5.86')
def onLogin(protocol):
"""On Login, attempt to originate the call"""
context, extension, priority = connectTo
df = protocol.originate(
channel,
context,
extension,
priority,
)
def onFinished(result):
df = protocol.logoff()
def onLogoff(result):
reactor.stop()
return df.addCallbacks(onLogoff, onLogoff)
def onFailure(reason):
print(reason.getTraceback())
return reason
df.addErrback(onFailure)
df.addCallbacks(onFinished, onFinished)
return df
def onFailure(reason):
"""Unable to log in!"""
print(reason.getTraceback())
reactor.stop()
df.addCallbacks(onLogin, onFailure)
return df
def main(channel='sip/[email protected]', connectTo=('outgoing', 's', '1')): f = manager.AMIFactory(sys.argv[1], sys.argv[2]) df = f.login() def onLogin(protocol): """On Login, attempt to originate the call""" context, extension, priority = connectTo df = protocol.originate( channel, context, extension, priority, ) def onFinished(result): df = protocol.logoff() def onLogoff(result): reactor.stop() return df.addCallbacks(onLogoff, onLogoff) def onFailure(reason): print(reason.getTraceback()) return reason df.addErrback(onFailure) df.addCallbacks(onFinished, onFinished) return df def onFailure(reason): """Unable to log in!""" print(reason.getTraceback()) reactor.stop() df.addCallbacks(onLogin, onFailure) return df
def started(self):
# start AGI service
f = fastagi.FastAGIFactory(self.connected)
reactor.listenTCP(4573, f, 50, '127.0.0.1')
self.sessions = set()
# establish AMI admin connection
f = manager.AMIFactory('admin', 'admin')
def r(proto):
self.admin = proto
self.admin.registerEvent("ConferenceDTMF", log.msg)
self.admin.registerEvent("MeetmeJoin", self.joined)
self.admin.registerEvent("MeetmeLeave", self.left)
self.admin.originate("SIP/5010",
context="default",
exten="503",
priority="1")
f.login("127.0.0.1", 5038).addCallback(r)
self.chan2user = {}
def main(self):
"""Main operation for the channel-tracking demo"""
theManager = manager.AMIFactory(amiusername, amipassword)
df = theManager.login(amihost, amiport).addCallback(self.onAMIConnect)
def main(self):
theManager = manager.AMIFactory(amiusername, amipassword)
df = theManager.login(amihost, amiport).addCallback(self.onConnect)
def main(self):
theManager = manager.AMIFactory(self.username, self.password)
df = theManager.login(self.host, self.port).addCallback(self.onConnect)
def login(self):
"""Login to the specified manager via the AMI"""
theManager = manager.AMIFactory(self.username, self.secret)
return theManager.login(self.server, self.port, timeout=self.timeout)
from starpy import manager
#usernmae, password
f = manager.AMIFactory(sys.argv[1], sys.argv[2])
df = f.login('server', port)
self.ami.originate(
self.callbackChannel,
self.ourContext, id(self), 1,
timeout = 15,
def onChannelHangup(ami, event):
"""Deal with the hangup of an event"""
if event['uniqueid'] == self.uniqueChannelId:
log.info("""AMI Detected close of our channel: %s""", self.uniqueChannelId)
self.stopTime = time.time()
# give the user a few seconds to put down the hand-set
reactor.callLater(2, df.callback, event)
self.ami.deregisterEvent('Hangup', onChannelHangup)
delf.ami.registerEvent('Hangup', onChannelHangup)
return df.addCallback(self.onHangup, callbacks=5)
def main(self):
"""Main operation for the channel-tracking demo"""
theManager = manager.AMIFactory(ami_user, ami_secret, None,
True) #, self.onAMIConnect )
theManager.login(ami_host, ami_port).addCallback(self.onAMIConnect)
