def run():
config = ConfigParser.ConfigParser()
config.read("config.ini")
ws_port = config.get('port_config', 'ws_port')
server = WSGIServer(("0.0.0.0", int(ws_port)), vity_ws, handler_class=WebSocketHandler,
keyfile=config.get('ssl', 'keyfile'), certfile=config.get('ssl', 'certfile'))
server.serve_forever()
def run_server(options):
api_listener = Api()
gevent.spawn(api_listener.run)
#
# Setup flask app
static_url_path = "/changed-so-it-doesnt-conflict-with-blueprint-static-path"
app = Flask(__name__, static_url_path=static_url_path)
app.config.from_pyfile(options["config"].name)
app.register_blueprint(FrontendBlueprint())
#
# JS/CSS & HTML minification in production
if not app.config.get('DEBUG'):
from .misc.jinja2htmlcompress import HTMLCompress
app.jinja_env.add_extension(HTMLCompress)
assets = Environment()
assets.init_app(app)
#
# Run server
http = WSGIServer((options['http_host'], options['http_port']), app)
LOGGER.info('Listening on %s:%s', options['http_host'], options['http_port'])
try:
http.serve_forever()
return 0
except KeyboardInterrupt:
http.stop()
api_listener.stop()
LOGGER.info('Application Terminated')
return 0
def main():
status = 0
parser = argparse.ArgumentParser()
parser.add_argument('port', nargs='?', type=int, help='HTTP port', default=80)
args = parser.parse_args()
# start the dropbox service for handling file uploads
dropbox.start()
print 'starting web server on port %s' % args.port
print 'press control-c to quit'
try:
server = WSGIServer(('0.0.0.0', args.port), api, handler_class=WebSocketHandler)
log.info('entering main loop')
server.serve_forever()
except KeyboardInterrupt:
dropbox.stop()
log.info('exiting main loop')
except Exception as e:
str = 'could not start web server: %s' % e
log.error(str)
print str
status = 1
dropbox.stop()
dropbox.join(60)
log.info('exiting with status %d', status)
return status
def greenlet_admin(self):
""" This greenlet is used to get status information about the worker when --admin_port was given
"""
if self.config["processes"] > 1:
self.log.debug("Admin server disabled because of multiple processes.")
return
from flask import Flask
from mrq.dashboard.utils import jsonify
app = Flask("admin")
@app.route("/")
def route_index():
report = self.get_worker_report()
report.update({"_id": self.id})
return jsonify(report)
self.log.debug("Starting admin server on port %s" % self.config["admin_port"])
try:
server = WSGIServer(("0.0.0.0", self.config["admin_port"]), app, log=open(os.devnull, "w"))
server.serve_forever()
except Exception, e:
self.log.debug("Error in admin server : %s" % e)
def main(port):
ini_path = './production.ini'
setup_logging(ini_path)
app = get_app(ini_path, 'main')
server = WSGIServer(('', port), app)
server.backlog = 256
server.serve_forever()
def run(self, host, port, *args, **kw):
from gevent.pywsgi import WSGIServer
from gevent.monkey import patch_all; patch_all()
logger = logging.getLogger('gevent')
logger.info('Starting gevent on port: {}'.format(port))
http_server = WSGIServer(('', port), self.manager.app)
http_server.serve_forever()
def mmain():
manager = multiprocessing.Manager()
global PROCESSES
PROCESSES = {}
global PLUGINS
PLUGINS = manager.list()
global CONTEXT
CONTEXT = manager.dict()
for plugin in os.listdir('plugins'):
try:
dir = os.path.join('plugins', plugin)
if not os.path.isdir(dir):
continue
print 'Loading plugin {}'.format(plugin)
p = Plugin(dir)
PLUGINS.append(p)
print 'Successfully loaded plugin: {}'.format(p)
except Exception:
traceback.print_exc(file=sys.stdout)
print 'Failed to load plugin {}'.format(plugin)
global http_server
http_server = WSGIServer(('',5000), app)
#http_server.log = open('http.log', 'w')
http_server.serve_forever()
class Server(Greenlet):
def __init__(self, name, addr, *args, **kwargs):
Greenlet.__init__(self)
self._application = Flask(name)
self._server = WSGIServer(addr, self._application, *args, **kwargs)
@self._application.errorhandler(404)
def error_404(error):
log.warning('web handler(%s) not found', request.path)
return str(error), 404
@self._application.errorhandler(Exception)
def error_500(error):
log.exception('web handler(%s) is error(%s)', request.path, error)
return str(error), 500
def _run(self):
self._server.serve_forever()
def close(self):
self._server.stop()
def getServer(self):
return self._server
def getApplication(self):
return self._application
def setHandler(self, handler, url=None, **kwargs):
if not url:
url = '/' + handler.__name__
self._application.route(url, **kwargs)(handler)
def run(self, host='localhost', port=80):
"""Run the moulinette
Start a server instance on the given port to serve moulinette
actions.
Keyword arguments:
- host -- Server address to bind to
- port -- Server port to bind to
"""
try:
if self.use_websocket:
from gevent.pywsgi import WSGIServer
from geventwebsocket.handler import WebSocketHandler
server = WSGIServer((host, port), self._app,
handler_class=WebSocketHandler)
server.serve_forever()
else:
run(self._app, host=host, port=port)
except IOError as e:
if e.args[0] == errno.EADDRINUSE:
raise MoulinetteError(errno.EADDRINUSE,
m18n.g('server_already_running'))
raise
def _run():
from gevent.pywsgi import WSGIServer
server = WSGIServer(('127.0.0.1', 8999), app)
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
def run_server(instance_dir, address, port, access_log=False):
# workaround on osx, disable kqueue
if sys.platform == "darwin":
os.environ['EVENT_NOKQUEUE'] = "1"
sys.path.insert(0, instance_dir)
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
# This application object is used by any WSGI server configured to use this
# file. This includes Django's development server, if the WSGI_APPLICATION
# setting points here.
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
from gevent import monkey
monkey.patch_all(dns=False)
from gevent.pywsgi import WSGIServer
if access_log:
logfile = 'default'
else:
logfile = file(os.devnull, 'a+')
server = WSGIServer((address, port), application, log=logfile)
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
def go():
app = get_app()
app.debug = debug
if app.debug:
app.config.update(SEND_FILE_MAX_AGE_DEFAULT=0)
# TODO: asset debug settings will cause bad YSLOW rating
app.config['COMPRESS_DEBUG'] = False
app.config['ASSETS_DEBUG'] = debug
# Breaks web socket communication
# (WebSocketConnectionClosedException in client)
# app = DebuggedApplication(app, evalex=True)
host = conf_global['serverHost']
port = conf_global['serverPort']
print('Server: {0}:{1}'.format(host, port))
http_server = WSGIServer((host, port),
app,
handler_class=WebSocketHandler)
# gevent.spawn(send_dummy_notifications)
gevent.spawn(send_bulk)
http_server.serve_forever()
def start(host,port,allow_agent=False):
import argparse
from gevent.pywsgi import WSGIServer
from geventwebsocket.handler import WebSocketHandler
from jinja2 import FileSystemLoader
import os
root_path = os.path.dirname(wssh.__file__)
# root_path = '/home/bob/test/wssh/wssh'#os.path.dirname(wssh.__file__)
# print "RootPath===>",root_path
app.jinja_loader = FileSystemLoader(os.path.join(root_path, 'templates'))
app.static_folder = os.path.join(root_path, 'static')
# global wssh_server_log_file
handler = RotatingFileHandler(wssh_server_log_file, maxBytes=10000000, backupCount=5)
handler.setLevel(logging.DEBUG)
app.logger.addHandler(handler)
app.config['WSSH_ALLOW_SSH_AGENT'] = allow_agent
agent = 'wsshd/{0}'.format(wssh.__version__)
print '{0} running on {1}:{2}'.format(agent, host, port)
app.debug = True
http_server = WSGIServer((host, port), app,
log=None,
handler_class=WebSocketHandler)
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
def main():
options = parser.parse_args()
logging.basicConfig(
level=getattr(logging, options.log_level.upper(), logging.INFO),
format="[%(asctime)s] %(filename)s:%(lineno)d %(levelname)s %(message)s"
)
app.config['DATABASE'] = options.db
init_db()
app.template_folder = TEMPLATES_PATH
app.static_folder = STATIC_PATH
log.info("Starting service on http://%s:%d/", options.listen, options.port)
if options.debug:
log.warning("Running on debug mode not for production.")
app.run(host=options.listen, port=options.port, debug=True)
else:
http_server = WSGIServer((options.listen, options.port), app)
with suppress(KeyboardInterrupt):
http_server.serve_forever()
def start(self):
'''Kickoff the TCP Server
'''
try:
address = self.config.get('listener', 'ip')
port = self.config.getint('listener', 'port')
listener.server.listener.config_file = self.config_filename
listener.server.listener.tail_method = listener.windowslogs.tail_method
listener.server.listener.config['iconfig'] = self.config
user_cert = self.config.get('listener', 'certificate')
if user_cert == 'adhoc':
basepath = self.determine_relative_filename('')
cert, key = listener.certificate.create_self_signed_cert(basepath, 'ncpa.crt', 'ncpa.key')
else:
cert, key = user_cert.split(',')
ssl_context = {'certfile': cert, 'keyfile': key}
listener.server.listener.secret_key = os.urandom(24)
http_server = WSGIServer(listener=(address, port),
application=listener.server.listener,
handler_class=webhandler.PatchedWSGIHandler,
spawn=Pool(100),
**ssl_context)
http_server.serve_forever()
except Exception, e:
logging.exception(e)
def run():
from gevent.pywsgi import WSGIServer
http_server = WSGIServer(('', app.config['HTTP_PORT']), app)
if app.config['DEBUG']:
debugModeStr = '''Debug mode enabled!'''
else:
debugModeStr = ''
try:
print '''===========================================================================
__...____________________ ,
`(\ [ ===SPACEGDN===--|__|) ___..--"_`--.._____
`"""""""""""""""""| |""` [_""_-___________"_/
| | /..../`'-._.-'`
____| |__/::..'_
|\ ".`"` '_____//\\
`"'-. """"" \\\\/
`""""""""""`
===========================================================================
SpaceGDN developed by pyxld.com and is OSS under the MPL-2.0 at
https://github.com/connor4312/SpaceGDN. We're lifting off...
===========================================================================
Running on '''+app.config['HTTP_HOST']+''':'''+str(app.config['HTTP_PORT'])+'''
'''+debugModeStr+'''
==========================================================================='''
http_server.serve_forever()
except KeyboardInterrupt:
http_server.stop()
print '''
def main():
handler = logging.FileHandler('server.log')
handler.setLevel(logging.DEBUG)
app.logger.setLevel(logging.DEBUG)
app.logger.addHandler(handler)
http_server = WSGIServer(('127.0.0.1', 8001), app)
http_server.serve_forever()
def main():
parser, options, arguments = parse_options()
if not arguments:
parser.print_help()
return
# configure logging
setup_logging(options.loglevel, options.logfile)
proxy = TransparentProxy(arguments[0])
throttler = WsgiThrottler(proxy, options.pool_size)
# SSL settings
if options.certfile and options.keyfile:
ssl_settings = {"certfile": options.certfile, "keyfile": options.keyfile}
else:
ssl_settings = {}
main_logger = getLogger(__name__)
main_logger.info("Proxying %s on %s:%i with a maximum of %i concurrent requests" %(
arguments[0],
options.interface,
options.port,
options.pool_size,
))
server = WSGIServer((options.interface, options.port), throttler, log=sys.stdout, **ssl_settings)
server.serve_forever()
def main():
global ENVISALINKCLIENT
parser = argparse.ArgumentParser('Flask powered Alarm Server')
parser.add_argument('config', help='Configurationf file', default='')
args = parser.parse_args()
logger.info('Using configuration file %s' % args.config)
config = AlarmServerConfig(args.config)
# Create Envisalink client object
ENVISALINKCLIENT = Envisalink.Client(config, CONNECTEDCLIENTS)
gevent.spawn(ENVISALINKCLIENT.connect)
app.debug = True
server = WSGIServer(("", 5000), app, keyfile=config.KEYFILE, certfile=config.CERTFILE)
gevent.spawn(publish)
try:
server.serve_forever()
except KeyboardInterrupt:
print "Crtl+C pressed. Shutting down."
logger.info('Shutting down from Ctrl+C')
server.stop()
raise SystemExit
def django_worker_function(options, args):
from django.core.handlers.wsgi import WSGIHandler
from django.conf import settings
from django.utils import translation
translation.activate(settings.LANGUAGE_CODE)
if options.logfile != 'error':
sys.stderr = open(os.path.join(current_path, options.logfile), "ab", 1)
if len(args) > 0:
appfile = args[0]
try:
application = extract_application(appfile)
except AttributeError:
sys.exit("Could not find application in %s" % filename)
if options.disable_logging:
server = WSGIServer((options.host, int(options.port)), application, log=None)
else:
server = WSGIServer((options.host, int(options.port)), application)
print >>sys.stderr, "Serving %s on %s:%s" % (appfile, options.host, options.port)
server.serve_forever()
else:
server = WSGIServer((options.host, int(options.port)), WSGIHandler(), log=None)
print >>sys.stderr, "Serving on %s:%s\n" % (options.host, options.port)
server.serve_forever()
def web_main():
log = logging.getLogger('web')
def server_factory(global_conf, host, port):
port = int(port)
def serve(app):
server = WSGIServer(('', port), app, )
log.info('serving on port %s...', port)
server.serve_forever()
return serve
port = 8000
log.info('starting web server on port %s', port)
config = Configurator(
settings={
'mako.directories': 'templates',
'reload_templates': True
})
config.add_static_view('static', path='static')
config.add_route('root', '/')
config.add_route('logcat', '/logcat')
config.scan()
app = config.make_wsgi_app()
http_server = WSGIServer(('', 8000), app, handler_class=WebSocketHandler)
http_server.serve_forever()
def main():
ip = config.listening_ip
port = config.listening_port
log.info("listening on %s:%d" % (ip, port))
server = WSGIServer((ip, port), app,
handler_class=WebSocketHandler)
server.serve_forever()
def run(self, host="0.0.0.0", port=5000, **kwargs):
"""Run a testing server in debug mode using gevent's wsgi server.
"""
# overwrite debug to True when running the app this way
self.app.debug = True
httpserver = WSGIServer((host, port), self.app)
print "starting gevent.WSGIServer server on http://%s:%d" % (host, port)
httpserver.serve_forever()
def start_app(verbose=False):
global http_server
if verbose:
print "Starting server on port 5006..."
http_server = WSGIServer(('', 5006), app,
handler_class=WebSocketHandler,
)
http_server.serve_forever()
def start_vaurien_httpserver(port):
"""Start a vaurien httpserver, controlling a fake proxy"""
config = get_config()
config.registry['proxy'] = FakeProxy()
server = WSGIServer(('localhost', int(port)), config.make_wsgi_app(),
log=None)
server.serve_forever()
def main():
print u"OpenMining start server at: {}:{}".format(args.ip, args.port)
if args.debug is None:
server = WSGIServer((args.ip, args.port), app, handler_class=WebSocketHandler)
server.serve_forever()
run(app=app, host=args.ip, port=args.port, debug=args.debug, reloader=True, server=GeventWebSocketServer)
def start_app(app, verbose=False):
global http_server
if verbose:
print "Starting server on port %d..." % cdx_app.port
http_server = WSGIServer(('', cdx_app.port), app,
handler_class=WebSocketHandler,
)
http_server.serve_forever()
def runserver(port, ip, debug):
if debug is None:
server = WSGIServer((ip, port), app, handler_class=WebSocketHandler)
server.serve_forever()
click.echo(u"OpenMining start server at: {}:{}".format(ip, port))
run(app=app, host=ip, port=port, debug=debug, reloader=True, server=GeventWebSocketServer)
def main():
server = WSGIServer(('', port), application)
try:
print("Fishes on %s" % port)
server.serve_forever()
except KeyboardInterrupt:
print(' now sleeping with the fishes')
server.stop()
class Engine(BaseEngine, Signaler):
#
# 引擎本身只需实现 BaseEngine 接口，信号处理属于额外增强功能。
# 子进程创建、退出都属于系统信号范畴，统一由 Singaler 处理。
#
def __init__(self, server):
self._server = server
self._pool = ThreadPool(CPUS * 4)
self._listen_sock = None
self._wsgi_server = None
BaseEngine.__init__(self, server)
Signaler.__init__(self)
def run(self):
from engine.config import HOST, PORT
self._listen_sock = socket(family=AF_INET)
self._listen_sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self._listen_sock.bind((HOST, PORT))
self._listen_sock.listen(2048)
self._listen_sock.setblocking(0)
self.fork_workers(WORKERS or CPUS + 1)
self.parent_execute()
def fork_workers(self, num):
for i in range(num):
if fork() == 0:
self.worker_execute()
exit(0)
def worker_execute(self):
Signaler.worker_execute(self)
# 启动服务器。
kwargs = HTTPS and \
{k: app_path("ssl/" + v) for k, v in (("keyfile", HTTPS_KEY), ("certfile", HTTPS_CERT))} or \
{}
self._wsgi_server = WSGIServer(self._listen_sock, self._server.execute, log=None, **kwargs)
self._wsgi_server.serve_forever()
# 等待所有处理结束，超时 10 秒。
hasattr(self._wsgi_server, "__graceful__") and gwait(timeout=10)
def worker_stop(self, graceful):
stop = lambda *args: self._wsgi_server and self._wsgi_server.stop()
graceful and (setattr(self._wsgi_server, "__graceful__", True), stop()) or stop()
def async_execute(self, func, *args, **kwargs):
e = Event()
g = self._pool.apply_async(func, args, kwargs, callback=lambda ret: e.set())
e.wait()
return g.get()
def main():
server = WSGIServer(('0.0.0.0', 5000), app)
try:
server.serve_forever()
except KeyboardInterrupt:
gevent.shutdown()
def main(args):
global name
name = args.get('name', 'stranger')
port = int('5000')
server = WSGIServer(('', port), proxy, log=None)
server.serve_forever()
@app.route('/')
def upload_form():
return render_template('upload.html')
@app.route('/', methods=['POST', 'GET'])
def upload_file():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
if file.filename == '':
flash('No file selected for uploading')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
flash('File successfully uploaded')
return redirect('/')
else:
flash('Allowed file types are txt, pdf, png, jpg, jpeg, gif')
return redirect(request.url)
if __name__ == "__main__":
app_server = WSGIServer(('192.168.1.109', 9999), app)
app_server.serve_forever()
def run(host, port, wsgi=False, https_mode=False):
''' Автовыбор доступного порта (если указан порт 0), загрузка языковой модели и нейронной сети и запуск сервера.
1. wsgi - True: запуск WSGI сервера, False: запуск тестового Flask сервера
2. https - True: запуск в режиме https (сертификат и ключ должны быть в cert.pem и key.pem), False: запуск в режиме http
Самоподписанный сертификат можно получить, выполнив: openssl req -x509 -newkey rsa:4096 -nodes -out temp/cert.pem -keyout temp/key.pem -days 365 '''
if port == 0: # Если был введён порт 0, то автовыбор любого доступного порта
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind((host, 0))
port = sock.getsockname()[1]
log('выбран порт ' + str(port))
sock.close()
except socket.gaierror:
log('адрес ' + host + ':' + str(port) + ' некорректен',
level='error')
sock.close()
return
except OSError:
log('адрес ' + host + ':' + str(port) + ' недоступен',
level='error')
sock.close()
return
log('Flask v.' + flask_version + ', WSGIServer v.' + wsgi_version)
log('установлен максимальный размер принимаемых данных: {:.2f} Кб'.format(
max_content_length / 1024))
name_dataset = f_name_w2v_model_plays[
f_name_w2v_model_plays.rfind('w2v_model_') +
len('w2v_model_'):f_name_w2v_model_plays.rfind('.bin')]
log('загрузка обученной на наборе данных ' + name_dataset +
' модели seq2seq...')
global ttt
print()
ttt = TextToText(f_name_w2v_model=f_name_w2v_model_plays,
f_name_model=f_name_model_plays,
f_name_model_weights=f_name_model_weights_plays)
print()
log('загрузка языковой модели для распознавания речи...')
global stt
stt = SpeechToText('from_file', name_dataset)
log('загрузка синтезатора речи...')
global tts
tts = TextToSpeech('anna')
if wsgi:
global http_server
if https_mode:
log('WSGI сервер запущен на https://' + host + ':' + str(port) +
' (нажмите Ctrl+C или Ctrl+Z для выхода)')
else:
log('WSGI сервер запущен на http://' + host + ':' + str(port) +
' (нажмите Ctrl+C или Ctrl+Z для выхода)')
try:
if https_mode:
http_server = WSGIServer((host, port),
app,
log=app.logger,
error_log=app.logger,
keyfile='temp/key.pem',
certfile='temp/cert.pem')
else:
http_server = WSGIServer((host, port),
app,
log=app.logger,
error_log=app.logger)
http_server.serve_forever()
except OSError:
print()
log('адрес ' + host + ':' + str(port) + ' недоступен',
level='error')
else:
log('запуск тестового Flask сервера...')
try:
if https_mode:
app.run(host=host,
port=port,
ssl_context=('temp/cert.pem', 'temp/key.pem'),
threaded=True,
debug=False)
else:
app.run(host=host, port=port, threaded=True, debug=False)
except OSError:
print()
log('адрес ' + host + ':' + str(port) + ' недоступен',
level='error')
def runServer():
server = WSGIServer(("127.0.0.1", 5000), create_app())
server.serve_forever()
def run(debug, no_browser, m, mu, mc, f):
"""
Sacredboard.
\b
Sacredboard is a monitoring dashboard for Sacred.
Homepage: http://github.com/chovanecm/sacredboard
Example usage:
\b
sacredboard -m sacred
Starts Sacredboard on default port (5000) and connects to
a local MongoDB database called 'sacred'. Opens web browser.
Note: MongoDB must be listening on localhost.
\b
sacredboard -m 192.168.1.1:27017:sacred
Starts Sacredboard on default port (5000) and connects to
a MongoDB database running on 192.168.1.1 on port 27017
to a database called 'sacred'. Opens web browser.
\b
sacredboard -mu mongodb://user:pwd@host/admin?authMechanism=SCRAM-SHA-1 sacred
Starts Sacredboard on default port (5000) and connects to
a MongoDB database running on localhost on port 27017
to a database called 'sacred'. Opens web browser.
\b
sacredboard -m sacred -mc default.runs
Starts Sacredboard on default port (5000) and connects to
a local MongoDB database called 'sacred' and uses the Sacred's 0.6
default collection 'default.runs' to search the runs in.
Opens web browser.
Note: MongoDB must be listening on localhost.
"""
if m or mu != (None, None):
add_mongo_config(app, m, mu, mc)
app.config["data"].connect()
elif f:
app.config["data"] = FileStorage(f)
else:
print("Must specify either a mongodb instance or " +
"a path to a file storage.\nRun sacredboard --help "
"for more information.",
file=sys.stderr)
sys.exit(1)
app.config['DEBUG'] = debug
app.debug = debug
jinja_filters.setup_filters(app)
routes.setup_routes(app)
metrics.initialize(app)
if debug:
app.run(host="0.0.0.0", debug=True)
else:
for port in range(5000, 5050):
http_server = WSGIServer(('0.0.0.0', port), app)
try:
http_server.start()
except OSError as e:
# try next port
continue
print("Starting sacredboard on port %d" % port)
if not no_browser:
click.launch("http://127.0.0.1:%d" % port)
http_server.serve_forever()
break
class GeventServer(CommonServer):
def __init__(self, app):
super(GeventServer, self).__init__(app)
self.port = config['longpolling_port']
self.httpd = None
def process_limits(self):
restart = False
if self.ppid != os.getppid():
_logger.warning("LongPolling Parent changed", self.pid)
restart = True
memory = memory_info(psutil.Process(self.pid))
if config['limit_memory_soft'] and memory > config['limit_memory_soft']:
_logger.warning('LongPolling virtual memory limit reached: %s', memory)
restart = True
if restart:
# suicide !!
os.kill(self.pid, signal.SIGTERM)
def watchdog(self, beat=4):
import gevent
self.ppid = os.getppid()
while True:
self.process_limits()
gevent.sleep(beat)
def start(self):
import gevent
try:
from gevent.pywsgi import WSGIServer, WSGIHandler
except ImportError:
from gevent.wsgi import WSGIServer, WSGIHandler
class ProxyHandler(WSGIHandler):
""" When logging requests, try to get the client address from
the environment so we get proxyfix's modifications (if any).
Derived from werzeug.serving.WSGIRequestHandler.log
/ werzeug.serving.WSGIRequestHandler.address_string
"""
def format_request(self):
old_address = self.client_address
if getattr(self, 'environ', None):
self.client_address = self.environ['REMOTE_ADDR']
elif not self.client_address:
self.client_address = '<local>'
# other cases are handled inside WSGIHandler
try:
return super().format_request()
finally:
self.client_address = old_address
set_limit_memory_hard()
if os.name == 'posix':
# Set process memory limit as an extra safeguard
signal.signal(signal.SIGQUIT, dumpstacks)
signal.signal(signal.SIGUSR1, log_ormcache_stats)
gevent.spawn(self.watchdog)
self.httpd = WSGIServer(
(self.interface, self.port), self.app,
log=logging.getLogger('longpolling'),
error_log=logging.getLogger('longpolling'),
handler_class=ProxyHandler,
)
_logger.info('Evented Service (longpolling) running on %s:%s', self.interface, self.port)
try:
self.httpd.serve_forever()
except:
_logger.exception("Evented Service (longpolling): uncaught error during main loop")
raise
def stop(self):
import gevent
self.httpd.stop()
gevent.shutdown()
def run(self, preload, stop):
self.start()
self.stop()
def run(self):
logging.info(f'ixu server listening to {self.host}:{self.port}')
http_server = WSGIServer((self.host, self.port), self)
http_server.serve_forever()
def start(self):
# Check if there is a start delay
try:
delay_start = self.config.get('listener', 'delay_start')
if delay_start:
logging.info(
'Delayed start in configuration. Waiting %s seconds to start.',
delay_start)
time.sleep(int(delay_start))
except Exception:
pass
# Run DB maintenance on start
self.db.run_db_maintenance(self.config)
try:
try:
address = self.config.get('listener', 'ip')
except Exception:
self.config.set('listener', 'ip', '0.0.0.0')
address = '0.0.0.0'
try:
port = self.config.getint('listener', 'port')
except Exception:
self.config.set('listener', 'port', 5693)
port = 5693
listener.server.listener.config_files = self.config_filenames
listener.server.listener.tail_method = listener.windowslogs.tail_method
listener.server.listener.config['iconfig'] = self.config
try:
ssl_str_version = self.config.get('listener', 'ssl_version')
ssl_version = getattr(ssl, 'PROTOCOL_' + ssl_str_version)
except:
ssl_version = getattr(ssl, 'PROTOCOL_TLSv1')
ssl_str_version = 'TLSv1'
try:
ssl_str_ciphers = self.config.get('listener', 'ssl_ciphers')
except Exception:
ssl_str_ciphers = None
logging.info('Using SSL version %s', ssl_str_version)
user_cert = self.config.get('listener', 'certificate')
if user_cert == 'adhoc':
basepath = self.determine_relative_filename('')
certpath = os.path.abspath(os.path.join(basepath, 'var'))
cert, key = listener.certificate.create_self_signed_cert(
certpath, 'ncpa.crt', 'ncpa.key')
else:
cert, key = user_cert.split(',')
# Create SSL context that will be passed to the server
ssl_context = {
'certfile': cert,
'keyfile': key,
'ssl_version': ssl_version
}
# Add SSL cipher list if one is given
if ssl_str_ciphers:
ssl_context['ciphers'] = ssl_str_ciphers
listener.server.listener.secret_key = os.urandom(24)
http_server = WSGIServer(listener=(address, port),
application=listener.server.listener,
handler_class=WebSocketHandler,
spawn=Pool(200),
**ssl_context)
http_server.serve_forever()
except Exception as e:
logging.exception(e)
from gevent.pywsgi import WSGIServer
from app import app
http_server = WSGIServer(('', 5000), app)
http_server.serve_forever()
@login_required
def test():
global pred_class_name
dic = {"pred_class_name": pred_class_name}
return render_template('display.html', dic=dic)
@app.route('/login')
def login():
return 'Login'
def get_pred_class_name(pred_class_number):
global mapper
return mapper[pred_class_number]
def preprocess_single_image(filepath):
pic = cv2.imread(filepath)
pic = cv2.resize(pic, (120, 120))
pic = pic.astype('float32')
pic /= 255
pic = pic.reshape(-1, 120, 120, 3)
return pic
if __name__ == "__main__":
server = WSGIServer(("", 5000), app)
print('Server is up and running on port 5000......')
print('Go to http://localhost:5000')
server.serve_forever()
def stop_replicant():
# TODO: Unused at this moment
replicant_id = json.loads(
request.form.get("replicant_id", json.dumps(None)))
replicant.terminate(False)
#TODO: Maybe json.dumps({})
return json.dumps("Replicant stopped")
@app.route('/', defaults={"path": ''})
@app.route("/<path:path>/")
def index(path):
return render_template("index.html")
if __name__ == "__main__":
try:
os.mkdir(USERS_DIRECTORY)
except:
pass
# app.run(debug = True, threaded = True)
# Use this in production code
HTTPServer = WSGIServer(
(IP_ADDRESS, PORT),
app) #, keyfile="server.key", certfile="server.crt")
HTTPServer.serve_forever()
from gevent.pywsgi import WSGIServer
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
ws = WSGIServer(('0.0.0.0', 5001), app)
ws.serve_forever()
class fHDHR_HTTP_Server():
app = None
def __init__(self, fhdhr):
self.fhdhr = fhdhr
self.template_folder = fhdhr.config.internal["paths"]["www_templates_dir"]
self.fhdhr.logger.info("Loading Flask.")
self.fhdhr.app = Flask("fHDHR", template_folder=self.template_folder)
self.instance_id = str(uuid.uuid4())
# Allow Internal API Usage
self.fhdhr.app.testing = True
self.fhdhr.api.client = self.fhdhr.app.test_client()
# Set Secret Key For Sessions
self.fhdhr.app.secret_key = self.fhdhr.config.dict["fhdhr"]["friendlyname"]
self.route_list = {}
self.endpoints_obj = {}
self.endpoints_obj["brython"] = fHDHR_Brython(fhdhr)
self.endpoints_obj["api"] = fHDHR_API(fhdhr)
# Load Plugins before pages so they can override core web pages
self.selfadd_web_plugins()
self.endpoints_obj["pages"] = fHDHR_Pages(fhdhr)
self.endpoints_obj["files"] = fHDHR_Files(fhdhr)
for endpoint_type in list(self.endpoints_obj.keys()):
self.fhdhr.logger.info("Loading HTTP %s Endpoints." % endpoint_type)
self.add_endpoints(endpoint_type)
self.fhdhr.app.before_request(self.before_request)
self.fhdhr.app.after_request(self.after_request)
self.fhdhr.app.before_first_request(self.before_first_request)
self.fhdhr.threads["flask"] = threading.Thread(target=self.run)
def selfadd_web_plugins(self):
for plugin_name in list(self.fhdhr.plugins.plugins.keys()):
if self.fhdhr.plugins.plugins[plugin_name].type == "web":
method = self.fhdhr.plugins.plugins[plugin_name].name.lower()
plugin_utils = self.fhdhr.plugins.plugins[plugin_name].plugin_utils
try:
self.endpoints_obj[method] = self.fhdhr.plugins.plugins[plugin_name].Plugin_OBJ(self.fhdhr, plugin_utils)
except Exception as e:
print(e)
def start(self):
self.fhdhr.logger.info("Flask HTTP Thread Starting")
self.fhdhr.threads["flask"].start()
def stop(self):
self.fhdhr.logger.info("Flask HTTP Thread Stopping")
self.http.stop()
def before_first_request(self):
self.fhdhr.logger.info("HTTP Server Online.")
def before_request(self):
session["session_id"] = str(uuid.uuid4())
session["instance_id"] = self.instance_id
session["route_list"] = self.route_list
session["user_agent"] = request.headers.get('User-Agent')
session["is_internal_api"] = self.detect_internal_api(request)
if session["is_internal_api"]:
self.fhdhr.logger.debug("Client is using internal API call.")
session["is_mobile"] = self.detect_mobile(request)
if session["is_mobile"]:
self.fhdhr.logger.debug("Client is a mobile device.")
session["is_plexmediaserver"] = self.detect_plexmediaserver(request)
if session["is_plexmediaserver"]:
self.fhdhr.logger.debug("Client is a Plex Media Server.")
session["deviceauth"] = self.detect_plexmediaserver(request)
session["tuner_used"] = None
session["restart"] = False
self.fhdhr.logger.debug("Client %s requested %s Opening" % (request.method, request.path))
def after_request(self, response):
# Close Tuner if it was in use, and did not close already
# if session["tuner_used"] is not None:
# tuner = self.fhdhr.device.tuners.tuners[str(session["tuner_used"])]
# if tuner.tuner_lock.locked():
# self.fhdhr.logger.info("Shutting down Tuner #%s after Request." % session["tuner_used"])
# tuner.close()
self.fhdhr.logger.debug("Client %s requested %s Closing" % (request.method, request.path))
if not session["restart"]:
return response
else:
return self.stop()
def detect_internal_api(self, request):
user_agent = request.headers.get('User-Agent')
if not user_agent:
return False
elif str(user_agent).lower().startswith("fhdhr"):
return True
else:
return False
def detect_deviceauth(self, request):
return request.args.get('DeviceAuth', default=None, type=str)
def detect_mobile(self, request):
user_agent = request.headers.get('User-Agent')
phones = ["iphone", "android", "blackberry"]
if not user_agent:
return False
elif any(phone in user_agent.lower() for phone in phones):
return True
else:
return False
def detect_plexmediaserver(self, request):
user_agent = request.headers.get('User-Agent')
if not user_agent:
return False
elif str(user_agent).lower().startswith("plexmediaserver"):
return True
else:
return False
def add_endpoints(self, index_name):
item_list = [x for x in dir(self.endpoints_obj[index_name]) if self.isapath(x)]
endpoint_main = self.endpoints_obj[index_name]
endpoint_main.fhdhr.version # dummy line
for item in item_list:
endpoints = eval("endpoint_main.%s.%s" % (item, "endpoints"))
if isinstance(endpoints, str):
endpoints = [endpoints]
handler = eval("endpoint_main.%s" % item)
endpoint_name = eval("endpoint_main.%s.%s" % (item, "endpoint_name"))
try:
endpoint_methods = eval("endpoint_main.%s.%s" % (item, "endpoint_methods"))
except AttributeError:
endpoint_methods = ['GET']
try:
endpoint_access_level = eval("endpoint_main.%s.%s" % (item, "endpoint_access_level"))
except AttributeError:
endpoint_access_level = 0
try:
pretty_name = eval("endpoint_main.%s.%s" % (item, "pretty_name"))
except AttributeError:
pretty_name = endpoint_name
try:
endpoint_category = eval("endpoint_main.%s.%s" % (item, "endpoint_category"))
except AttributeError:
endpoint_category = index_name
try:
endpoint_default_parameters = eval("endpoint_main.%s.%s" % (item, "endpoint_default_parameters"))
except AttributeError:
endpoint_default_parameters = {}
endpoint_added = True
try:
for endpoint in endpoints:
self.add_endpoint(endpoint=endpoint,
endpoint_name=endpoint_name,
handler=handler,
methods=endpoint_methods)
except AssertionError:
endpoint_added = False
if endpoint_added:
self.fhdhr.logger.debug("Adding endpoint %s available at %s with %s methods." % (endpoint_name, ",".join(endpoints), ",".join(endpoint_methods)))
if endpoint_category not in list(self.route_list.keys()):
self.route_list[endpoint_category] = {}
if endpoint_name not in list(self.route_list[endpoint_category].keys()):
self.route_list[endpoint_category][endpoint_name] = {}
self.route_list[endpoint_category][endpoint_name]["name"] = endpoint_name
self.route_list[endpoint_category][endpoint_name]["endpoints"] = endpoints
self.route_list[endpoint_category][endpoint_name]["endpoint_methods"] = endpoint_methods
self.route_list[endpoint_category][endpoint_name]["endpoint_access_level"] = endpoint_access_level
self.route_list[endpoint_category][endpoint_name]["endpoint_default_parameters"] = endpoint_default_parameters
self.route_list[endpoint_category][endpoint_name]["pretty_name"] = pretty_name
self.route_list[endpoint_category][endpoint_name]["endpoint_category"] = endpoint_category
def isapath(self, item):
not_a_page_list = ["fhdhr", "plugin_utils"]
if item in not_a_page_list:
return False
elif item.startswith("__") and item.endswith("__"):
return False
else:
return True
def add_endpoint(self, endpoint=None, endpoint_name=None, handler=None, methods=['GET']):
self.fhdhr.app.add_url_rule(endpoint, endpoint_name, handler, methods=methods)
def run(self):
self.http = WSGIServer(self.fhdhr.api.address_tuple,
self.fhdhr.app.wsgi_app,
log=self.fhdhr.logger.logger,
error_log=self.fhdhr.logger.logger)
try:
self.http.serve_forever()
self.stop()
except AttributeError:
self.fhdhr.logger.info("HTTP Server Offline")
def main():
http_server = WSGIServer(('', args.listen_port), app)
http_server.serve_forever()
import getopt
from gevent import monkey
monkey.patch_all()
from gevent.pywsgi import WSGIServer
from cplatform.wsgi import application
from multiprocessing import Process
addr, port = '127.0.0.1', 8000
opts, _ = getopt.getopt(sys.argv[1:], "b:")
for opt, value in opts:
if opt == '-b':
addr, port = value.split(":")
server = WSGIServer((addr, int(port)), application)
process_count = 4
for i in range(process_count - 1):
Process(target=server.serve_forever(), args=tuple()).start()
"""
username: String: a String of the user page requested in the url.
generates the requested user page if it exists, if not, generates the page saying that the user was not found.
"""
if username_in_db(username):
db = sqlite3.connect(DB_PATH)
cur = db.cursor()
cur.execute(
"SELECT about, age, sex, favorite_food FROM users WHERE username=?",
(username, )) # Retrieves the info about the user.
row = cur.fetchone()
about, age, sex, favorite_food = row
return render_template('video_feed.html',
video_url=url_for('video_feed',
username=username),
about=about,
age=age,
sex=sex,
favorite_food=favorite_food)
return render_template('user_not_found.html')
if __name__ == "__main__":
print CODE_FILES_PATH
thread = threading.Thread(target=ImageReceiveServer().start_server)
thread.daemon = True
thread.start()
app.config["SECRET_KEY"] = "ITSASECRET"
http = WSGIServer(('', WEB_SERVER_PORT), app)
http.serve_forever()
def __init__(self, args):
for arg in args:
temp = arg.split("=")
if temp[0] == "env":
Container.env = temp[1]
# 获取项目根目录
Container.project_path = os.getcwd()
# 加载配置文件信息
Container.config = Config(root_path=Container.project_path, env=Container.env)
# 初始化日志
level_info = {
'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR
}
logging.basicConfig(level=level_info[Container.config.getProperty("logging.level")]
, format=Container.config.getProperty("logging.format"))
logger.info("run env: %s" % Container.env)
logger.debug("config: %s" % Container.config.config)
logger.debug("project_root_path = %s" % Container.project_path)
# 打印logo
logger.info('''
('-. ('-. .-') _
_( OO) ( OO ).-. ( OO ) )
.-'),-----. .-----. (,------./ . --. /,--./ ,--,'
( OO' .-. ' ' .--./ | .---'| \-. \ | \ | |\
/ | | | | | |('-. | | .-'-' | || \| | )
\_) | |\| | /_) |OO )(| '--.\| |_.' || . |/
\ | | | | || |`-'| | .--' | .-. || |\ |
`' '-' '(_' '--'\ | `---.| | | || | \ |
`-----' `-----' `------'`--' `--'`--' `--'
''')
# 加载数据库
database_list = Container.config.getProperty("postgres")
logger.info("load database start")
for key, database in database_list.items():
logger.info(
"load database, host: %s, port: %s, path: %s" % (database["host"], database["port"], database["path"]))
Container.database_conn_pool_dict[database["path"]] \
= ThreadedConnectionPool(database["minconn"]
, database["maxconn"]
, host=database["host"]
, user=database["user"]
, password=database["password"]
, dbname=database["database"]
, port=int(database["port"]))
logger.info("load database complete")
# 初始化定时任务
logger.info("init scheduler start")
Container.scheduler = BackgroundScheduler(job_defaults={
'coalesce': Container.config.getProperty("scheduler.coalesce", False),
'max_instances': Container.config.getProperty("scheduler.max_instances", 1),
'misfire_grace_time': Container.config.getProperty("scheduler.misfire_grace_time", 60)
})
# 初始化jobs
job_list = Container.config.getProperty("scheduler.job")
module_dict = {}
for key, job in job_list.items():
logger.debug("add scheduler: %s" % key)
func_info = job["path"].split(".")
method = func_info[-1]
from_info = ".".join(func_info[0: -2]) if len(func_info) > 3 else func_info[0]
module_info = ".".join(func_info[0: -1])
module = None
try:
module = module_dict[module_info]
except Exception as e:
logger.warn(e)
if not module:
module = __import__(module_info, fromlist=[from_info])
module_dict[module_info] = module
fn = getattr(module, method)
if job["schema"] == "cron":
Container.scheduler.add_job(fn, CronTrigger.from_crontab(job["cron"]))
else:
Container.scheduler.add_job(fn, job["schema"], seconds=job["seconds"])
Container.scheduler.start()
logger.info("init scheduler end")
# 初始化web
port = Container.config.getProperty("server.port", 8080)
logger.info("init web start, port: %s" % port)
routeLen = len("@route(")
errorhandlerLen = len("@errorhandler(")
for root, dirs, files in os.walk(Container.project_path):
for file in files:
with open(os.path.join(root, file), mode='r') as rp:
try:
lines = rp.readlines()
flag = False
for line in lines:
content = line.rstrip()
if len(content) > routeLen and (content[:routeLen] == "@route(" or content[:errorhandlerLen] == "@errorhandler("):
flag = True
break
if flag:
f = root[len(Container.project_path) + 1:]
f = ".".join(f.split("/"))
name = ".".join([f, file.split(".")[0]])
logger.info("init web, path: %s" % name)
__import__(name, fromlist=[f])
except Exception as e:
logger.debug("init controller failed, path: %s Exception: %s" % (os.path.join(root, file), e))
# app.run(host="0.0.0.0", port=int(port))
monkey.patch_all()
http_server = WSGIServer(("0.0.0.0", port), app)
http_server.serve_forever()
class server:
wsgiserver = None
restart = False
def __init__(self):
signal.signal(signal.SIGINT, self.killServer)
signal.signal(signal.SIGTERM, self.killServer)
def start_gevent(self):
try:
ssl_args = dict()
certfile_path = web.ub.config.get_config_certfile()
keyfile_path = web.ub.config.get_config_keyfile()
if certfile_path and keyfile_path:
if os.path.isfile(certfile_path) and os.path.isfile(
keyfile_path):
ssl_args = {
"certfile": certfile_path,
"keyfile": keyfile_path
}
else:
web.app.logger.info(
'The specified paths for the ssl certificate file and/or key file seem to be broken. Ignoring ssl. Cert path: %s | Key path: %s'
% (certfile_path, keyfile_path))
if os.name == 'nt':
self.wsgiserver = WSGIServer(
('0.0.0.0', web.ub.config.config_port),
web.app,
spawn=Pool(),
**ssl_args)
else:
self.wsgiserver = WSGIServer(('', web.ub.config.config_port),
web.app,
spawn=Pool(),
**ssl_args)
web.py3_gevent_link = self.wsgiserver
self.wsgiserver.serve_forever()
except SocketError:
try:
web.app.logger.info(
'Unable to listen on \'\', trying on IPv4 only...')
self.wsgiserver = WSGIServer(
('0.0.0.0', web.ub.config.config_port),
web.app,
spawn=Pool(),
**ssl_args)
web.py3_gevent_link = self.wsgiserver
self.wsgiserver.serve_forever()
except (OSError, SocketError) as e:
web.app.logger.info("Error starting server: %s" % e.strerror)
print("Error starting server: %s" % e.strerror)
web.helper.global_WorkerThread.stop()
sys.exit(1)
except Exception:
web.app.logger.info("Unknown error while starting gevent")
def startServer(self):
if gevent_present:
web.app.logger.info('Starting Gevent server')
# leave subprocess out to allow forking for fetchers and processors
self.start_gevent()
else:
try:
ssl = None
web.app.logger.info('Starting Tornado server')
certfile_path = web.ub.config.get_config_certfile()
keyfile_path = web.ub.config.get_config_keyfile()
if certfile_path and keyfile_path:
if os.path.isfile(certfile_path) and os.path.isfile(
keyfile_path):
ssl = {
"certfile": certfile_path,
"keyfile": keyfile_path
}
else:
web.app.logger.info(
'The specified paths for the ssl certificate file and/or key file seem to be broken. Ignoring ssl. Cert path: %s | Key path: %s'
% (certfile_path, keyfile_path))
# Max Buffersize set to 200MB
http_server = HTTPServer(WSGIContainer(web.app),
max_buffer_size=209700000,
ssl_options=ssl)
http_server.listen(web.ub.config.config_port)
self.wsgiserver = IOLoop.instance()
self.wsgiserver.start()
# wait for stop signal
self.wsgiserver.close(True)
except SocketError as e:
web.app.logger.info("Error starting server: %s" % e.strerror)
print("Error starting server: %s" % e.strerror)
web.helper.global_WorkerThread.stop()
sys.exit(1)
# ToDo: Somehow caused by circular import under python3 refactor
if sys.version_info > (3, 0):
self.restart = web.py3_restart_Typ
if self.restart == True:
web.app.logger.info("Performing restart of Calibre-Web")
web.helper.global_WorkerThread.stop()
if os.name == 'nt':
arguments = ["\"" + sys.executable + "\""]
for e in sys.argv:
arguments.append("\"" + e + "\"")
os.execv(sys.executable, arguments)
else:
os.execl(sys.executable, sys.executable, *sys.argv)
else:
web.app.logger.info("Performing shutdown of Calibre-Web")
web.helper.global_WorkerThread.stop()
sys.exit(0)
def setRestartTyp(self, starttyp):
self.restart = starttyp
# ToDo: Somehow caused by circular import under python3 refactor
web.py3_restart_Typ = starttyp
def killServer(self, signum, frame):
self.stopServer()
def stopServer(self):
# ToDo: Somehow caused by circular import under python3 refactor
if sys.version_info > (3, 0):
if not self.wsgiserver:
if gevent_present:
self.wsgiserver = web.py3_gevent_link
else:
self.wsgiserver = IOLoop.instance()
if self.wsgiserver:
if gevent_present:
self.wsgiserver.close()
else:
self.wsgiserver.add_callback(self.wsgiserver.stop)
@staticmethod
def getNameVersion():
if gevent_present:
return {'Gevent': 'v' + geventVersion}
else:
return {'Tornado': 'v' + tornadoVersion}
class LANServer:
def __init__(self, shared_state):
app = Flask(__name__)
self.app = app
self.host = config.get('lan.bind_ip', '')
self.server = None
if self.host == '':
self.host = best_ip
self.port = None
@app.before_request
def dns_rebinding_prevention():
if request.remote_addr in lan_ips or ipaddress.ip_address(
request.remote_addr).is_loopback:
if time.time() - _start_time > 600:
abort(403)
if request.host != f'{self.host}:{self.port}':
logger.warn('Potential DNS rebinding attack on LAN server:')
logger.warn(
f'Hostname {request.host} was used instead of {self.host}:{self.port}'
)
abort(403)
@app.route('/blist/<time>')
def get_block_list_for_lan(time):
return Response('\n'.join(get_block_list(dateRec=time)))
@app.route('/get/<block>')
def get_block_data(block):
if not stringvalidators.validate_hash(block):
raise ValueError
return Response(Block(block).raw,
mimetype='application/octet-stream')
@app.route("/ping")
def ping():
return Response("onionr!")
@app.route('/upload', methods=['POST'])
def upload_endpoint():
return accept_upload(request)
def start_server(self):
def _show_lan_bind(port):
better_sleep(1)
if self.server.started and port == self.server.server_port:
logger.info(f'Serving to LAN on {self.host}:{self.port}',
terminal=True)
if self.host == "":
logger.info(
"Not binding to LAN due to no private network configured.",
terminal=True)
return
for i in ports:
self.server = WSGIServer((self.host, i),
self.app,
log=None,
handler_class=FDSafeHandler)
self.port = self.server.server_port
try:
Thread(target=_show_lan_bind, args=[i], daemon=True).start()
self.server.serve_forever()
except OSError:
pass
else:
break
else:
logger.warn("Could not bind to any LAN ports " + str(min(ports)) +
"-" + str(max(ports)),
terminal=True)
return
def main():
global engine
global connection
global metadata
global Session
global solutions
global submissions
global correct
global incorrect
global users
global hints
global hintreqs
global chattext
# database location handling
db_loc = os.getenv("CTF_DB_LOC")
if db_loc is None:
logging.error("FLASK : No database location provided. exiting...")
exit(1)
if not os.path.isfile(db_loc) or not os.access(db_loc, os.R_OK):
logging.error("FLASK : database does not exist. exiting...")
exit(1)
# sqlalchemy setup
engine = sql.create_engine("sqlite:///" + db_loc)
connection = engine.connect()
metadata = sql.MetaData()
Session = sql.orm.sessionmaker(bind=engine)
try:
users = sql.Table("users",
metadata,
autoload=True,
autoload_with=engine)
solutions = sql.Table("solutions",
metadata,
autoload=True,
autoload_with=engine)
correct = sql.Table("correct",
metadata,
autoload=True,
autoload_with=engine)
incorrect = sql.Table("incorrect",
metadata,
autoload=True,
autoload_with=engine)
submissions = sql.Table("submissions",
metadata,
autoload=True,
autoload_with=engine)
starttime = sql.Table("starttime",
metadata,
autoload=True,
autoload_with=engine)
hints = sql.Table("hints",
metadata,
autoload=True,
autoload_with=engine)
hintreqs = sql.Table("hintreqs",
metadata,
autoload=True,
autoload_with=engine)
chattext = sql.Table("chattext",
metadata,
autoload=True,
autoload_with=engine)
hint_config = sql.Table("hint_config",
metadata,
autoload=True,
autoload_with=engine)
except NoSuchTableError:
logging.error("FLASK : database exists, " +
"but does not have required tables. exiting...")
exit(1)
# mapping the loaded tables onto our classes
mapper(User, users)
mapper(Solution, solutions)
mapper(Submission, submissions)
mapper(Correct, correct)
mapper(Incorrect, incorrect)
mapper(Starttime, starttime)
mapper(Hint, hints)
mapper(Hintreq, hintreqs)
mapper(Chattext, chattext)
mapper(Hintconfig, hint_config)
# setting up and starting the server
logger = logging.getLogger()
logging.basicConfig(
level='INFO', format='FLASK : %(levelname)-8s %(asctime)s %(message)s')
logging.info("Connecting to MQTT server...")
mqtt_addr = os.getenv("MQTT_ADDR")
mqtt_port = os.getenv("MQTT_PORT")
mqtt_username = os.getenv("MQTT_USERNAME")
mqtt_password = os.getenv("MQTT_PASSWORD")
global mclient
if mqtt_addr is None or mqtt_port is None:
logging.warning(
"FLASK : MQTT_PORT or MQTT_ADDR not set, disabling mqtt...")
else:
mclient = mqtt.Client()
try:
if mqtt_username is not None:
if mqtt_password is not None:
mclient.username_pw_set(mqtt_username, mqtt_password)
else:
mclient.username_pw_set(mqtt_username)
mclient.connect(mqtt_addr, int(mqtt_port), 60, "0.0.0.0")
mclient.loop_start()
except ValueError:
logging.error("FLASK : MQTT_PORT must be an integer. exiting...")
exit(1)
except ConnectionRefusedError as e:
logging.error(
f"FLASK : connection to MQTT broker refused. exiting...\n{e}")
exit(1)
except Exception as e:
logging.error(
f"FLASK : unexpected error while connecting to MQTT broker: {str(e)}"
)
exit(1)
time = datetime.datetime.utcnow()
session = Session()
if session.query(Starttime).count() == 0:
session.add(Starttime(time=time))
session.commit()
logging.info("Initialization of the hintbot...")
configs = session.query(Hintconfig).all()
config_dict = {}
for config in configs:
config_dict[config.k] = config.v
global hintbot
hintbot = Hintbot(config_dict)
try:
global fails_until_hints
fails_until_hints = int(config_dict["failures_until_hints"])
except ValueError:
logging.error("Using default 2 failures until hints.")
fails_until_hints = 2
except KeyError:
logging.error("Using default 2 failures until hints.")
fails_until_hints = 2
session.close()
logging.info("Starting ctf server...")
http_server = WSGIServer(("0.0.0.0", 8443),
app,
log=logger,
error_log=logger)
http_server.serve_forever()
def main():
global input_args
app.jinja_env.filters['str2datetime'] = str2datetime
input_args = parse_input_args()
# setup logging level
if input_args.log_level:
logging.root.setLevel(input_args.log_level)
# On `init` command, create directory args.project_name with initial project state and exit
if input_args.command == 'init':
Project.create_project_dir(input_args.project_name, input_args)
return
elif input_args.command == 'start':
# If `start --init` option is specified, do the same as with `init` command, but continue to run app
if input_args.init:
Project.create_project_dir(input_args.project_name, input_args)
if not os.path.exists(
Project.get_project_dir(input_args.project_name, input_args)):
raise FileNotFoundError(
'Project directory "{pdir}" not found. '
'Did you miss create it first with `label-studio init {pdir}` ?'
.format(pdir=Project.get_project_dir(input_args.project_name,
input_args)))
# On `start` command, launch browser if --no-browser is not specified and start label studio server
if input_args.command == 'start':
import label_studio.utils.functions
import label_studio.utils.auth
config = Project.get_config(input_args.project_name, input_args)
# set username and password
label_studio.utils.auth.USERNAME = input_args.username or \
config.get('username') or label_studio.utils.auth.USERNAME
label_studio.utils.auth.PASSWORD = input_args.password or config.get(
'password', '')
# set host name
host = input_args.host or config.get(
'host', 'localhost') # name for external links generation
port = input_args.port or config.get('port', 8080)
server_host = 'localhost' if host == 'localhost' else '0.0.0.0' # web server host
# ssl certificate and key
cert_file = input_args.cert_file or config.get('cert')
key_file = input_args.key_file or config.get('key')
ssl_context = None
if cert_file and key_file:
config['protocol'] = 'https://'
ssl_context = (cert_file, key_file)
# check port is busy
if not input_args.debug and check_port_in_use('localhost', port):
old_port = port
port = int(port) + 1
print('\n*** WARNING! ***\n* Port ' + str(old_port) +
' is in use.\n' + '* Trying to start at ' + str(port) +
'\n****************\n')
set_web_protocol(input_args.protocol
or config.get('protocol', 'http://'))
set_full_hostname(get_web_protocol() +
host.replace('0.0.0.0', 'localhost') + ':' +
str(port))
start_browser('http://localhost:' + str(port), input_args.no_browser)
if input_args.use_gevent:
app.debug = input_args.debug
ssl_args = {
'keyfile': key_file,
'certfile': cert_file
} if ssl_context else {}
http_server = WSGIServer((server_host, port),
app,
log=app.logger,
**ssl_args)
http_server.serve_forever()
else:
app.run(host=server_host,
port=port,
debug=input_args.debug,
ssl_context=ssl_context)
# On `start-multi-session` command, server creates one project per each browser sessions
elif input_args.command == 'start-multi-session':
server_host = input_args.host or '0.0.0.0'
port = input_args.port or 8080
if input_args.use_gevent:
app.debug = input_args.debug
http_server = WSGIServer((server_host, port), app, log=app.logger)
http_server.serve_forever()
else:
app.run(host=server_host, port=port, debug=input_args.debug)
def _run(self):
print("WSGI Server Listen at port {0}".format(self.port))
server = WSGIServer(('0.0.0.0', self.port), self.app or self._app)
server.serve_forever()
console_handler.setLevel(logging.ERROR)
# create formatter
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# add handlers to the logger
loggerA.addHandler(file_handler)
loggerA.addHandler(console_handler)
return loggerA
if __name__ == '__main__':
logger = createLogger()
logger.info('Started')
freeze_support()
game_servers = {}
tracker_server = TrackerServer()
tracker_server.start()
state_server = StateServer(tracker_server)
state_server.start()
rest_app = RESTAPI(game_servers, state_server)
rest_server = WSGIServer(('0.0.0.0', 8088), rest_app)
rest_server.serve_forever()
def run():
http_server = WSGIServer(('', 7210), app)
http_server.serve_forever()
def start(self):
http_server = WSGIServer(('', self.port), self.app)
http_server.serve_forever()
class WebfrontEngine(object):
"""
The client-facing web interface.
"""
def __init__(self):
logger.debug("Initializing webfront engine...")
global webfront
webfront = self
self._http_listener = None
self._https_listener = None
self.listen_port = 5000
self.listen_addr = '127.0.0.1'
self.secure_listen_port = 0 # 0 means not binding
self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port, )
self.secure_base_url = "https://127.0.0.1:%d/" % (
self.secure_listen_port, )
self._token = None
@property
def access_token(self):
return self._token
def _acquire_access_token(self):
self._token = os.environ.get('AVA_ACCESS_TOKEN',
base58.b58encode(os.urandom(16)))
def start(self, ctx=None):
logger.debug("Starting webfront engine...")
disabled = settings[_CONF_SECTION].get('disabled')
if disabled:
logger.debug("Webfront is not enabled.")
return
self._acquire_access_token()
logger.info("Access Token: %s", self._token)
self.listen_port = settings[_CONF_SECTION]['listen_port']
self.listen_addr = settings[_CONF_SECTION]['listen_addr']
self.secure_listen_port = settings[_CONF_SECTION]['secure_listen_port']
self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port, )
logger.debug("Local base URL:%s", self.local_base_url)
if self.listen_port > 0:
ctx.add_child_greenlet(gevent.spawn(self._run_http))
if self.secure_listen_port > 0:
ctx.add_child_greenlet(gevent.spawn(self._run_https))
else:
logger.debug("HTTPS listener is disabled.")
ctx.bind('webfront', self)
logger.debug("Webfront engine started.")
def stop(self, ctx=None):
logger.debug("Webfront engine stopped.")
def _run_https(self):
logger.debug("Webfront engine(HTTPS) is running...")
conf_dir = environ.conf_dir()
keyfile = os.path.join(conf_dir, 'ava.key')
certfile = os.path.join(conf_dir, 'ava.crt')
self._https_listener = WSGIServer(
(self.listen_addr, self.secure_listen_port),
dispatcher,
keyfile=keyfile,
certfile=certfile)
logger.debug("Webfront engine(HTTPS) is listening on port: %d",
self._https_listener.address[1])
self._https_listener.serve_forever()
def _run_http(self):
logger.debug("Webfront engine(HTTP) is running...")
self._http_listener = WSGIServer((self.listen_addr, self.listen_port),
dispatcher)
logger.debug("Webfront engine(HTTP) is listening on port: %d",
self._http_listener.address[1])
self._http_listener.serve_forever()
raise ValueError('User agent must be set to adhere to metno ToS: https://api.met.no/doc/TermsOfService')
content, headers = _fetch_content_and_headers(path, query, headers={
'User-Agent': USER_AGENT
})
content = create_standard_json_from_metno(content, days)
else:
# WWO tweaks
query_string += "&extra=localObsTime"
query_string += "&includelocation=yes"
content, headers = _fetch_content_and_headers(path, query_string)
content = add_translations(content, lang)
return content, 200, headers
if __name__ == "__main__":
#app.run(host='0.0.0.0', port=5001, debug=False)
#app.debug = True
if len(sys.argv) == 1:
bind_addr = "0.0.0.0"
SERVER = WSGIServer((bind_addr, PROXY_PORT), APP)
SERVER.serve_forever()
else:
print('running single request from command line arg')
APP.testing = True
with APP.test_client() as c:
resp = c.get(sys.argv[1])
print('Status: ' + resp.status)
# print('Headers: ' + dumps(resp.headers))
print(resp.data.decode('utf-8'))
class PsDashRunner(object):
DEFAULT_LOG_INTERVAL = 60
DEFAULT_NET_IO_COUNTER_INTERVAL = 3
DEFAULT_REGISTER_INTERVAL = 60
DEFAULT_BIND_HOST = "0.0.0.0"
DEFAULT_PORT = 5000
LOCAL_NODE = "localhost"
@classmethod
def create_from_cli_args(cls):
return cls(args=None)
def __init__(self, config_overrides=None, args=tuple()):
self._nodes = {}
config = self._load_args_config(args)
if config_overrides:
config.update(config_overrides)
self.app = self._create_app(config)
self._setup_nodes()
self._setup_logging()
self._setup_context()
def _get_args(cls, args):
parser = argparse.ArgumentParser(
description="psdash %s - system information web dashboard" %
__version__)
parser.add_argument(
"-l",
"--log",
action="append",
dest="logs",
default=None,
metavar="path",
help=
"log files to make available for psdash. Patterns (e.g. /var/log/**/*.log) are supported. "
"This option can be used multiple times.",
)
parser.add_argument(
"-b",
"--bind",
action="store",
dest="bind_host",
default=None,
metavar="host",
help="host to bind to. Defaults to 0.0.0.0 (all interfaces).",
)
parser.add_argument(
"-p",
"--port",
action="store",
type=int,
dest="port",
default=None,
metavar="port",
help="port to listen on. Defaults to 5000.",
)
parser.add_argument(
"-d",
"--debug",
action="store_true",
dest="debug",
help="enables debug mode.",
)
parser.add_argument(
"-a",
"--agent",
action="store_true",
dest="agent",
help=
"Enables agent mode. This launches a RPC server, using zerorpc, on given bind host and port.",
)
parser.add_argument(
"--register-to",
action="store",
dest="register_to",
default=None,
metavar="host:port",
help=
"The psdash node running in web mode to register this agent to on start up. e.g 10.0.1.22:5000",
)
parser.add_argument(
"--register-as",
action="store",
dest="register_as",
default=None,
metavar="name",
help=
"The name to register as. (This will default to the node's hostname)",
)
return parser.parse_args(args)
def _load_args_config(self, args):
config = {}
for k, v in vars(self._get_args(args)).items():
if v:
key = "PSDASH_%s" % k.upper() if k != "debug" else "DEBUG"
config[key] = v
return config
def _setup_nodes(self):
self.add_node(LocalNode())
nodes = self.app.config.get("PSDASH_NODES", [])
logger.info("Registering %d nodes", len(nodes))
for n in nodes:
self.register_node(n["name"], n["host"], int(n["port"]))
def add_node(self, node):
self._nodes[node.get_id()] = node
def get_local_node(self):
return self._nodes.get(self.LOCAL_NODE)
def get_node(self, name):
return self._nodes.get(name)
def get_nodes(self):
return self._nodes
def register_node(self, name, host, port):
n = RemoteNode(name, host, port)
node = self.get_node(n.get_id())
if node:
n = node
logger.debug("Updating registered node %s", n.get_id())
else:
logger.info("Registering %s", n.get_id())
n.update_last_registered()
self.add_node(n)
return n
def _create_app(self, config=None):
app = Flask(__name__)
app.psdash = self
app.config.from_envvar("PSDASH_CONFIG", silent=True)
if config and isinstance(config, dict):
app.config.update(config)
self._load_allowed_remote_addresses(app)
# If the secret key is not read from the config just set it to something.
if not app.secret_key:
app.secret_key = "whatisthissourcery"
app.add_template_filter(fromtimestamp)
from psdash.web import webapp
prefix = app.config.get("PSDASH_URL_PREFIX")
if prefix:
prefix = "/" + prefix.strip("/")
webapp.url_prefix = prefix
app.register_blueprint(webapp)
return app
def _load_allowed_remote_addresses(self, app):
key = "PSDASH_ALLOWED_REMOTE_ADDRESSES"
addrs = app.config.get(key)
if not addrs:
return
if isinstance(addrs, str):
app.config[key] = [a.strip() for a in addrs.split(",")]
def _setup_logging(self):
level = (self.app.config.get("PSDASH_LOG_LEVEL", logging.INFO)
if not self.app.debug else logging.DEBUG)
format = self.app.config.get("PSDASH_LOG_FORMAT",
"%(levelname)s | %(name)s | %(message)s")
logging.basicConfig(level=level, format=format)
logging.getLogger("werkzeug").setLevel(
logging.WARNING if not self.app.debug else logging.DEBUG)
def _setup_workers(self):
net_io_interval = self.app.config.get(
"PSDASH_NET_IO_COUNTER_INTERVAL",
self.DEFAULT_NET_IO_COUNTER_INTERVAL,
)
gevent.spawn_later(net_io_interval, self._net_io_counters_worker,
net_io_interval)
if "PSDASH_LOGS" in self.app.config:
logs_interval = self.app.config.get("PSDASH_LOGS_INTERVAL",
self.DEFAULT_LOG_INTERVAL)
gevent.spawn_later(logs_interval, self._logs_worker, logs_interval)
if self.app.config.get("PSDASH_AGENT"):
register_interval = self.app.config.get(
"PSDASH_REGISTER_INTERVAL", self.DEFAULT_REGISTER_INTERVAL)
gevent.spawn_later(
register_interval,
self._register_agent_worker,
register_interval,
)
def _setup_locale(self):
# This set locale to the user default (usually controlled by the LANG env var)
locale.setlocale(locale.LC_ALL, "")
def _setup_context(self):
self.get_local_node().net_io_counters.update()
if "PSDASH_LOGS" in self.app.config:
self.get_local_node().logs.add_patterns(
self.app.config["PSDASH_LOGS"])
def _logs_worker(self, sleep_interval):
while True:
logger.debug("Reloading logs...")
self.get_local_node().logs.add_patterns(
self.app.config["PSDASH_LOGS"])
gevent.sleep(sleep_interval)
def _register_agent_worker(self, sleep_interval):
while True:
logger.debug("Registering agent...")
self._register_agent()
gevent.sleep(sleep_interval)
def _net_io_counters_worker(self, sleep_interval):
while True:
logger.debug("Updating net io counters...")
self.get_local_node().net_io_counters.update()
gevent.sleep(sleep_interval)
def _register_agent(self):
register_name = self.app.config.get("PSDASH_REGISTER_AS")
if not register_name:
register_name = socket.gethostname()
url_args = {
"name": register_name,
"port": self.app.config.get("PSDASH_PORT", self.DEFAULT_PORT),
}
register_url = "%s/register?%s" % (
self.app.config["PSDASH_REGISTER_TO"],
urllib.parse.urlencode(url_args),
)
if ("PSDASH_AUTH_USERNAME" in self.app.config
and "PSDASH_AUTH_PASSWORD" in self.app.config):
auth_handler = urllib.request.HTTPBasicAuthHandler()
auth_handler.add_password(
realm="psDash login required",
uri=register_url,
user=self.app.config["PSDASH_AUTH_USERNAME"],
passwd=self.app.config["PSDASH_AUTH_PASSWORD"],
)
opener = urllib.request.build_opener(auth_handler)
urllib.request.install_opener(opener)
try:
urllib.request.urlopen(register_url)
except urllib.error.HTTPError as e:
logger.error('Failed to register agent to "%s": %s', register_url,
e)
def _run_rpc(self):
logger.info("Starting RPC server (agent mode)")
if "PSDASH_REGISTER_TO" in self.app.config:
self._register_agent()
service = self.get_local_node().get_service()
self.server = zerorpc.Server(service)
self.server.bind("tcp://%s:%s" % (
self.app.config.get("PSDASH_BIND_HOST", self.DEFAULT_BIND_HOST),
self.app.config.get("PSDASH_PORT", self.DEFAULT_PORT),
))
self.server.run()
def _run_web(self):
logger.info("Starting web server")
log = "default" if self.app.debug else None
ssl_args = {}
if self.app.config.get("PSDASH_HTTPS_KEYFILE") and self.app.config.get(
"PSDASH_HTTPS_CERTFILE"):
ssl_args = {
"keyfile": self.app.config.get("PSDASH_HTTPS_KEYFILE"),
"certfile": self.app.config.get("PSDASH_HTTPS_CERTFILE"),
}
listen_to = (
self.app.config.get("PSDASH_BIND_HOST", self.DEFAULT_BIND_HOST),
self.app.config.get("PSDASH_PORT", self.DEFAULT_PORT),
)
self.server = WSGIServer(listen_to,
application=self.app,
log=log,
**ssl_args)
self.server.serve_forever()
def run(self):
logger.info("Starting psdash v%s" % __version__)
self._setup_locale()
self._setup_workers()
logger.info(
"Listening on %s:%s",
self.app.config.get("PSDASH_BIND_HOST", self.DEFAULT_BIND_HOST),
self.app.config.get("PSDASH_PORT", self.DEFAULT_PORT),
)
if self.app.config.get("PSDASH_AGENT"):
return self._run_rpc()
else:
return self._run_web()
def spawn(host: Tuple[str, int]):
global _standalone
server = WSGIServer(host, _standalone, log=None, error_log=None)
_ping()
server.serve_forever()
