def run_worker(self, args, options):
"""
Runs the Tornado-based queue worker.
"""
import tornado.options
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from signalqueue.worker.vortex import Application
from signalqueue.worker import queues
queue_name = options.get('queue_name')
queue = queues[queue_name]
try:
queue_available = queue.ping()
except:
self.echo("\n--- Can't ping the backend for %s named '%s'" % (queue.__class__.__name__, queue_name), color=16)
self.echo("\n--- Is the server running?", color=16)
self.exit(2)
if not queue_available:
self.echo("\n--- Can't ping the backend for %s named '%s'" % (queue.__class__.__name__, queue_name), color=16)
self.echo("\n--- Is the server running?", color=16)
self.exit(2)
http_server = HTTPServer(Application(queue_name=queue_name,
halt_when_exhausted=options.get('halt_when_exhausted', False)))
http_server.listen(int(options.get('port')), address=options.get('addr'))
try:
IOLoop.instance().start()
except KeyboardInterrupt:
self.echo("Shutting down signal queue worker ...", color=31)
def handle(self, addrport='', *args, **options):
""" Handle command-line options. """
echo_banner()
if args:
raise CommandError('Usage: %s %s' % (__file__, self.args))
self.exit_when_halting = options.get('exit', True)
self.echo('exit_when_halting: ' + str(self.exit_when_halting))
if not addrport:
addr = ''
port = str(settings.SQ_WORKER_PORT) or '8088'
else:
try:
addr, port = addrport.split(':')
except ValueError:
addr, port = '', addrport
if not addr:
addr = '127.0.0.1'
if not port.isdigit():
raise CommandError("%r is not a valid port number." % port)
self.quit_command = (sys.platform
== 'win32') and 'CTRL-BREAK' or 'CONTROL-C'
options.update({
'addr': addr,
'port': port,
})
self.echo("Validating models...")
self.validate(display_num_errors=True)
self.echo(
("\nDjango version %(version)s, using settings %(settings)r\n"
"Tornado worker for queue \"%(queue_name)s\" binding to http://%(addr)s:%(port)s/\n"
"Quit the server with %(quit_command)s.\n") % {
"version": self.get_version(),
"settings": settings.SETTINGS_MODULE,
"queue_name": options.get('queue_name'),
"addr": addr,
"port": port,
"quit_command": self.quit_command,
})
try:
self.run_worker(args, options)
except ImproperlyConfigured, err:
self.echo("*** ERROR in configuration: %s" % err, color=31)
self.echo("*** Check the signalqueue options in your settings.py.",
color=31)
def handle(self, addrport='', *args, **options):
echo_banner()
if args:
raise CommandError('Usage: %s %s' % (__file__, self.args))
self.exit_when_halting = options.get('exit', True)
if not addrport:
addr = ''
port = str(settings.SQ_WORKER_PORT) or '8088'
else:
try:
addr, port = addrport.split(':')
except ValueError:
addr, port = '', addrport
if not addr:
addr = '127.0.0.1'
if not port.isdigit():
raise CommandError("%r is not a valid port number." % port)
self.quit_command = (sys.platform == 'win32') and 'CTRL-BREAK' or 'CONTROL-C'
options.update({
'addr': addr,
'port': port,
})
self.echo("Validating models...")
self.validate(display_num_errors=True)
self.echo(("\nDjango version %(version)s, using settings %(settings)r\n"
"Tornado worker for queue \"%(queue_name)s\" binding to http://%(addr)s:%(port)s/\n"
"Quit the server with %(quit_command)s.\n" ) % {
"version": self.get_version(),
"settings": settings.SETTINGS_MODULE,
"queue_name": options.get('queue_name'),
"addr": addr,
"port": port,
"quit_command": self.quit_command,
})
try:
self.run_worker(args, options)
except ImproperlyConfigured, err:
self.echo("*** ERROR in configuration: %s" % err, color=31)
self.echo("*** Check the signalqueue options in your settings.py.", color=31)
def determine_port(options):
if options:
return (tornado.options.options.port or
options.get('port') or
DEFAULT_PORT)
else:
return tornado.options.options.port or DEFAULT_PORT
def get(key):
env = tornado.options.options.environment
if env not in options:
raise Exception("Invalid Environment (%s)" % env)
v = options.get(env).get(key) or default.get(key)
if callable(v):
return v()
return v
def get(key):
env = tornado.options.options.environment
if env not in options:
raise Exception("Invalid Environment (%s)" % env)
v = options.get(env).get(key) or default.get(key)
if callable(v):
return v()
return v
def run_worker(self, args, options):
self.echo('run_worker')
""" Runs the Tornado-based queue worker. """
import tornado.options
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from signalqueue.worker.vortex import Application
from signalqueue.worker import backends
import signalqueue
queue_name = options.get('queue_name')
queues = backends.ConnectionHandler(
settings.SQ_QUEUES, signalqueue.SQ_RUNMODES['SQ_ASYNC_MGMT'])
queue = queues[queue_name]
try:
queue_available = queue.ping()
except:
self.echo("\n--- Can't ping the backend for %s named '%s'" %
(queue.__class__.__name__, queue_name),
color=16)
self.echo("\n--- Is the server running?", color=16)
self.exit(2)
if not queue_available:
self.echo("\n--- Can't ping the backend for %s named '%s'" %
(queue.__class__.__name__, queue_name),
color=16)
self.echo("\n--- Is the server running?", color=16)
self.exit(2)
http_server = HTTPServer(
Application(
queue_name=queue_name,
halt_when_exhausted=options.get('halt_when_exhausted', False),
log_exceptions=options.get('log_exceptions', True),
))
http_server.listen(int(options.get('port')),
address=options.get('addr'))
try:
IOLoop.instance().start()
except KeyboardInterrupt:
self.echo("Shutting down signal queue worker ...", color=31)
def send_hangup(self, call_id, status):
data = self.session[call_id]["data"]
options = self.session[call_id]["options"]
generate_status = options.get("generate_status", 0)
invite_time = self.session[call_id].get("invite_time", 0)
ring_time = self.session[call_id].get("ring_time", 0)
answered_time = self.session[call_id].get("answered_time", 0)
disconnected_time = self.session[call_id].get("disconnected_time",
int(time.time()))
end_reason = self.session[call_id].get("end_reason", 0)
if 0 == status:
if generate_status:
if not invite_time:
invite_time = self.session[call_id].get("req_time") + 1
self.send_status(call_id, 1, 1, invite_time)
if not ring_time:
ring_time = invite_time + 3
self.send_status(call_id, 1, 2, ring_time)
if answered_time:
self.send_status(call_id, 1, 3, answered_time)
self.send_status(call_id, 1, 4, disconnected_time)
sip_code = 200
else:
if generate_status:
self.send_status(call_id, 1, 5, disconnected_time)
sip_code = 480
body = json.dumps({
"appId": data["appId"],
"callId": data["callId"],
"addr": base_cfg["listen_ip"],
"caller": data["aCaller"],
"callee": data["aCallee"],
"inviteTime": invite_time,
"ringTime": ring_time,
"answeredTime": answered_time,
"disconnectedTime": disconnected_time,
"endReason": end_reason,
"sipCode": sip_code,
"apiType": data["apiType"],
"status": status
})
sign = generate_sign(body, base_cfg["rest_key"])
url = "http://{0}:{1}/rest/hangup?sign={2}".format(
base_cfg["rest_ip"], base_cfg["rest_port"], sign)
logging.info(u"send hangup, url:{0}, call_id:{1}, body:{2}".format(
url, call_id, body))
self.async_urlopen(url=url, method="POST", body=body)
def request_timeout(self, call_id):
logging.error("session request timeout, call_id:{0}".format(call_id))
options = self.session[call_id]["options"]
generate_status = options.get("generate_status", 0)
# failed
if not generate_status:
self.send_status(call_id, 1, 5, int(time.time()))
# no ring
self.send_hangup(call_id, 2)
def max_allow_timeout(self, call_id):
logging.warn("session max allow timeout, call_id:{0}".format(call_id))
options = self.session[call_id]["options"]
generate_status = options.get("generate_status", 0)
# disconnected
if not generate_status:
self.send_status(call_id, 1, 5, int(time.time()))
# success
self.send_hangup(call_id, 0)
def get(key):
"""
provides ability to get settings values with settings.get('SETTING_YOU_WANT')
"""
env = tornado.options.options.environment
if env not in options:
raise Exception("Invalid Environment (%s)" % tornado.options.options.environment)
v = options.get(env).get(key) or default_options.get(key)
if callable(v):
return v
if v is not None:
return v
return default_options.get(key)
def get(key):
# check for an environmental variable (used w Heroku) first
if os.environ.get('ENVIRONMENT'):
env = os.environ.get('ENVIRONMENT')
else:
env = tornado.options.options.environment
if env not in options:
raise Exception("Invalid Environment (%s)" % tornado.options.options.environment)
v = options.get(env).get(key) or default_options.get(key)
if callable(v):
return v
if v is not None:
return v
return default_options.get(key)
def get(key):
# check for an environmental variable (used w Heroku) first
if os.environ.get('ENVIRONMENT'):
env = os.environ.get('ENVIRONMENT')
else:
env = tornado.options.options.environment
if env not in options:
raise Exception("Invalid Environment (%s)" % env)
if key == 'environment':
return env
v = options.get(env).get(key) or os.environ.get(
key.upper()) or default_options.get(key)
if callable(v):
return v
if v is not None:
return v
return default_options.get(key)
class StatsHandler(BaseHandler):
def get(self):
self.api_response(_c2dm.get_stats())
if __name__ == "__main__":
tornado.options.define("port", default=8888, help="Listen on port", type=int)
tornado.options.define("max_concurrent", default=64, help="max concurrent http requests", type=int)
tornado.options.define("Email", default=None, help="Google client email", type=str)
tornado.options.define("Passwd", default=None, help="Google client password", type=str)
tornado.options.define("source", default=None, help="C2DM source", type=str)
tornado.options.parse_command_line()
''' allow sensitive data to be passed on cmd line ( so everyone can see it w ps ) '''
for key in ['Email', 'Passwd', 'source', 'max_concurrent']:
if key in tornado.options.options and tornado.options.options[key].value():
options.get(env())['login'][key] = tornado.options.options[key].value()
logging.getLogger().setLevel(settings.get('logging_level'))
# the global c2dm
_c2dm = c2dm(max_concurrent=settings.get('max_concurrent'))
application = tornado.web.Application([
(r"/push", PushHandler),
(r"/stats", StatsHandler),
(r"/flush", FlushHandler),
], debug=(env() == 'dev'))
application.listen(tornado.options.options.port)
tornado.ioloop.IOLoop.instance().start()
def set_env(environments):
env_options = environments.get(get_env(), {})
for setting, value in env_options.items():
if options.get(setting):
options[setting].set(value)
def get_env():
if options.get('env'):
return options.env
else:
return os.getenv('HYDRA_ENV')
class StatsHandler(BaseHandler):
def get(self):
self.api_response(_smtp.get_stats())
if __name__ == "__main__":
tornado.options.define("port", default=8888, help="Listen on port", type=int)
tornado.options.define("smtphost", default=None, help="smtp host", type=str)
tornado.options.define("smtpport", default=25, help="smtp port", type=int)
tornado.options.define("usetls", default=True, help="use TLS", type=bool)
tornado.options.define("user", default=None, help="smtp user", type=str)
tornado.options.define("password", default=None, help="smtp password", type=str)
tornado.options.parse_command_line()
''' allow sensitive data to be passed on cmd line ( so everyone can see it w ps ) '''
for key in ['smtphost', 'smtpport', 'user', 'password']:
if key in tornado.options.options and tornado.options.options[key].value():
options.get(env())[key] = tornado.options.options[key].value()
logging.getLogger().setLevel(settings.get('logging_level'))
_smtp = smtprelay(settings.get("smtphost"), settings.get("smtpport"),
settings.get("user"), settings.get("password"), usetls=settings.get("usetls"))
application = tornado.web.Application([
(r"/push", PushHandler),
(r"/stats", StatsHandler),
], debug=(env() == 'dev'))
application.listen(tornado.options.options.port)
tornado.ioloop.IOLoop.instance().start()
except Exception as e:
self.error(status_code=500, status_txt="ERROR", data=str(e))
class StatsHandler(BaseHandler):
def get(self):
self.api_response(_c2dm.get_stats())
if __name__ == "__main__":
tornado.options.define("port", default=8888, help="Listen on port", type=int)
tornado.options.define("Email", default=None, help="Google client email", type=str)
tornado.options.define("Passwd", default=None, help="Google client password", type=str)
tornado.options.define("source", default=None, help="C2DM source", type=str)
tornado.options.parse_command_line()
""" allow sensitive data to be passed on cmd line ( so everyone can see it w ps ) """
for key in ["Email", "Passwd", "source"]:
if key in tornado.options.options and tornado.options.options[key].value():
options.get(env())["login"][key] = tornado.options.options[key].value()
logging.getLogger().setLevel(settings.get("logging_level"))
# the global c2dm
_c2dm = c2dm()
application = tornado.web.Application(
[(r"/push", PushHandler), (r"/stats", StatsHandler), (r"/flush", FlushHandler)], debug=(env() == "dev")
)
application.listen(tornado.options.options.port)
tornado.ioloop.IOLoop.instance().start()
'link': link,
'channels': feed_channels,
'timestamp': timestamp,
})
# Mark feed in cache
feeds_cache[feed_key] = str(time.time())
# Only report up to rss_limit entries for this feed
entries[feed_title] = entries[feed_title][0:entries_limit]
for feed_title, feed_entries in entries.items():
entries[feed_title] = list(
sorted(feed_entries, key=lambda e: e['timestamp']))
json.dump(entries, sys.stdout)
# Main Execution
if __name__ == '__main__':
tornado.options.define('config_dir',
default=None,
help='Configuration directory')
tornado.options.parse_command_line()
options = tornado.options.options.as_dict()
script(os.path.expanduser(options.get('config_dir', '~/.config/bobbit')))
# vim: set sts=4 sw=4 ts=8 expandtab ft=python:
