def install_zmq_hooks():
global pubsock, repsock, reqsock
ioloop.install()
context = zmq.Context()
pubsock = context.socket(zmq.PUB)
try:
pubsock.bind(ADDR_PUB)
# we succeeded, so we are king of the disk log and
# the central queueing service for incoming points
print "We are king"
repsock = context.socket(zmq.REP)
repsock.bind(ADDR_REQ)
tstream = zmqstream.ZMQStream(repsock)
tstream.on_recv(pass_msg)
tornado.ioloop.PeriodicCallback(logger, TIMEOUT*1000).start()
except zmq.ZMQError as e:
print "Slave machine, spinning up"
reqsock = context.socket(zmq.REQ)
reqsock.connect(ADDR_REQ)
tstream = zmqstream.ZMQStream(reqsock)
tstream.on_recv(echo_msg)
ptsock = context.socket(zmq.SUB)
ptsock.setsockopt(zmq.SUBSCRIBE, "")
ptsock.connect(ADDR_PUB)
ptstream = zmqstream.ZMQStream(ptsock)
ptstream.on_recv(runcmd)
def main(): # pragma: no cover
parser = ArgumentParser('Pubsub listener pushing to websockets.')
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()
sub_socket = zmq.Context().socket(zmq.SUB)
sub_socket.connect(config.get('zeromq', 'sub'))
sub_socket.setsockopt(zmq.SUBSCRIBE, 'PUSH')
print 'SUB sub_socket on', config.get('zeromq', 'sub')
loop = ioloop.IOLoop.instance()
port = config.get('websockets', 'port')
Push(zmqstream.ZMQStream(sub_socket, loop))
application.listen(port)
print 'websockets on :%s' % port
# Send a status report every 10 seconds.
cfg = config.get_map('storage')
storage = DottedNameResolver(None).resolve(cfg.pop('backend'))(**cfg)
ip = '%s:%s' % (socket.gethostbyname(socket.getfqdn()), port)
callback = partial(report_status, storage, ip)
period = config.get('monitor', 'period')
ioloop.PeriodicCallback(callback, period * 1000).start()
# Get in the pool right away.
callback()
loop.start()
def websocket_server(webport, nbdir):
global nb_dir
nb_dir = nbdir
ioloop.install()
try:
application.listen(webport)
except:
# print('Port %d already in use!' % webport)
sys.exit(2)
main_loop = tornado.ioloop.IOLoop.instance()
main_loop.start()
def run_application(options, instance_name):
from zmq.eventloop import ioloop
ioloop.install()
application = WebSocketGatewayApplication(options, instance_name)
server = tornado.httpserver.HTTPServer(application)
server.listen(options.port)
try:
tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
application.clean_up()
def main(argv):
global webport, nb_dir
#try:
opts, args = getopt.getopt(argv,"hp:d:",["port=","directory="])
if opts == []:
print 'drag-and-drop.py -p <port> -d <directory>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'drag-and-drop.py -p <port> -d <directory>'
sys.exit()
elif opt in ("-p", "--port"):
webport = int(arg)
elif opt in ("-d", "--directory"):
nb_dir = arg
print 'webport is "', webport
print 'notebook directory is "', nb_dir
if webport < 1000 or webport > 65535:
print('Illegal webport adress %d' % webport)
sys.exit(2)
if not os.path.exists(nb_dir):
print('Directory %s does not exist' % nb_dir)
sys.exit(2)
ioloop.install()
try:
application.listen(webport)
except:
print('Port %d already in use!' % webport)
exit()
main_loop = tornado.ioloop.IOLoop.instance()
main_loop.start()
import os
import sys
import json
import tornado
import tornado.web
import tornado.ioloop
import tornado.options
import tornado.httpserver
from tornado.options import define, options
from zmq.eventloop import ioloop
# Install ZMQ ioloop instead of a tornado ioloop
# http://zeromq.github.com/pyzmq/eventloop.html
ioloop.install()
from centrifuge.core import Application
from centrifuge.log import logger
define(
"debug", default=False, help="tornado debug mode", type=bool
)
define(
"port", default=8000, help="app port", type=int
)
define(
"zmq_pub_listen", default="127.0.0.1", help="zmq pub listen", type=str
import sys
import argparse
import tornado.ioloop
import tornado.web
import tornado.ioloop
from zmq.eventloop import ioloop
ioloop.install()
from crypto2crypto import CryptoTransportLayer
from market import Market
from ws import WebSocketHandler
import logging
import signal
import threading
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.redirect("/html/index.html")
class MarketApplication(tornado.web.Application):
def __init__(self, my_market_ip, my_market_port, seed_uri, market_id,
seed_guid):
self.transport = CryptoTransportLayer(my_market_ip, my_market_port,
market_id)
self.transport.join_network(seed_uri, seed_guid)
self.market = Market(self.transport)
handlers = [(r"/", MainHandler), (r"/main", MainHandler),
(r"/html/(.*)", tornado.web.StaticFileHandler, {
