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