def run_hub(task): logging.basicConfig(level=logging.DEBUG) task.reset() # Register on receive callback. task.command_stream = zmqstream.ZMQStream(task.command_socket) task.command_stream.on_recv(task.on_command_recv) # Register on receive callback. task.query_stream = zmqstream.ZMQStream(task.query_socket) task.query_stream.on_recv(task.on_query_recv) def dump_registry(): print '\n' + (72 * '*') + '\n' print task.registry print '\n' + (72 * '*') + '\n' try: ioloop.install() logger.info('Starting hub ioloop') PeriodicCallback(dump_registry, 100, io_loop=ioloop.IOLoop.instance()).start() ioloop.IOLoop.instance().start() except RuntimeError: logger.warning('IOLoop already running.')
def _init_context(self, context): self.context = context or zmq.Context.instance() if self.loop is None: ioloop.install() self.loop = ioloop.IOLoop.instance() self.ctrl = Controller(self.endpoint, self.multicast_endpoint, self.context, self.loop, self, self.check_delay)
def run(self): if self.filename == 'sys.stdout': self.file = sys.stdout elif self.filename == 'sys.stderr': self.file = sys.stderr else: self.file = open(self.filename, 'a+b') ioloop.install() loop = ioloop.IOLoop.instance() stream = None try: context = zmq.Context() socket = context.socket(zmq.SUB) socket.connect(self.addr) socket.setsockopt(zmq.SUBSCRIBE, '') stream = ZMQStream(socket) except Exception, err: print self.name, 'error getting outstream:', err exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_exception(exc_type, exc_value, exc_traceback) traceback.print_tb(exc_traceback, limit=30) if stream and not stream.closed(): stream.close()
def run(self): ioloop.install() # Command stream. self._ctx = zmq.Context() self._cmd_sock = self._ctx.socket(zmq.REQ) self._auth_token = _extract_auth_token(sys.argv[1]) addr = _remove_auth_token(sys.argv[1]) self._cmd_sock.connect(addr) self._cmd_sock.send_json((self._auth_token, 'port_info',)) self._data_port, md = self._cmd_sock.recv_json() self._cmd_stream = zmqstream.ZMQStream(self._cmd_sock) self._cmd_stream.on_recv(self._handle_cmd_feedback) wx.CallAfter(Publisher().sendMessage, "init", md) # Data stream. addr = _remove_auth_token(sys.argv[1]) addr = "%s:%s" % (addr.rsplit(':', 1)[0], self._data_port) self._sock = self._ctx.socket(zmq.SUB) self._sock.connect(addr) self._sock.setsockopt(zmq.SUBSCRIBE, '') self._stream = zmqstream.ZMQStream(self._sock) self._stream.on_recv(self._handle_data) # UI stream. self._ui_sock = self._ui_ctx.socket(zmq.SUB) self._ui_sock.setsockopt(zmq.SUBSCRIBE, '') self._ui_sock.connect('inproc://ui') self._ui_stream = zmqstream.ZMQStream(self._ui_sock) self._ui_stream.on_recv(self._handle_ui) ioloop.IOLoop.instance().start()
def initialize(self, argv=None): super(IPKernelApp, self).initialize(argv) if self.subapp is not None: return # register zmq IOLoop with tornado zmq_ioloop.install() self.init_blackhole() self.init_connection_file() self.init_poller() self.init_sockets() self.init_heartbeat() # writing/displaying connection info must be *after* init_sockets/heartbeat self.write_connection_file() # Log connection info after writing connection file, so that the connection # file is definitely available at the time someone reads the log. self.log_connection_info() self.init_io() self.init_signal() self.init_kernel() # shell init steps self.init_path() self.init_shell() if self.shell: self.init_gui_pylab() self.init_extensions() self.init_code() # flush stdout/stderr, so that anything written to these streams during # initialization do not get associated with the first execution request sys.stdout.flush() sys.stderr.flush()
def main(options): install() logger = logging.getLogger() logger.setLevel(logging.DEBUG if options.debug else logging.INFO) logger.propagate = False handler = logging.StreamHandler() handler.setFormatter(ColorUTCFormatter()) logger.addHandler(handler) config = Config.load_yaml(options.config) random.seed(0) def on_db_ready(**dbs): msgman = MsgManager(config) msgman.connect() connman = ConnManager(pub_socket=msgman.pub_to_broker, sub_socket=msgman.sub_to_broker, locations_sub_socket=msgman.sub_to_locs) game_config = Config.load_yaml(options.game_config) root = Root(config, game_config, connman, msgman, dbs) msgman.setup(connman, root) server = TCPServer() server.setup(Protocol, connman, root, options.max_conn) server.listen(options.port) prepare_dbs(config, on_db_ready) if options.debug: set_debug_mode() IOLoop.instance().start()
def setUp(self): ioloop.install() super(TestCircus, self).setUp() self.arbiters = [] self.files = [] self.dirs = [] self.tmpfiles = [] self.cli = AsyncCircusClient()
def main(): logger.info('Starting') ioloop.install() # See the link in the module's docstring application = web.Application( [(r'/', HomepageHandler)], ) application.listen(config.HTTP_PORT) ioloop.IOLoop.instance().start()
def runFifoNetWorker(self, netName, pubAgentAddr, sinkAgentAddr, neighbor): self.dataObject = None self.dataObjectId = None ioloop.install() self.prMod = None self.nodeIloop = ioloop.IOLoop.instance() self.statusQueue = Queue() self.fifoStats = FifoStats() logFname = netName.replace(":", "_") logFname = "logs/"+logFname logging.basicConfig(level=logging.DEBUG, filename=logFname) self.name = netName self.pubAgent = pubAgentAddr self.sinkAgent = sinkAgentAddr self.neighborAddr = "tcp://"+neighbor self.neighbor = neighbor logging.debug("\tCreating SubAgent socket") self.context = zmq.Context() self.cmdSubSock = self.context.socket(zmq.SUB) self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, netName) self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'Exit') self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'ConnectToNeighbor') self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'TestConnectionToNeighbor') self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'Reset') self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'Set') self.cmdSubSock.setsockopt(zmq.SUBSCRIBE, b'Echo') self.cmdSubSock.connect(self.pubAgent) self.streamCmdIn = zmqstream.ZMQStream(self.cmdSubSock) self.streamCmdIn.on_recv_stream(self.procAgentCmd) logging.debug("\tCreating PUSH-to-Agent socket") self.cmdReqRepSock = self.context.socket(zmq.REQ) self.cmdReqRepSock.connect(self.sinkAgent) self.streamCmdOut = zmqstream.ZMQStream(self.cmdReqRepSock) self.streamCmdOut.on_send(self.cmdOutRequestToSink) self.stupidVerificationSocket = self.context.socket(zmq.REQ) self.stupidVerificationSocket.connect(self.sinkAgent) logging.debug("\tCreating Local Server socket") self.peerSockServ = self.context.socket(zmq.REP) localbindAddr = "tcp://*:"+netName.split(':')[1] self.peerSockServ.bind(localbindAddr) self.peerServStream = zmqstream.ZMQStream(self.peerSockServ) self.peerServStream.on_recv_stream(self.procPeerRxServerMsg) self.peerServStream.on_send_stream(self.procPeerTxServerMsg) self.nodeIloop.start()
def runserver(args): settings = json.load(args.config) ioloop.install() loop = IOLoop.instance() listeners = [] if "air" in settings.keys(): from components.air import air_handlers listeners += air_handlers if "roots" in settings.keys(): from components.roots import roots_handlers listeners += roots_handlers if "branch" in settings.keys(): from components.branch import branch_handlers listeners += branch_handlers if "druid" in settings.keys(): from components.druid import druid_handlers listeners += druid_handlers application = Trunk(settings["base"], handlers=listeners) if "air" in settings.keys(): from components.air import Air application.air = Air(application, settings["air"]["host"], settings["air"]["port"]) if "roots" in settings.keys(): from components.roots import Roots application.roots = Roots(application, settings["roots"]) if "branch" in settings.keys(): from components.branch import Branch application.branch = Branch(application, settings["branch"]) if "druid" in settings.keys(): from components.druid import Druid application.druid = Druid(application, settings["druid"]) application.listen(settings["base"]["port"], settings["base"]["host"]) def cleanup(signum=None, frame=None): if signum != signal.SIGQUIT: log_message("Cleaning up...", begin="\r") application.cleanup() log_message("Done!") else: log_message("Shutting down forest, keeping uwsgi", begin="\r") loop.stop() sys.exit(0) for sig in [signal.SIGTERM, signal.SIGINT, signal.SIGQUIT]: signal.signal(sig, cleanup) loop.start()
def start_io_loop(): if not tornado.ioloop.IOLoop.instance(): ioloop.install() try: tornado.ioloop.IOLoop.instance().start() except Exception as e: print "openbazaar::start_io_loop Exception:", e raise
def _setup_tornado(self): if self._is_setup: return from zmq.eventloop import ioloop, zmqstream ioloop.install() from tornado.ioloop import IOLoop self._zmqioloop = ioloop self._zmqstream = zmqstream self._tornadoioloop = IOLoop self._is_setup = True
def run(parser=None, options=None, args=None): ''' Launch the GUI with specified options. ''' # install zmq ioloop before creating any tornado objects ioloop.install() # create the server and kick it off server = AppServer(options) server.serve()
def start(self): """Starts the server""" ioloop.install() connection = self.config["transport"] + "://" + self.config["ip"] secure_key = self.config["key"].encode() digestmod = self.signature_schemes[self.config["signature_scheme"]] self.auth = hmac.HMAC(secure_key, digestmod=digestmod) # Heartbeat ctx = zmq.Context() self.heartbeat_socket = ctx.socket(zmq.REP) self.config["hb_port"] = bind( self.heartbeat_socket, connection, self.config["hb_port"] ) # IOPub/Sub, aslo called SubSocketChannel in IPython sources self.iopub_socket = ctx.socket(zmq.PUB) self.config["iopub_port"] = bind( self.iopub_socket, connection, self.config["iopub_port"] ) self.iopub_stream = zmqstream.ZMQStream(self.iopub_socket) self.iopub_stream.on_recv(self.iopub_handler) # Control self.control_socket = ctx.socket(zmq.ROUTER) self.config["control_port"] = bind( self.control_socket, connection, self.config["control_port"] ) self.control_stream = zmqstream.ZMQStream(self.control_socket) self.control_stream.on_recv(self.control_handler) # Stdin: self.stdin_socket = ctx.socket(zmq.ROUTER) self.config["stdin_port"] = bind( self.stdin_socket, connection, self.config["stdin_port"] ) self.stdin_stream = zmqstream.ZMQStream(self.stdin_socket) self.stdin_stream.on_recv(self.stdin_handler) # Shell self.shell_socket = ctx.socket(zmq.ROUTER) self.config["shell_port"] = bind( self.shell_socket, connection, self.config["shell_port"] ) self.shell_stream = zmqstream.ZMQStream(self.shell_socket) self.shell_stream.on_recv(self.shell_handler) # start up configurtation self.dprint(2, "Config:", json.dumps(self.config)) self.dprint(1, "Starting loops...") self.hb_thread = threading.Thread(target=self.heartbeat_loop) self.hb_thread.daemon = True self.hb_thread.start() self.dprint(1, "Ready! Listening...") ioloop.IOLoop.instance().start()
def worker(vent_address,sink_address,sz,dtype): import zmq import theano from zmq.eventloop import ioloop ioloop.install() from zmq.eventloop.zmqstream import ZMQStream # Context context = zmq.Context() # Socket to receive messages on receiver = context.socket(zmq.PULL) receiver.connect(vent_address) receiver_stream = ZMQStream(receiver) # Socket to send messages to sender = context.socket(zmq.PUSH) sender.connect(sink_address) def _worker(msg_list, sz=sz, dtype=dtype, sender=sender): import theano import numpy as np msg = msg_list[0] # if normalize_A does any inplace operation, we need to .copy() here: new_A = np.frombuffer(buffer(msg), dtype=dtype).reshape(sz).copy() new_A = l.model.normalize_A(new_A) l.model.A.set_value(new_A.astype(theano.config.floatX)) x = l.get_databatch() dA = l.model.gradient(x)['dA'] dA *= l.eta param_max = np.max(np.abs(l.model.A.get_value()), axis=0) update_max = np.max(np.abs(dA), axis=0) update_max = np.max(update_max / param_max) l._adapt_eta(update_max) # no subset selection: sender.send(dA,copy=False) # subset selection: #inds = np.argwhere(dA.sum(0) != 0.).ravel() #subset_dA = dA[:, inds] #sender.send_pyobj(dict(inds=inds, subset_dA=subset_dA)) receiver_stream.on_recv(_worker,copy=False) iolooper = ioloop.IOLoop.instance() iolooper.start() return
def main(): ''' Process command line arguments, create server, and start it up. ''' # make sure to install zmq ioloop before creating any tornado objects ioloop.install() # create the server and kick it off parser = ZMQServer.get_options_parser() (options, args) = parser.parse_args() server = ZMQServer(options) server.serve()
def run(self): """ The main run loop for the management process. Sets a signal handler so that the process can be stopped by sending SIGTERM. You can also call the "stop()" function from inside the same process to stop the management server. This version of the run loop does provides the web configuration front-end. The web front-end is a RESTful API that provides status and configuration command and control interfaces. See api_client for use. :return: 0 on success, nonzero for error conditions. """ Controller.instance = self zmq_ioloop.install() signal.signal(signal.SIGTERM, self._stop_signal_handler) # Setup the web application self.application = tornado.web.Application(api.handlers, gzip=True) self.application.listen(self.config.get("management", "configuration_port"), address=self.config.get("management", "configuration_ip")) # Setup handlers to care for the management tasks. announce_timer = tornado.ioloop.PeriodicCallback(self.announce_presence, 1000) management_timer = tornado.ioloop.PeriodicCallback(self.process_node_tasks, 100) leader_timer = tornado.ioloop.PeriodicCallback(self.process_leader_tasks, 100) announce_timer.start() management_timer.start() leader_timer.start() instance = zmq_ioloop.ZMQIOLoop.instance() instance.add_handler(self.presence_socket.fileno(), self._process_presence, zmq_ioloop.ZMQIOLoop.READ) # Start the I/O loop logging.info("Started management process, announcing on %s:%s, configuration=%s:%s, command=%s:%s", self.mcast_group, self.mcast_port, self.config.get("management", "configuration_ip"), self.config.get("management", "configuration_port"), self.config.get("management", "management_ip"), self.config.get("management", "management_port") ) instance.start() announce_timer.stop() management_timer.stop() leader_timer.stop() # Unregister the signal handler and exit. signal.signal(signal.SIGTERM, signal.SIG_DFL) logging.info("Stopped management process.") return 0
def install_zmq_hooks(): ioloop.install() context = zmq.Context() socket_jobs = context.socket(zmq.SUB) socket_jobs.setsockopt(zmq.SUBSCRIBE, "") socket_jobs.connect ("tcp://localhost:%s" % GATEWAY_PORT_JOBS) stream_jobs = zmqstream.ZMQStream(socket_jobs) stream_jobs.on_recv(pushjobs) socket_logs = context.socket(zmq.SUB) socket_logs.setsockopt(zmq.SUBSCRIBE, "") socket_logs.connect ("tcp://localhost:%s" % GATEWAY_PORT_LOGS) stream_logs = zmqstream.ZMQStream(socket_logs) stream_logs.on_recv(pushlogs)
def __init__(self, *args, **kw): self.context = zmq.Context() ioloop.install() zmq_broker_address = conf.get('dealer', 'zmq_broker_address') if zmq_broker_address == None: zmq_broker_address = "tcp://localhost:5570" self.dealer = self.context.socket(zmq.DEALER) self.dealer.identity = (u"Dealer-%s-%s" % (socket.getfqdn(), os.getpid())).encode('ascii') self.dealer.connect(zmq_broker_address) self.dealer_stream = zmqstream.ZMQStream(self.dealer) self.dealer_stream.on_recv(self.stop)
def main(args=None): if args is None: args = sys.argv[1:] parser = optparse.OptionParser() parser.add_option("--repurl", action="store", type="string", dest='repurl', help="url of REP socket", default='tcp://*:5555') parser.add_option("--puburl", action="store", type="string", dest='puburl', help="url of PUB socket", default='tcp://*:5556') parser.add_option("-c", "--class", action="store", type="string", dest='classpath', help="module path to class of top level component") parser.add_option("-p", "--publish", action="append", type="string", dest='published', help="specify a variable to publish", default=[]) parser.add_option("--wspub", action="store", type="string", dest='wspub', help="route to pub websocket") parser.add_option("--wscmd", action="store", type="string", dest='wscmd', help="route to cmd websocket") (options, args) = parser.parse_args(args) if options.classpath is None: print "you must specify the module path to a class or factory function" parser.print_help() sys.exit(-1) if options.wspub or options.wscmd: ioloop.install() # must call this before importing any tornado stuff parts = options.classpath.split('.') modpath = '.'.join(parts[:-1]) __import__(modpath) try: mod = sys.modules[modpath] ctor = getattr(mod, parts[-1]) except (KeyError, AttributeError): print "can't locate %s" % options.classpath sys.exit(-1) top = set_as_top(ctor()) top.register_published_vars(options.published) ZmqCompWrapper.serve(top, rep_url=options.repurl, pub_url=options.puburl, wspub=options.wspub, wscmd=options.wscmd)
def run_plugin(task): logging.basicConfig(level=logging.DEBUG) task.reset() # Register on receive callback. task.command_stream = zmqstream.ZMQStream(task.command_socket) task.command_stream.on_recv(task.on_command_recv) # Register on receive callback. task.query_stream = zmqstream.ZMQStream(task.subscribe_socket) task.query_stream.on_recv(task.on_subscribe_recv) try: ioloop.install() logger.info('Starting plugin %s ioloop' % task.name) ioloop.IOLoop.instance().start() except RuntimeError: logger.warning('IOLoop already running.')
def run_hub(task, log_level=None): if log_level is not None: logging.basicConfig(level=log_level) task.reset() # Register on receive callback. task.command_stream = zmqstream.ZMQStream(task.command_socket) task.command_stream.on_recv(task.on_command_recv) # Register on receive callback. task.query_stream = zmqstream.ZMQStream(task.query_socket) task.query_stream.on_recv(task.on_query_recv) try: ioloop.install() logger.info('Starting hub ioloop') ioloop.IOLoop.instance().start() except RuntimeError: logger.warning('IOLoop already running.')
def main(options): install() logger = logging.getLogger() logger.setLevel(logging.DEBUG if options.debug else logging.INFO) handler = logging.StreamHandler() handler.setFormatter(ColorUTCFormatter()) logger.addHandler(handler) config = Config.load_yaml(options.config) msgman = MsgManager(config) msgman.connect() connman = ConnManager(pub_socket=msgman.pub_to_broker, sub_socket=msgman.sub_to_broker, locations_sub_socket=msgman.sub_to_locs) root = Root(config, connman, msgman) msgman.setup(connman, root) server = TCPServer() server.setup(Protocol, connman, root, options.max_conn) server.listen(options.port) IOLoop.instance().start()
def main(): ioloop.install() parser = argparse.ArgumentParser() parser.add_argument('-i', '--interface', help='Bind interface') parser.set_defaults(interface=DEFAULT_INTERFACE) options = parser.parse_args() application = tornado.web.Application([ (r'/apps/register', RegisterHandler), (r'/apps/unregister', UnRegisterHandler), (r'/apps/([0-9]+)', UpdateHandler), (r'/apps/query', QueryHandler) ]) application.options = options address, port = options.interface.split(':') application.listen(port, address=address) try: ioloop.IOLoop.instance().start() except KeyboardInterrupt: print 'Interrupted'
def main(options): install() logger = logging.getLogger() logger.setLevel(logging.DEBUG if options.debug else logging.INFO) logger.propagate = False handler = logging.StreamHandler() handler.setFormatter(ColorUTCFormatter()) logger.addHandler(handler) loc_config = Config.load_yaml(options.location_config) random.seed(0) ioloop = IOLoop.instance() db_fut = prepare_db(loc_config, ioloop) ioloop.start() db = db_fut.result() config = Config.load_yaml(options.config) gateway = Gateway(config, loc_config.ident) root = Root(gateway, loc_config, db) gateway.setup(root) connected = gateway.connect(loc_config.pub_address, loc_config.pull_address) if not connected: return wh_conf = loc_config.work_handlers work_handlers = dict(load_work_handlers(wh_conf.path, db, gateway)) root.work_handlers = work_handlers for _ in range(wh_conf.tick_processors): process_ticks(db, work_handlers, wh_conf.works_per_step) if options.debug: set_debug_mode() gateway.start(ioloop) # runs ioloop again
def initialize(self, argv=None): super(IPKernelApp, self).initialize(argv) if self.subapp is not None: return # register zmq IOLoop with tornado zmq_ioloop.install() self.init_blackhole() self.init_connection_file() self.init_poller() self.init_sockets() self.init_heartbeat() # writing/displaying connection info must be *after* init_sockets/heartbeat self.write_connection_file() # Log connection info after writing connection file, so that the connection # file is definitely available at the time someone reads the log. self.log_connection_info() self.init_io() try: self.init_signal() except: # Catch exception when initializing signal fails, eg when running the # kernel on a separate thread if self.log_level < logging.CRITICAL: self.log.error("Unable to initialize signal:", exc_info=True) self.init_kernel() # shell init steps self.init_path() self.init_shell() if self.shell: self.init_gui_pylab() self.init_extensions() self.init_code() # flush stdout/stderr, so that anything written to these streams during # initialization do not get associated with the first execution request sys.stdout.flush() sys.stderr.flush()
def main(): parser = ArgumentParser('Router to publish messages to edge nodes.') parser.add_argument('config', help='path to the config file') args, settings = parser.parse_args(), {} load_into_settings(args.config, settings) config = settings['config'] ioloop.install() loop = ioloop.IOLoop.instance() context = zmq.Context() pull_socket = context.socket(zmq.PULL) pull_socket.bind(config.get('zeromq', 'pull')) pull_stream = zmqstream.ZMQStream(pull_socket, loop) print 'PULL socket on', config.get('zeromq', 'pull') pub_socket = context.socket(zmq.PUB) pub_socket.bind(config.get('zeromq', 'pub')) pub_stream = zmqstream.ZMQStream(pub_socket, loop) print 'PUB socket on', config.get('zeromq', 'pub') Proxy(pull_stream, pub_stream) loop.start()
import sys from tornado.ioloop import IOLoop from async_pubsub.zmq_pubsub import ZMQPubSub from async_pubsub.constants import (CALLBACK_TYPE_CONNECTED, CALLBACK_TYPE_SUBSCRIBED, CALLBACK_TYPE_UNSUBSCRIBED, CALLBACK_TYPE_MESSAGE, CALLBACK_TYPE_DISCONNECTED) from zmq.eventloop import ioloop as zmq_ioloop zmq_ioloop.install() ioloop = IOLoop.instance() class Subscriber(object): def __init__(self, channel_id): self.channel_id = channel_id self.r = ZMQPubSub(callback=self.callback) self.r.connect() def callback(self, evtype, *args, **kwargs): if evtype == CALLBACK_TYPE_CONNECTED: print 'connected' self.r.subscribe(self.channel_id) elif evtype == CALLBACK_TYPE_SUBSCRIBED: print 'subscribed to channel_id %s' % args[0] elif evtype == CALLBACK_TYPE_MESSAGE: print 'received on channel_id %s message %s' % (args[0], args[1]) self.r.unsubscribe() elif evtype == CALLBACK_TYPE_UNSUBSCRIBED: print 'unsubscribed'
import zmq from zmq.eventloop import ioloop, zmqstream """ ioloop.install() must be called prior to instantiating *any* tornado objects, and ideally before importing anything from tornado, just to be safe. install() sets the singleton instance of tornado.ioloop.IOLoop with zmq's IOLoop. If this is not done properly, multiple IOLoop instances may be created, which will have the effect of some subset of handlers never being called, because only one loop will be running. """ ioloop.install() import tornado import tornado.web """ this application can be used with echostream.py, start echostream.py, start web.py, then every time you hit http://localhost:8888/, echostream.py will print out 'hello' """ def printer(msg): print(msg) ctx = zmq.Context() s = ctx.socket(zmq.REQ) s.connect('tcp://127.0.0.1:5555') stream = zmqstream.ZMQStream(s)
# -*- coding: utf-8 -*- from zmq.eventloop import ioloop; ioloop.install() from zmq.eventloop.zmqstream import ZMQStream import zmq from tornado import websocket import tornado try: import cPickle as pickle except ImportError: import pickle ctx = zmq.Context() class MainHandler(websocket.WebSocketHandler): """ This is a main tornado handler that receives all websocket connections. """ _first = True _namespace = 'default' @property def ref(self): return id(self) def initialize(self):
def start_node(my_market_ip, my_market_port, log_file, market_id, bm_user=None, bm_pass=None, bm_port=None, seed_peers=[], seed_mode=0, dev_mode=False, log_level=None, database='db/ob.db', disable_upnp=False): logging.basicConfig(level=int(log_level), format='%(asctime)s - %(name)s - \ %(levelname)s - %(message)s', filename=log_file) locallogger = logging.getLogger('[%s] %s' % (market_id, 'root')) handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=50, backupCount=0) locallogger.addHandler(handler) application = MarketApplication(my_market_ip, my_market_port, market_id, bm_user, bm_pass, bm_port, seed_peers, seed_mode, dev_mode, database) error = True port = 8888 while error and port < 8988: try: application.listen(port) error = False except: port += 1 if not disable_upnp: application.setup_upnp_port_mapping(port) else: print "Disabling upnp setup" locallogger.info("Started OpenBazaar Web App at http://%s:%s" % (my_market_ip, port)) print "Started OpenBazaar Web App at http://%s:%s" % (my_market_ip, port) # handle shutdown def shutdown(x, y): locallogger = logging.getLogger('[%s] %s' % (market_id, 'root')) locallogger.info("Received TERMINATE, exiting...") #application.get_transport().broadcast_goodbye() application.cleanup_upnp_port_mapping() application.market.p.kill() sys.exit(0) try: signal.signal(signal.SIGTERM, shutdown) except ValueError: # not the main thread pass if not tornado.ioloop.IOLoop.instance(): ioloop.install() else: tornado.ioloop.IOLoop.instance().start()
import argparse import copy import getpass import inspect import json import logging import math import os import time import traceback from os.path import expanduser import visdom from zmq.eventloop import ioloop ioloop.install() # Needs to happen before any tornado imports! import tornado.ioloop # noqa E402: gotta install ioloop first import tornado.web # noqa E402: gotta install ioloop first import tornado.websocket # noqa E402: gotta install ioloop first import tornado.escape # noqa E402: gotta install ioloop first LAYOUT_FILE = 'layouts.json' DEFAULT_ENV_PATH = '%s/.visdom/' % expanduser("~") DEFAULT_PORT = 8097 def get_rand_id(): return str(hex(int(time.time() * 10000000))[2:])
# Distributed under the terms of the BSD License. The full license is in # the file COPYING, distributed as part of this software. #----------------------------------------------------------------------------- #----------------------------------------------------------------------------- # Imports #----------------------------------------------------------------------------- # stdlib import logging import os # Install the pyzmq ioloop. This has to be done before anything else from # tornado is imported. from zmq.eventloop import ioloop ioloop.install() from tornado import httpserver from tornado import web try: from tornado.log import app_log except ImportError: logging.basicConfig() app_log = logging.getLogger() # IPython from IPython.kernel.multikernelmanager import MultiKernelManager
def main(args=None): if args is None: args = sys.argv[1:] parser = optparse.OptionParser() parser.add_option("--repurl", action="store", type="string", dest='repurl', help="url of REP socket", default='tcp://*:5555') parser.add_option("--puburl", action="store", type="string", dest='puburl', help="url of PUB socket", default='tcp://*:5556') parser.add_option("-c", "--class", action="store", type="string", dest='classpath', help="module path to class of top level component") parser.add_option("-p", "--publish", action="append", type="string", dest='published', help="specify a variable to publish", default=[]) parser.add_option("--wspub", action="store", type="string", dest='wspub', help="route to pub websocket") parser.add_option("--wscmd", action="store", type="string", dest='wscmd', help="route to cmd websocket") (options, args) = parser.parse_args(args) if options.classpath is None: print "you must specify the module path to a class or factory function" parser.print_help() sys.exit(-1) if options.wspub or options.wscmd: ioloop.install() # must call this before importing any tornado stuff parts = options.classpath.split('.') modpath = '.'.join(parts[:-1]) __import__(modpath) try: mod = sys.modules[modpath] ctor = getattr(mod, parts[-1]) except KeyError, AttributeError: print "can't locate %s" % options.classpath sys.exit(-1)