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)
