def get_sockets():
"""bind to available socket in this system
Returns:
sockets, port -- sockets and port bind to
"""
_sockets, _port = bind_sockets('0.0.0.0', 0)
set_bokeh_port(_port)
return _sockets, _port
def bokeh_worker(self):
asyncio.set_event_loop(asyncio.new_event_loop())
sockets, port = bind_sockets(self.hostname, self.port)
extra_websocket_origins = [
"{}:{}".format(self.hostname, self.port),
"{}:{}".format(self.hostname, self.agent.web.port)
]
bokeh_tornado = BokehTornado(
self.apps, extra_websocket_origins=extra_websocket_origins)
bokeh_http = HTTPServer(bokeh_tornado)
bokeh_http.add_sockets(sockets)
self.server = BaseServer(IOLoop.current(), bokeh_tornado, bokeh_http)
self.server.start()
self.server.io_loop.start()
def base(score_title):
LOGGER.info("you're on {}".format(score_title))
url = '/' + score_title
score = APPS[score_title](score_title)
LOGGER.info("starting score...")
score()
LOGGER.info("starting server...")
bokeh_tornado = BokehTornado({url: score.app},
extra_websocket_origins=["localhost:8000"])
# extra_websocket_origins=["52.53.126.244:8000"])
# A non-blocking, single-threaded HTTP server (from Tornado)
bokeh_http = HTTPServer(bokeh_tornado)
# If port is 0, the OS automatically chooses a free port
# sockets will listen to localhost
# Opens a new process (visible with netstat) on the port
sockets, port = bind_sockets('127.0.0.1', 0)
# sockets, port = bind_sockets('0.0.0.0', 0)
bokeh_http.add_sockets(sockets)
LOGGER.info("sockets, port: {}, {}".format(sockets, port))
def bk_worker():
# An Input/Output event loop for non-blocking sockets (from tornado)
io_loop = IOLoop.instance()
# Explicitly coordinate the level Tornado components
# required to run a Bokeh server:
# - IOLoop to run the Bokeh server machinery.
# - Tornado application that defines the Bokeh server machinery.
# - HTTPServer to direct HTTP requests
server = BaseServer(io_loop, bokeh_tornado, bokeh_http)
server.start()
server.io_loop.start()
LOGGER.info("starting thread...")
Thread(target=bk_worker).start()
script = server_document('http://localhost:{}{}'.format(port, url))
# script = server_document('http://52.53.126.244:{}{}'.format(port, url))
return render_template("base.html", script=script, title=score_title)
def test_bind_sockets_with_zero_port():
ss, port = util.bind_sockets("127.0.0.1", 0)
assert isinstance(ss, list)
assert len(ss) == 1
assert isinstance(ss[0], socket.socket)
assert isinstance(port, int)
legend_toggle, plot,
row(column(line_layout_L, sizing_mode='scale_width'),
column(line_layout_R, sizing_mode='scale_width'),
sizing_mode='scale_width')
],
sizing_mode='scale_width')
# show
doc.add_root(layout)
########################################
# Plot Page (2/5): Server Setting
########################################
bkapp = Application(FunctionHandler(modify_doc))
sockets, port = bind_sockets("localhost", 0)
########################################
# Plot Page (3/5): Flask call
########################################
@app.route('/dashboard/', methods=['GET'])
def show_dashboard():
# main
script = server_document('http://localhost:%d/bkapp' % port)
return render_template('embed.html', script=script, template='Flask')
########################################
# Plot Page (4/5): Start Server Workers (can run multiple servers)
########################################
slider = Slider(start=0,
end=30,
value=0,
step=1,
title="Smoothing by N Days")
slider.on_change('value', callback)
doc.add_root(column(slider, plot))
doc.theme = Theme(filename="theme.yaml")
bkapp = Application(FunctionHandler(modify_doc))
# This is so that if this app is run using something like "gunicorn -w 4" then
# each process will listen on its own port
sockets, port = bind_sockets("127.0.0.1", 0)
@app.route('/', methods=['GET'])
def bkapp_page():
dataset = request.args.get('dataset')
if request.args.get('unit_type') is None:
unit_type = "Celcius"
else:
unit_type = request.args.get('unit_type')
script = server_document('http://127.0.0.1:%d/bkapp' % port,
arguments=dict(unit_type=unit_type))
return render_template(
server.register_blueprint(apiOrderBlueprint)
server.register_blueprint(apiMetricBlueprint)
server.register_blueprint(apiPaletteBlueprint)
server.register_blueprint(apiDatashadingBlueprint)
server.register_blueprint(apiNodeColorBlueprint)
server.register_blueprint(apiNodeSizeBlueprint)
server.register_blueprint(apiWindowSpecsBlueprint)
# other stuff
if (not isdir(server.config['UPLOAD_FOLDER'])):
mkdir(server.config['UPLOAD_FOLDER'])
# start Bokeh server
if "gunicorn" in environ.get("SERVER_SOFTWARE", ""):
forcedPort = getpid()
sockets, port = bind_sockets("localhost", forcedPort)
server.config['PORT'] = port + 20
server.logger.info("STARTED LISTENING INTERNALLY ON %d AND EXTERNALLY ON %d" % (port, server.config['PORT']))
else:
sockets, port = bind_sockets("localhost", 0)
server.config['PORT'] = port
from graphion.visualise import modify_doc
bkapp = Application(FunctionHandler(modify_doc))
def bk_worker():
set_event_loop(new_event_loop())
bokeh_tornado = BokehTornado({'/bkapp': bkapp}, extra_websocket_origins=["localhost:5000", "graphion.uddi.ng:*"])
bokeh_http = HTTPServer(bokeh_tornado)
bokeh_http.add_sockets(sockets)
doc.add_root(column(r, l1))
else:
l = column(plot, row(splot, tplot), row(numco_plot, sales_plot))
doc.add_root(column(slider, l))
doc.theme = Theme(filename=f"theme-{theme}.yaml")
bkapp = Application(FunctionHandler(modify_doc))
# This is so that if this app is run using something like "gunicorn -w 4" then
# each process will listen on its own port
sockets, port = bind_sockets("157.245.12.139", 0)
@app.route('/', methods=['GET'])
def bkapp_page():
if request.args.get('title') is None:
plot_title = "Sea Surface Temperature at 43.18, -70.43"
else:
plot_title = request.args.get('title')
if plot_title == '1':
rightdiv = 'none'
center = 'calc(100% - 16px)'
else:
rightdiv = ''
center = ''
datasets = {
'set1': "Dataset One",
slider = Slider(start=0, end=30, value=0, step=1, title="Smoothing by N Days")
slider.on_change('value', callback)
doc.add_root(column(slider, plot))
doc.theme = Theme(filename="theme.yaml")
# can't use shortcuts here, since we are passing to low level BokehTornado
bkapp = Application(FunctionHandler(modify_doc))
bokeh_tornado = BokehTornado({'/bkapp': bkapp}, extra_websocket_origins=["localhost:8000"])
bokeh_http = HTTPServer(bokeh_tornado)
# This is so that if this app is run using something like "gunicorn -w 4" then
# each process will listen on its own port
sockets, port = bind_sockets("localhost", 0)
bokeh_http.add_sockets(sockets)
@app.route('/', methods=['GET'])
def bkapp_page():
script = server_document('http://localhost:%d/bkapp' % port)
return render_template("embed.html", script=script, template="Flask")
def bk_worker():
io_loop = IOLoop.current()
server = BaseServer(io_loop, bokeh_tornado, bokeh_http)
server.start()
server.io_loop.start()
from threading import Thread
Thread(target=bk_worker).start()
def test_bind_sockets_with_zero_port():
ss, port = util.bind_sockets("127.0.0.1", 0)
assert isinstance(ss, list)
assert len(ss) == 1
assert isinstance(ss[0], socket.socket)
assert isinstance(port, int)
from tornado.ioloop import IOLoop
from threading import Thread
from app import bokeh_TSNE as bk
import asyncio
from flask_migrate import Migrate
# from flask_login import LoginManager
app = Flask(__name__)
# Configure app based on supplied settings in Config.py
app.config.from_object(Config)
# Initialize database with app
with app.app_context():
db.init_app(app)
app.config['sockets'], app.config['port'] = bind_sockets("localhost", 0)
app.register_blueprint(apiBP, url_prefix='/api')
# Set up database migration to allow updating of database tables to match models.py
migrate = Migrate(app, db)
def bk_worker():
# Can't pass num_procs > 1 in this configuration. If you need to run multiple
# processes, see e.g. flask_gunicorn_embed.py
# server = Server({'/bkapp': bk.start_doc()}, io_loop=IOLoop(), allow_websocket_origin=['127.0.0.1:5000', '127.0.0.1:3000', '127.0.0.1:8000', 'localhost:3000', 'localhost:5000', 'localhost:8000'], relative_urls=True)
# server.start()
# server.io_loop.start()
print('Starting worker...')
print(app)
asyncio.set_event_loop(asyncio.new_event_loop())
def bk_worker(bokehsockets, flask_port):
bokeh_tornado = BokehTornado({'/bokeh': bkapp}, extra_websocket_origins=["localhost",
"127.0.0.1",
"0.0.0.0",
"*"
])
bokeh_http = HTTPServer(bokeh_tornado)
bokeh_http.add_sockets(bokehsockets)
io_loop = IOLoop.current()
server = BaseServer(io_loop, bokeh_tornado, bokeh_http)
server.start()
server.io_loop.start()
if __name__ == '__main__':
from threading import Thread
bokehsockets, bokehport = bind_sockets("0.0.0.0", 0)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('0.0.0.0', 0))
flaskport = sock.getsockname()[1]
sock.close()
Thread(target=bk_worker, args=([bokehsockets, flaskport])).start()
app.config["BASE_DIR"] = os.path.expanduser('~/REINVENT/')
app.config["BOKEH_PORT"] = bokehport
print("Running Vizor on http://localhost:{}/".format(flaskport))
app.run(port=flaskport, debug=False)
slider.on_change('value', callback)
doc.add_root(column(slider, plot))
doc.theme = Theme(filename="theme.yaml")
bkapp = Application(FunctionHandler(modify_doc))
bokeh_tornado = BokehTornado({'/bkapp': bkapp},
extra_websocket_origins=["127.0.0.1:8000"])
bokeh_http = HTTPServer(bokeh_tornado)
# This is so that if this app is run using something like "gunicorn -w 4" then
# each process will listen on its own port
sockets, port = bind_sockets("127.0.0.1", 46518)
bokeh_http.add_sockets(sockets)
@app.route('/', methods=['GET'])
def bkapp_page():
print('here')
script = server_document('http://127.0.0.1:%d/bkapp' % port)
print(str(script))
return render_template("embed.html", script=script, template="Flask")
def bk_worker():
io_loop = IOLoop.current()
server = BaseServer(io_loop, bokeh_tornado, bokeh_http)
server.start()
