def main():
# argparse setup
# noinspection PyTypeChecker
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description='datenight server')
# optional arguments
parser.add_argument('-v',
action='count',
default=0,
help="verbosity increases with each 'v' | "
"critical/error/warning/info/debug")
parser.add_argument('-a',
'--all-interfaces',
action="store_true",
help="Listen on 0.0.0.0? (otherwise 127.0.0.1)")
parser.add_argument('-p',
'--port',
default=5500,
type=int,
help="port to listen on")
parser.add_argument('-d',
'--debug',
action="store_true",
help="run in debug mode "
"(Warning: don't run this with -a)")
parser.add_argument('-V',
'--version',
action='version',
version="%(prog)s v{}".format('.'.join(
map(str, __version__))),
help="Show version and exit")
args = parser.parse_args()
# logger setup
level = max(10, 50 - (10 * args.v))
print(f'Logging level is: {logging.getLevelName(level)}')
logger = logging.getLogger(__name__)
logger.setLevel(level)
formatter = logging.Formatter('%(asctime)s: %(levelname)s:\t%(message)s')
sh = logging.StreamHandler()
sh.setFormatter(formatter)
logger.addHandler(sh)
logger = logging.getLogger('server')
logger.setLevel(level)
logger.addHandler(sh)
# run flask
host = "0.0.0.0" if args.all_interfaces else "127.0.0.1"
socketio.run(app, host=host, port=args.port, debug=args.debug)
def __call__(self, app, host, port, use_debugger, use_reloader):
# override the default runserver command to start a Socket.IO server
if use_debugger is None:
use_debugger = app.debug
if use_debugger is None:
use_debugger = True
if use_reloader is None:
use_reloader = app.debug
print("host:", host, "port:", port)
socketio.run(app,
host=host,
port=port,
debug=use_debugger,
use_reloader=use_reloader,
**self.server_options)
def server_main(parsed_args: Namespace) -> NoReturn:
logging = init_logging(parsed_args)
main_logger = logging.getLogger(ServerLoggerName.MAIN.value)
main_logger.info('Starting youSonos server ...')
import eventlet
eventlet.monkey_patch()
wait_for_redis(main_logger)
from server import create_app
from server import socketio
app = create_app(parsed_args)
socketio.run(app,
host=parsed_args.host,
port=parsed_args.port,
log_output=True,
log=logging.getLogger(ServerLoggerName.EVENTLET.value))
from server import app, socketio
from classes import *
if __name__ == "__main__":
app.debug = True
socketio.run(app, port=5000, debug=True, use_reloader=True)
from server import create_app, socketio
import os
app = create_app()
if __name__ == '__main__':
socketio.run(
app, port=os.getenv("PORT"), host='0.0.0.0',
use_reloader=False) # reloader may glitch out mqtt connections?
#!/usr/bin/env python
from server import app, socketio
import os
if __name__ == "__main__":
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
os.environ["FLASK_ENV"] = "development"
os.environ["LOCATION"] = "DEVEL"
# app.run(debug=True, threaded=True, host= '0.0.0.0', port=8000)
socketio.run(app, host='localhost', port=8000, debug=True)
from server import create_app, socketio
app = create_app()
if __name__ == '__main__':
socketio.run(app, threaded=True, port=8000, use_reloader=False, debug=True)
from server import server_app, socketio
app = server_app()
if __name__ == '__main__':
socketio.run(app, debug=True)
from server import app, socketio
if __name__ == "__main__":
socketio.run(app, "0.0.0.0", port=5001, debug=True)
from server import app as application
from server import socketio
if __name__ == "__main__":
socketio.run(application, port=3010, debug=True)
from server import socketio, app
import logging
import os
if __name__ == '__main__':
root = logging.getLogger()
root.setLevel(logging.DEBUG)
port = os.environ.get('PORT', 5000)
socketio.run(app, host='0.0.0.0', port=int(port))
from server import app, socketio
if __name__ == '__main__':
socketio.run(app, host="0.0.0.0")
from gevent import monkey monkey.patch_all() from server import create_app, socketio app = create_app(True) if __name__ == '__main__': socketio.run(app)
def run(host, port, debug):
print "Running on %s:%d" % (host, port)
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
socketio.run(app, host=host, port=port, debug=debug)
# telemetry processor
parser.add_argument('--process-can',
type=int,
default=1,
help='Disables the can logging')
# telemetry processor
parser.add_argument('--process-telemetry',
type=int,
default=1,
help='Disables the telemetry (psutil)')
args = parser.parse_args()
if args.debug:
logger.setLevel(logging.DEBUG)
if args.process_can:
print('Starting CAN logger')
socketio.start_background_task(target=can_processor.processor)
if args.process_telemetry:
print('Starting telemetry processor')
socketio.start_background_task(target=telemetry_processor.processor)
socketio.run(app,
host=args.host,
port=args.socket_port,
debug=args.debug,
use_reloader=True)
from server import app, socketio
if __name__ == '__main__':
socketio.run(app, host=app.config['HOST'], port=app.config['PORT'])
# import eventlet
# eventlet.monkey_patch()
# from eventlet import wsgi
from server import socketio, app
from livereload import Server
server = Server(app.wsgi_app)
server.watch('~/flask/dash_app/static/js/*')
if __name__ == '__main__':
# server.serve(port=80)
# wsgi.server(eventlet.listen(('', 80)), app)
socketio.run(app, host="0.0.0.0", port=80, use_reloader=True)
# app.run(host="0.0.0.0",port=80, use_reloader=False)
from os import environ
from server import socketio, app
if __name__ == '__main__':
socketio.run(app,
debug=True,
host='0.0.0.0',
port=environ.get('PORT', 5000))
from server import app, socketio socketio.run(app, port=12000)
from server import create_app
from server import socketio
from server.models.user import User
if __name__ == '__main__':
app=create_app()
socketio.run(app=app,host='0.0.0.0',threaded=True)
import sys
import eventlet
eventlet.monkey_patch()
from server import create_app, socketio
if __name__ == "__main__":
host = sys.argv[1]
port = sys.argv[2]
print("host: ", host)
print("port: ", port)
app = create_app()
socketio.run(app, host=host, port=port, debug=False, use_reloader=False)
from server import app, socketio
if __name__ == '__main__':
# SIGINT to stop (Ctrl + C)
# app.run(host='127.0.0.1',port=6969, debug=True, threaded=True)
socketio.run(app, host='127.0.0.1', port=6969, debug=True)
#!/bin/env python
from server import create_app, socketio
from server.model import Base, db_session, Games, engine
from server.config import Config
from server.tictactoegame import TicTacToe
import numpy as np
app = create_app()
if __name__ == '__main__':
with app.app_context():
server_restart = True
if server_restart:
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
for idx in range(Config.NUM_GAMES):
g = Games(game=TicTacToe())
db_session.add(g)
db_session.commit()
else:
Base.metadata.create_all(engine)
socketio.run(app, use_reloader=False)
""" Main entrypoint for the Starcorp server. """
from utils import LOGGER
import eventlet
from server import socketio, app, main_loop
if __name__ == "__main__":
LOGGER.info("Starting game loop")
eventlet.spawn(main_loop)
LOGGER.info("Starting server!")
socketio.run(app, host="192.168.1.16", port="1234")
elif pathname == '/katy/katy':
if current_user.is_authenticated:
return [sidebar, katy.layout]
else:
return login.layout
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
@app.callback([Output('user-name', 'children'),
Output('logout', 'children')],
[Input('page-content', 'children')])
def go_to_platform(input1):
if current_user.is_authenticated:
return html.Div('User: '******'Logout', href='/katy/logout')
else:
return '', ''
if __name__ == '__main__':
if ENV == "production":
socketio.run(server, host="147.135.137.147", port=5000)
#app.run_server(host="147.135.137.147", debug=True, port=5000)
else:
socketio.run(server)
#app.run_server(host="127.0.0.1", debug=True, port=5000)
from server import app,socketio socketio.run(app,host='0.0.0.0',port=8900,debug=True)
#!/usr/bin/env python3
"""
Script used to initiate the GUI server instance. The main documentation will be
given in the files of the server/ directory
"""
from server import create_server_flask, socketio
import logging
import sys
if __name__ == '__main__':
print('Created app')
app = create_server_flask()
print('socketio.run')
# Disabling all common network logging to declutter the terminal for
# debugging.
logging.getLogger('socketio').setLevel(logging.ERROR)
logging.getLogger('engineio').setLevel(logging.ERROR)
logging.getLogger('geventwebsocket.handler').setLevel(logging.ERROR)
logging.getLogger('werkzeug').setLevel(logging.ERROR)
socketio.run(app, host='0.0.0.0', port=9100)
print('stoping socketio')
sys.exit(0)
from server import app, socketio
if __name__ == '__main__':
socketio.run(app, log_output=True, host='0.0.0.0')
from logger_config import logger, pingLogger
from server import socketio, app
if __name__ == "__main__":
gunicorn_logger = logging.getLogger('gunicorn.error')
logger.handlers = gunicorn_logger.handlers
logger.info("recovery server active")
socketio.run(app)
from server import app
from server import socketio
import logging
if __name__ == '__main__':
log = logging.FileHandler('log')
log.setLevel(logging.INFO)
app.logger.addHandler(log)
log.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s'
'[%(filename)s(%(funcName)s:%(lineno)d)]'
': %(message)s'))
socketio.run(app, port=12138)
from server import socketio, app
application = app
if __name__ == "__main__":
socketio.run(application)
def runserver():
socketio.run(app, host='0.0.0.0')
