本文整理汇总了Python中zmq.eventloop.ioloop.install函数的典型用法代码示例。如果您正苦于以下问题:Python install函数的具体用法?Python install怎么用?Python install使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了install函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: _init_context
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)
示例2: run
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()
示例3: initialize
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()
示例4: run
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()
示例5: run_hub
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.')
示例6: main
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()
示例7: setUp
def setUp(self):
ioloop.install()
super(TestCircus, self).setUp()
self.arbiters = []
self.files = []
self.dirs = []
self.tmpfiles = []
self.cli = AsyncCircusClient()
示例8: runFifoNetWorker
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()
示例9: runserver
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()
示例10: start_io_loop
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
示例11: run
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()
示例12: _setup_tornado
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
示例13: worker
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
示例14: start
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()
示例15: main
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()