def server_maker(config, **extra_config):
"""
Return a server-making callable to create a CherryPy WSGI server.
The server-making callable should be passed a WSGI application, and it
will return an instance of `cherrypy.wsgiserver.CherryPyWSGIServer`.
You can optionally override any of the hardwired configuration
parameters by passing in keyword arguments which will be passed along to
the `CherryPyWSGIServer` constructor.
"""
from cheroot.wsgi import Server as WSGIServer
bind_addr = (config['server.bind'], config['server.port'])
kwargs = dict(
numthreads=config['server.num-threads'],
server_name=config['server.name'],
request_queue_size=config['server.request-queue-size'],
timeout=config['server.timeout'],
)
kwargs.update(extra_config)
return lambda wsgi_app: WSGIServer(bind_addr, wsgi_app, **kwargs)
def run_webserver():
server = WSGIServer(bind_addr=(MY_IP, int(MY_PORT)),
wsgi_app=app,
numthreads=100)
print(
"[DDR_INSTALLER][INFO] ------------------------------------------------------------------------"
)
print("[DDR_INSTALLER][INFO] Starting IDA plugin installation.")
print(
"[DDR_INSTALLER][INFO] Please go to your IDA machine and point your browser to:\n"
)
print("[DDR_INSTALLER][INFO] http://{}:{}\n".format(MY_IP, MY_PORT))
print(
"[DDR_INSTALLER][INFO] Once you are done installing the IDA plugin, hit Ctrl-C here to stop the"
)
print("[DDR_INSTALLER][INFO] webserver and proceed with the installation.")
print(
"[DDR_INSTALLER][INFO] ------------------------------------------------------------------------"
)
try:
server.start()
except KeyboardInterrupt:
server.stop()
except:
print(
"[DDR_INSTALLER][ERROR] Failed to start installation server. Please check if you"
)
print(
"[DDR_INSTALLER][ERROR] have configured a valid NGINX IP address above.\n"
)
raise
def main(argv=sys.argv[1:]) -> int:
"""main entry point for ghast"""
parser = get_parser()
args = parser.parse_args(argv)
init_logging(args, "ghast.log")
__log__.info("starting ghast server on "
"host: {} port: {} "
"graylog_http_alert_url: {} "
"graylog_http_alert_script: {}".format(
args.host, args.port, args.graylog_http_alert_url,
args.graylog_http_alert_script))
# Setup and start the flask / cheroot server
ghast.server.API_HTTPS = args.api_https
ghast.server.ALERT_SCRIPT_PATH = args.graylog_http_alert_script
ghast.server.APP.register_blueprint(ghast.server.API_BLUEPRINT,
url_prefix=args.graylog_http_alert_url)
if args.debug:
ghast.server.APP.run(host=args.host, port=args.port, debug=True)
else:
path_info_dispatcher = PathInfoDispatcher({'/': ghast.server.APP})
server = WSGIServer((args.host, args.port), path_info_dispatcher)
try:
server.start()
except KeyboardInterrupt:
__log__.info("stopping server: KeyboardInterrupt detected")
server.stop()
return 0
except Exception:
__log__.exception("stopping server: unexpected exception")
raise
return 0
def run(self):
import utils.runtime_handler
utils.runtime_handler.enable_traceback_hook(
) # Enable custom traceback handling (to strip build path info)
self._shutdown_handler.add_task()
if self._use_ssl:
self._init_ssl()
ks = _KeyStore.query.first()
if ks is not None:
_app.config['SECRET_KEY'] = ks.flask_secret
else:
# Temporary static key for first run. We should roll this occasionally.
_app.config[
'SECRET_KEY'] = b'\xee\xf0\xabc>\xc8\xa4S\xa1\x89\xff\xa3\xaf\xcfX\xac'
self._jwt = JWT(_app, user_authenticate, user_identity)
self._wsgi_server = WSGIServer((self._host, int(self._port)),
PathInfoDispatcher({'/': _app}))
# TODO: Issue with SSL:
# Firefox causes a (socket.error 1) exception to be thrown on initial connection (before accepting cert)
# This is internal to cheroot, so it may be difficult to handle
print('LiquiTrader is ready for action!')
print(
f'Visit http{"s" if self._use_ssl else ""}://{self._host}:{self._port} in your favorite browser'
)
print('to start trading!')
self._wsgi_server.start()
def main(argv=sys.argv[1:]) -> int:
"""main entry point for the autotradeweb server"""
parser = get_parser()
args = parser.parse_args(argv)
init_logging(args, "autotradeweb.log")
# monkey patch courtesy of
# https://github.com/noirbizarre/flask-restplus/issues/54
# so that /swagger.json is served over https
if not args.disable_https:
@property
def specs_url(self):
"""Monkey patch for HTTPS"""
return url_for(self.endpoint("specs"), _external=True, _scheme="https")
Api.specs_url = specs_url
__log__.info("starting server: host: {} port: {}".format(args.host, args.port))
APP.config["SQLALCHEMY_DATABASE_URI"] = args.database
if args.debug:
APP.run(host=args.host, port=args.port, debug=True)
else:
path_info_dispatcher = PathInfoDispatcher({"/": APP})
# See SRS: S.8.R.4
server = WSGIServer((args.host, args.port), path_info_dispatcher)
try:
server.start()
except KeyboardInterrupt:
__log__.info("stopping server: KeyboardInterrupt detected")
server.stop()
return 0
except Exception:
__log__.exception("stopping server: unexpected exception")
raise
def start_ui(url, port, interpreter, quiet, language):
openurl = "localhost" if url == "0.0.0.0" else url
if not quiet:
print("Booting CherryPy server...")
d = PathInfoDispatcher({'/': create_app(interpreter, language)})
server = WSGIServer((url, port), d)
try:
p = multiprocessing.Process(target=delayed_browser_open,
args=(openurl, port))
p.start()
if not quiet:
print("Hosting at http://" + openurl + ":" + str(port) +
"/#loaded")
server.start()
except KeyboardInterrupt:
if not quiet:
print("Stopping CherryPy server...")
server.stop()
if not quiet:
print("Stopped")
def main(argv=sys.argv[1:]) -> int:
"""main entry point undiscord flask/cheroot server"""
parser = get_parser()
args = parser.parse_args(argv)
init_logging(args, "undiscord_server.log")
graph_dir = os.path.abspath(args.graph_dir)
os.makedirs(graph_dir, exist_ok=True)
__log__.info("starting server: host: {} port: {} graph_dir: {}".format(
args.host, args.port, graph_dir))
undiscord.server.server.GRAPH_DIR = graph_dir
if args.debug:
undiscord.server.server.APP.run(host=args.host,
port=args.port,
debug=True)
else:
path_info_dispatcher = PathInfoDispatcher(
{'/': undiscord.server.server.APP})
server = WSGIServer((args.host, args.port), path_info_dispatcher)
try:
server.start()
except KeyboardInterrupt:
__log__.info("stopping server: KeyboardInterrupt detected")
server.stop()
return 0
except Exception:
__log__.exception("stopping server: unexpected exception")
raise
def get_server(cmd_line_args):
args = _parse_args(cmd_line_args)
logger = _get_logger(args)
a = create_app([args['sql_source']], {})
d = PathInfoDispatcher({'/': a})
server = WSGIServer((args['url'], args['port']), d)
return logger, server, a
def start_ui(url, port, interpreter, quiet):
openurl = "localhost" if url == "0.0.0.0" else url
if not quiet:
print("Initializing CherryPy server...")
os.environ["FLASK_APP"] = "satyrnUI.satyrnUI"
os.environ["FLASK_ENV"] = "production"
d = PathInfoDispatcher({'/': create_app(interpreter)})
server = WSGIServer((url, port), d)
try:
p = multiprocessing.Process(target=delayed_browser_open,
args=(openurl, port))
p.start()
if not quiet:
print("Hosting at http://" + openurl + ":" + str(port) +
"/#loaded")
server.start()
except KeyboardInterrupt:
if not quiet:
print("Stopping CherryPy server...")
server.stop()
if not quiet:
print("Stopped")
def runtime(self, flask_instance: Flask, mode: int = ENABLE_FLASK):
"""
This method deploys a REST endpoint as using different technologies according to the "mode" value.
This endpoint will listen for incoming REST requests on different route paths.
"""
if mode == ENABLE_FLASK:
# simply run Flask
flask_instance.run(host=self._listening_address,
port=self._listening_port,
threaded=True)
elif mode == ENABLE_CHERRYPY:
# Run Flask wrapped by Cherrypy
cherrypy.tree.graft(flask_instance, "/")
cherrypy.config.update({
"server.socket_host": self._listening_address,
"server.socket_port": self._listening_port,
"engine.autoreload.on": False,
})
cherrypy.engine.start()
cherrypy.engine.block()
elif mode == ENABLE_WSGISERVER:
# Run Flask wrapped by a WSGI Server.
dispatcher = PathInfoDispatcher({'/': flask_instance})
server = WSGIServer(
(self._listening_address, self._listening_port), dispatcher)
try:
server.start()
# server.block
except KeyboardInterrupt:
server.stop()
else:
raise RuntimeError("Invalid runtime mode was selected.")
def _server_thread(self):
log.info(f'Starting webserver on {self.bind_hostname}:{self.bind_port}')
app = self._handler
app = DispatcherMiddleware(app, self.mount_map)
app = WSGILogger(app)
self.server = WSGIServer((self.bind_hostname, self.bind_port), app)
self.server.stats['Enabled'] = True
self.server.start()
def initiate():
log_main.info('Iniciando a API versão: {}'.format(app_version))
signal.signal(signal.SIGTERM, finalize)
signal.signal(signal.SIGINT, finalize)
global token, database, sms
token = conf.get('Auth',
'Token',
fallback='14acd1c3b2f50c1e7354668f7d0b4057')
ttvToken = open(
os.path.join(workdir, conf.get('Auth', 'TokenTTV', fallback=False)),
'r')
sms = SMS(ttvToken.readline())
ttvToken.close()
log_main.warning('Iniciando conexão com banco de dados ...')
try:
db = os.path.join(workdir,
conf.get('Database', 'Database', fallback='data.db'))
database = Database(db)
except Exception as e:
log_main.exception(
'Erro ao iniciar a conexão com o banco de dados: [{}]'.format(e))
_port = conf.getint('Flask', 'Port', fallback=8860)
_host = conf.get('Flask', 'Host', fallback='0.0.0.0')
_threads = conf.getint('Flask', 'Threads', fallback=100)
_ssl_cert = os.path.join(workdir, 'SSL',
conf.get('Flask', 'SSL_Cert', fallback=''))
_ssl_key = os.path.join(workdir, 'SSL',
conf.get('Flask', 'SSL_Key', fallback=''))
try:
_ssl_enabled = os.path.isfile(_ssl_cert) and os.path.isfile(_ssl_key)
except Exception:
_ssl_enabled = False
if len(sys.argv) > 1:
if sys.argv[1] in ('-v', '--version'):
print('API')
print('Versão: {}'.format(app_version))
sys.exit(0)
elif sys.argv[1] in ('-d', '--debug'):
app.run(host=_host, port=_port, threaded=True, debug=True)
else:
print('ERRO | Parâmetro desconhecido: {}'.format(sys.argv))
sys.exit(2)
else:
global server
server = WSGIServer(bind_addr=(_host, _port),
wsgi_app=app,
numthreads=_threads)
if _ssl_enabled:
server.ssl_adapter = BuiltinSSLAdapter(_ssl_cert, _ssl_key)
log_main.warning('Iniciando flask ...')
server.start()
def start_rest_service(port, num_threads, ovms_port):
available_models = get_available_models()
dispatcher = PathInfoDispatcher(
{'/': create_dispatcher(available_models, ovms_port)})
server = WSGIServer(('0.0.0.0', port), dispatcher, numthreads=num_threads)
logger.info(f"AMS service will start listening on port {port}")
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run(self, handler):
cert = SSL_CERT
#cert_chain = SSL_CERT_CHAIN
privkey = SSL_PRIVKEY
server = WSGIServer((self.host, self.port), handler)
server.ssl_adapter = SecuredSSLServer(cert, privkey) #, cert_chain)
try:
server.start()
finally:
server.stop()
def _flaskthread(self):
if self.debug:
self.app.run(host=self.host, port=self.port, debug=self.debug)
else:
wsgi_server = WSGIServer(bind_addr=("0.0.0.0", self.wsgi_port),
wsgi_app=self.app,
numthreads=100)
try:
wsgi_server.start()
except KeyboardInterrupt:
wsgi_server.stop()
def start_web_rest_server(models, rest_port):
d = PathInfoDispatcher({'/': create_rest_api(models)})
server = WSGIServer(('0.0.0.0', rest_port),
d,
numthreads=1,
request_queue_size=50)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run(self, handler):
try:
from cheroot.wsgi import Server as WSGIServer
except ImportError:
from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer
server = WSGIServer((self.host, self.port), handler)
try:
server.start()
finally:
server.stop()
def start_web_rest_server(models, rest_port, num_threads):
d = PathInfoDispatcher({'/': create_rest_api(models)})
server = WSGIServer(('0.0.0.0', rest_port), d,
numthreads=num_threads,
request_queue_size=GLOBAL_CONFIG[
'rest_requests_queue_size'])
logger.info("REST server listens on port {port} and will be "
"serving models: {models}".format(port=rest_port,
models=list(models.keys())))
try:
server.start()
except KeyboardInterrupt:
server.stop()
def setUp(self):
self.app = create_app(TestConfig)
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
d = PathInfoDispatcher({'/': self.app})
self.server = WSGIServer(('0.0.0.0', 5000), d)
Thread(target=self.server.start).start()
self.driver = webdriver.Firefox()
def run(self, handler):
from cheroot.wsgi import Server as WSGIServer
from cheroot.ssl.pyopenssl import pyOpenSSLAdapter
server = WSGIServer((self.host, self.port), handler)
server.ssl_adapter = pyOpenSSLAdapter(
certificate=SolUtils.AppConfig().get('solserver_certificate'),
private_key=SolUtils.AppConfig().get('solserver_private_key'),
)
try:
server.start()
log.info("Server started")
finally:
server.stop()
def main():
args = get_args()
app = create_app(args.output)
d = PathInfoDispatcher({"/": app})
server = WSGIServer((args.netmask, args.port), d)
try:
print(f"Logging location set to: {args.output}")
print(f"Listening on {args.netmask}:{args.port}....")
server.start()
except KeyboardInterrupt:
print("Exiting....")
sys.exit(0)
def run(self):
logger.info(
f"HTTP server listens on http://{self.host}:{self.port}{self.endpoint}"
)
if self.agent:
self.agent.server_status.starttime = datetime.now()
if self.debug:
self.app.run(host=self.host, port=self.port, debug=self.debug)
else:
wsgi_server = WSGIServer(bind_addr=("0.0.0.0", self.wsgi_port),
wsgi_app=self.app,
numthreads=100)
try:
wsgi_server.start()
except KeyboardInterrupt:
wsgi_server.stop()
def run(self, handler):
"""
Run server
"""
try:
from cheroot.wsgi import Server as WSGIServer
except ImportError:
from cherrypy.wsgiserver import CherryPyWSGIServer as WSGIServer
global server
# server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server = WSGIServer((self.host, self.port), handler)
# cert = 'server.pem' # certificate path
# server.ssl_certificate = cert
# server.ssl_private_key = cert
try:
server.start()
finally:
server.stop()
def run(self, handler): # pragma: no cover
from cheroot.wsgi import Server as WSGIServer
self.options['bind_addr'] = (self.host, self.port)
self.options['wsgi_app'] = handler
certfile = self.options.get('certfile')
if certfile:
del self.options['certfile']
keyfile = self.options.get('keyfile')
if keyfile:
del self.options['keyfile']
server = WSGIServer(**self.options)
if certfile:
server.ssl_certificate = certfile
if keyfile:
server.ssl_private_key = keyfile
try:
server.start()
finally:
server.stop()
def main():
clear_screen()
print_logo()
with AdbInstaller() as installer:
installer.install()
AdbWrapper().disconnect_all()
success("Açık kalan ADB bağlantıları kapatıldı!")
web.api_key = "Girilmedi!"
success("Sunucu başlatılıyor!")
try:
http_server = WSGIServer(("127.0.0.1", 5000),
PathInfoDispatcher({'/': website_app}))
success("Sunucu başlatıldı!")
success("Arayüz adresi: http://localhost:5000")
http_server.start()
except KeyboardInterrupt:
clear_screen()
success("Kapatılıyor!")
_exit(0)
if sucess_login:
session['logged_in'] = True
logger.info("{ip} successfully looged in".format(ip=ip))
flash('You were successfully logged in!')
else:
logger.warning(
"{ip} attempted to log in with wrong password".format(ip=ip))
flash('wrong password!')
return index()
##################################################
# END API part
##################################################
if __name__ == "__main__":
log_manager = LogManager()
logger = log_manager.logger
logger.info('Running Flask Server on http://localhost:{port}'.format(
port=os.environ.get("SERVER_PORT")))
app.secret_key = os.urandom(12)
server = WSGIServer(('0.0.0.0', int(os.environ.get("SERVER_PORT"))),
app,
numthreads=int(os.environ.get("SERVER_NUM_THREADS")))
try:
server.start()
except KeyboardInterrupt:
logger.critical("KeyboardInterrupt")
def run(self):
self._configure_flask_app()
dispatcher = PathInfoDispatcher({"/": app})
self.server = WSGIServer((self.host, self.port), dispatcher)
self.server.start()
bcrypt = Bcrypt(app)
login = LoginManager()
login.init_app(app)
@app.before_first_request
def init_db():
db.create_all()
import_module('pagermaid.interface.views')
import_module('pagermaid.interface.modals')
dispatcher = PathInfoDispatcher({'/': app})
server = WSGIServer(
(config['web_interface']['host'], int(config['web_interface']['port'])),
dispatcher)
def start():
if strtobool(config['web_interface']['enable']):
logs.info(
f"已经启动Web界面 {config['web_interface']['host']}:{config['web_interface']['port']}"
)
app.logger.removeHandler(default_handler)
app.logger.addHandler(logging_handler)
try:
server.start()
except OSError:
logs.fatal("出错了呜呜呜 ~ 另一个进程绑定到了 PagerMaid 需要的端口！")
return
received_data = request.get_json(force=True)
extracted_df = jsonToCSV(received_data)
# TODO: Change hope feature vector calls to respective function. Uncomment for debugging temporarily
buy = feature_vector_buy(extracted_df, test=True)
communicate = feature_vector_communicate(extracted_df, test=True)
fun = feature_vector_fun(extracted_df, test=True)
hope = feature_vector_hope(extracted_df, test=True)
mother = feature_vector_mother(extracted_df, test=True)
really = feature_vector_really(extracted_df, test=True)
hope = feature_vector_hope(extracted_df, test=True)
feature_vectors = [buy, communicate, fun, hope, mother, really]
results = dict()
for i in range(1, 5):
scores = [0] * 6
for gesture_id in INDEX_TO_GESTURE:
scores[ord(gesture_id) - 65] = get_result_from_model(
i, gesture_id, feature_vectors[ord(gesture_id) - 65])
results[i] = INDEX_TO_GESTURE[chr(ord('A') + np.argmax(scores))]
return jsonify(results)
if __name__ == '__main__':
server = WSGIServer(bind_addr=('127.0.0.1', 9696),
wsgi_app=app,
numthreads=100)
try:
print("Serving on {}".format(server))
server.start()
except KeyboardInterrupt:
server.stop()
HOST = CONFIG.HOST
PORT = CONFIG.PORT
sign_alg = None
digest_alg = None
try:
sign_alg = CONFIG.SIGN_ALG
except AttributeError:
pass
try:
digest_alg = CONFIG.DIGEST_ALG
except AttributeError:
pass
ds.DefaultSignature(sign_alg, digest_alg)
SRV = WSGIServer((HOST, PORT), application)
_https = ""
if CONFIG.HTTPS:
https = "using HTTPS"
# SRV.ssl_adapter = ssl_pyopenssl.pyOpenSSLAdapter(
# config.SERVER_CERT, config.SERVER_KEY, config.CERT_CHAIN)
SRV.ssl_adapter = BuiltinSSLAdapter(CONFIG.SERVER_CERT,
CONFIG.SERVER_KEY,
CONFIG.CERT_CHAIN)
logger.info("Server starting")
print("IDP listening on %s:%s%s" % (HOST, PORT, _https))
try:
SRV.start()
except KeyboardInterrupt: