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 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: