def update_log_level():
"""Set the log level to log level defined in config."""
from rasax.community.config import log_level
logging.basicConfig(level=log_level)
logging.getLogger("rasax").setLevel(log_level)
packages = ["rasa", "apscheduler"]
for p in packages:
# update log level of package
logging.getLogger(p).setLevel(log_level)
# set propagate to 'False' so that logging messages are not
# passed to the handlers of ancestor loggers.
logging.getLogger(p).propagate = False
from sanic.log import logger, error_logger, access_logger
logger.setLevel(log_level)
error_logger.setLevel(log_level)
access_logger.setLevel(log_level)
logger.propagate = False
error_logger.propagate = False
access_logger.propagate = False
def _setup_logging(server_name: str, log_dir: Path) -> None:
"""
Setup logging for sanic application.
This function must be called before instantiate the Sanic App.
"""
logger.setLevel(INFO)
LOGGING_CONFIG_DEFAULTS['handlers']['root_file'] = {
'class': 'logging.FileHandler',
'formatter': 'generic',
'filename': str(log_dir.joinpath(server_name).joinpath('root.log'))
}
LOGGING_CONFIG_DEFAULTS['handlers']['error_file'] = {
'class': 'logging.FileHandler',
'formatter': 'generic',
'filename': str(log_dir.joinpath(server_name).joinpath('error.log'))
}
LOGGING_CONFIG_DEFAULTS['handlers']['access_file'] = {
'class': 'logging.FileHandler',
'formatter': 'access',
'filename': str(log_dir.joinpath(server_name).joinpath('access.log'))
}
LOGGING_CONFIG_DEFAULTS['loggers']['sanic.root']['handlers'][0] = 'root_file'
LOGGING_CONFIG_DEFAULTS['loggers']['sanic.error']['handlers'][0] = 'error_file'
LOGGING_CONFIG_DEFAULTS['loggers']['sanic.access']['handlers'][0] = 'access_file'
log_dir.joinpath(server_name).mkdir(parents=True, exist_ok=True)
def _create_log_config(log_level, log_dir: Path) -> dict:
"""
Create a logging configuration object for Sanic.
"""
logger.setLevel(log_level)
config: dict = copy(LOGGING_CONFIG_DEFAULTS)
config['handlers']['root_file'] = {
'class': 'logging.FileHandler',
'formatter': 'generic',
'filename': str(log_dir.joinpath('root.log'))
}
config['handlers']['error_file'] = {
'class': 'logging.FileHandler',
'formatter': 'generic',
'filename': str(log_dir.joinpath('error.log'))
}
config['handlers']['access_file'] = {
'class': 'logging.FileHandler',
'formatter': 'access',
'filename': str(log_dir.joinpath('access.log'))
}
config['loggers']['sanic.root']['handlers'][0] = 'root_file'
config['loggers']['sanic.error']['handlers'][0] = 'error_file'
config['loggers']['sanic.access']['handlers'][0] = 'access_file'
log_dir.mkdir(parents=True, exist_ok=True)
return config
def update_sanic_log_level(log_file: Optional[Text] = None):
"""Set the log level of sanic loggers to the log level specified in the environment
variable 'LOG_LEVEL_LIBRARIES'."""
from sanic.log import logger, error_logger, access_logger
log_level = os.environ.get(ENV_LOG_LEVEL_LIBRARIES,
DEFAULT_LOG_LEVEL_LIBRARIES)
logger.setLevel(log_level)
error_logger.setLevel(log_level)
access_logger.setLevel(log_level)
logger.propagate = False
error_logger.propagate = False
access_logger.propagate = False
if log_file is not None:
formatter = logging.Formatter(
"%(asctime)s [%(levelname)-5.5s] %(message)s")
file_handler = logging.FileHandler(log_file)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
error_logger.addHandler(file_handler)
access_logger.addHandler(file_handler)
def setup_logging(log_level: int) -> None:
"""
Setup logging for sanic application.
This function must be called before instantiate the Sanic.
"""
logger.setLevel(log_level)
LOGGING_CONFIG_DEFAULTS['handlers']['root_file'] = {
'class': 'logging.FileHandler',
'formatter': 'generic',
'filename': str(core.LOG_DIR.joinpath('sanic_root.log'))
}
LOGGING_CONFIG_DEFAULTS['handlers']['error_file'] = {
'class': 'logging.FileHandler',
'formatter': 'generic',
'filename': str(core.LOG_DIR.joinpath('sanic_error.log'))
}
LOGGING_CONFIG_DEFAULTS['handlers']['access_file'] = {
'class': 'logging.FileHandler',
'formatter': 'access',
'filename': str(core.LOG_DIR.joinpath('sanic_access.log'))
}
LOGGING_CONFIG_DEFAULTS['loggers']['sanic.root']['handlers'][
0] = 'root_file'
LOGGING_CONFIG_DEFAULTS['loggers']['sanic.error']['handlers'][
0] = 'error_file'
LOGGING_CONFIG_DEFAULTS['loggers']['sanic.access']['handlers'][
0] = 'access_file'
def start(port, pg_host, pg_port, pg_user, pg_password, pg_database, loglevel):
"""Starts the Bounce webserver with the given configuration."""
# Set log level
logger.setLevel(getattr(logging, loglevel.upper()))
conf = ServerConfig(port, pg_host, pg_port, pg_user, pg_password,
pg_database)
# Register your new endpoints here
endpoints = [UsersEndpoint, UserEndpoint]
serv = Server(conf, endpoints)
serv.start()
def setUp(self):
formatter = "[%(asctime)s] %(name)s {%(filename)s:%(lineno)d} %(levelname)s - %(message)s"
#logging.basicConfig(level=logging.DEBUG, format=formatter)
logging.config.dictConfig(LOGGING_CONFIG_DEFAULTS)
logger.setLevel(logging.DEBUG)
app.broker_url = 'mqtt://127.0.0.1:9883/'
app.eventlog = DummyEventLogger()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
def update_sanic_log_level():
"""Set the log level of sanic loggers to the log level specified in the environment
variable 'LOG_LEVEL'."""
log_level = os.environ.get(ENV_LOG_LEVEL, DEFAULT_LOG_LEVEL)
from sanic.log import logger, error_logger, access_logger
logger.setLevel(log_level)
error_logger.setLevel(log_level)
access_logger.setLevel(log_level)
def update_sanic_log_level():
"""Set the log level of sanic loggers to the log level specified in the environment
variable 'LOG_LEVEL_LIBRARIES'."""
from sanic.log import logger, error_logger, access_logger
log_level = os.environ.get(ENV_LOG_LEVEL_LIBRARIES, DEFAULT_LOG_LEVEL_LIBRARIES)
logger.setLevel(log_level)
error_logger.setLevel(log_level)
access_logger.setLevel(log_level)
logger.propagate = False
error_logger.propagate = False
access_logger.propagate = False
def start(port, secret, pg_host, pg_port, pg_user, pg_password, pg_database,
allowed_origin, image_dir, loglevel):
"""Starts the Bounce webserver with the given configuration."""
# Set log level
logger.setLevel(getattr(logging, loglevel.upper()))
conf = ServerConfig(port, secret, pg_host, pg_port, pg_user, pg_password,
pg_database, allowed_origin, image_dir)
# Register your new endpoints here
endpoints = [
UsersEndpoint, UserEndpoint, UserImagesEndpoint, ClubsEndpoint,
ClubEndpoint, ClubImagesEndpoint, SearchClubsEndpoint,
SearchUsersEndpoint, LoginEndpoint, MembershipEndpoint
]
serv = Server(conf, endpoints)
serv.start()
def update_sanic_log_level() -> None:
"""Set the log level of sanic loggers.
Use the environment variable 'LOG_LEVEL_LIBRARIES', or default to
`DEFAULT_LOG_LEVEL_LIBRARIES` if undefined.
"""
from sanic.log import logger, error_logger, access_logger
log_level = os.environ.get(ENV_LOG_LEVEL_LIBRARIES, DEFAULT_LOG_LEVEL_LIBRARIES)
logger.setLevel(log_level)
error_logger.setLevel(log_level)
access_logger.setLevel(log_level)
logger.propagate = False
error_logger.propagate = False
access_logger.propagate = False
def update_sanic_log_level(
log_file: Optional[Text] = None,
use_syslog: Optional[bool] = False,
syslog_address: Optional[Text] = None,
syslog_port: Optional[int] = None,
syslog_protocol: Optional[Text] = None,
) -> None:
"""Set the log level to 'LOG_LEVEL_LIBRARIES' environment variable ."""
from sanic.log import logger, error_logger, access_logger
log_level = os.environ.get(ENV_LOG_LEVEL_LIBRARIES,
DEFAULT_LOG_LEVEL_LIBRARIES)
logger.setLevel(log_level)
error_logger.setLevel(log_level)
access_logger.setLevel(log_level)
logger.propagate = False
error_logger.propagate = False
access_logger.propagate = False
if log_file is not None:
formatter = logging.Formatter(
"%(asctime)s [%(levelname)-5.5s] %(message)s")
file_handler = logging.FileHandler(log_file)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
error_logger.addHandler(file_handler)
access_logger.addHandler(file_handler)
if use_syslog:
formatter = logging.Formatter(
"%(asctime)s [%(levelname)-5.5s] [%(process)d]"
" %(message)s")
socktype = SOCK_STREAM if syslog_protocol == TCP_PROTOCOL else SOCK_DGRAM
syslog_handler = logging.handlers.SysLogHandler(
address=(syslog_address, syslog_port),
socktype=socktype,
)
syslog_handler.setFormatter(formatter)
logger.addHandler(syslog_handler)
error_logger.addHandler(syslog_handler)
access_logger.addHandler(syslog_handler)
__author__ = "Ryan LaTorre"
__email__ = "*****@*****.**"
__copyright__ = "Copyright (c) 2020 Cisco and/or its affiliates"
__license__ = "Cisco Sample Code License"
app = Sanic("meraki-csrv")
auth = HTTPBasicAuth()
# The root logger
#logging.getLogger().setLevel(logging.INFO)
logging.getLogger().setLevel(logging.DEBUG)
# The Meraki logger is very talkative, set it to ERROR only
logging.getLogger('meraki').setLevel(logging.ERROR)
#logger.setLevel(logging.INFO)
logger.setLevel(logging.DEBUG)
class MerakiConfig:
def __init__(self, config):
self.api_key = config['meraki_api_key']
def provision_client(network_id: str, mac: str, username: str, mapped_group: str):
clients = [{'mac': mac, 'name': username}]
device_policy = 'Group policy'
dashboard = meraki.DashboardAPI(meraki_config.api_key, output_log=False, print_console=False)
return dashboard.networks.provisionNetworkClients(network_id,
clients,
device_policy,
groupPolicyId=str(mapped_group))
# used for HTTP auth
def set_mode(self, value: Union[str, Mode]):
if hasattr(self.app, "error_handler"):
self.app.error_handler.debug = self.app.debug
if getattr(self.app, "configure_logging", False) and self.app.debug:
logger.setLevel(logging.DEBUG)
def _helper(
self,
host=None,
port=None,
debug=False,
ssl=None,
sock=None,
workers=1,
loop=None,
protocol=HttpProtocol,
backlog=100,
stop_event=None,
register_sys_signals=True,
run_async=False,
auto_reload=False,
):
"""Helper function used by `run` and `create_server`."""
if isinstance(ssl, dict):
# try common aliaseses
cert = ssl.get("cert") or ssl.get("certificate")
key = ssl.get("key") or ssl.get("keyfile")
if cert is None or key is None:
raise ValueError("SSLContext or certificate and key required.")
context = create_default_context(purpose=Purpose.CLIENT_AUTH)
context.load_cert_chain(cert, keyfile=key)
ssl = context
if stop_event is not None:
if debug:
warnings.simplefilter("default")
warnings.warn(
"stop_event will be removed from future versions.",
DeprecationWarning,
)
self.error_handler.debug = debug
self.debug = debug
server_settings = {
"protocol": protocol,
"request_class": self.request_class,
"is_request_stream": self.is_request_stream,
"router": self.router,
"host": host,
"port": port,
"sock": sock,
"ssl": ssl,
"signal": Signal(),
"debug": debug,
"request_handler": self.handle_request,
"error_handler": self.error_handler,
"request_timeout": self.config.REQUEST_TIMEOUT,
"response_timeout": self.config.RESPONSE_TIMEOUT,
"keep_alive_timeout": self.config.KEEP_ALIVE_TIMEOUT,
"request_max_size": self.config.REQUEST_MAX_SIZE,
"request_buffer_queue_size": self.config.REQUEST_BUFFER_QUEUE_SIZE,
"keep_alive": self.config.KEEP_ALIVE,
"loop": loop,
"register_sys_signals": register_sys_signals,
"backlog": backlog,
"access_log": self.config.ACCESS_LOG,
"websocket_max_size": self.config.WEBSOCKET_MAX_SIZE,
"websocket_max_queue": self.config.WEBSOCKET_MAX_QUEUE,
"websocket_read_limit": self.config.WEBSOCKET_READ_LIMIT,
"websocket_write_limit": self.config.WEBSOCKET_WRITE_LIMIT,
"graceful_shutdown_timeout": self.config.GRACEFUL_SHUTDOWN_TIMEOUT,
}
# -------------------------------------------- #
# Register start/stop events
# -------------------------------------------- #
for event_name, settings_name, reverse in (
("before_server_start", "before_start", False),
("after_server_start", "after_start", False),
("before_server_stop", "before_stop", True),
("after_server_stop", "after_stop", True),
):
listeners = self.listeners[event_name].copy()
if reverse:
listeners.reverse()
# Prepend sanic to the arguments when listeners are triggered
listeners = [partial(listener, self) for listener in listeners]
server_settings[settings_name] = listeners
if self.configure_logging and debug:
logger.setLevel(logging.DEBUG)
if (self.config.LOGO
and os.environ.get("SANIC_SERVER_RUNNING") != "true"):
logger.debug(self.config.LOGO if isinstance(self.config.LOGO, str
) else BASE_LOGO)
if run_async:
server_settings["run_async"] = True
# Serve
if host and port and os.environ.get("SANIC_SERVER_RUNNING") != "true":
proto = "http"
if ssl is not None:
proto = "https"
logger.info("Goin' Fast @ {}://{}:{}".format(proto, host, port))
return server_settings
def _helper(self,
host=None,
port=None,
debug=False,
ssl=None,
sock=None,
workers=1,
loop=None,
protocol=HttpProtocol,
backlog=100,
stop_event=None,
register_sys_signals=True,
run_async=False,
access_log=True):
"""Helper function used by `run` and `create_server`."""
if isinstance(ssl, dict):
# try common aliaseses
cert = ssl.get('cert') or ssl.get('certificate')
key = ssl.get('key') or ssl.get('keyfile')
if cert is None or key is None:
raise ValueError("SSLContext or certificate and key required.")
context = create_default_context(purpose=Purpose.CLIENT_AUTH)
context.load_cert_chain(cert, keyfile=key)
ssl = context
if stop_event is not None:
if debug:
warnings.simplefilter('default')
warnings.warn("stop_event will be removed from future versions.",
DeprecationWarning)
self.error_handler.debug = debug
self.debug = debug
server_settings = {
'protocol': protocol,
'request_class': self.request_class,
'is_request_stream': self.is_request_stream,
'router': self.router,
'host': host,
'port': port,
'sock': sock,
'ssl': ssl,
'signal': Signal(),
'debug': debug,
'request_handler': self.handle_request,
'error_handler': self.error_handler,
'request_timeout': self.config.REQUEST_TIMEOUT,
'response_timeout': self.config.RESPONSE_TIMEOUT,
'keep_alive_timeout': self.config.KEEP_ALIVE_TIMEOUT,
'request_max_size': self.config.REQUEST_MAX_SIZE,
'keep_alive': self.config.KEEP_ALIVE,
'loop': loop,
'register_sys_signals': register_sys_signals,
'backlog': backlog,
'access_log': access_log,
'websocket_max_size': self.config.WEBSOCKET_MAX_SIZE,
'websocket_max_queue': self.config.WEBSOCKET_MAX_QUEUE,
'graceful_shutdown_timeout': self.config.GRACEFUL_SHUTDOWN_TIMEOUT
}
# -------------------------------------------- #
# Register start/stop events
# -------------------------------------------- #
for event_name, settings_name, reverse in (
("before_server_start", "before_start", False),
("after_server_start", "after_start", False),
("before_server_stop", "before_stop", True),
("after_server_stop", "after_stop", True),
):
listeners = self.listeners[event_name].copy()
if reverse:
listeners.reverse()
# Prepend sanic to the arguments when listeners are triggered
listeners = [partial(listener, self) for listener in listeners]
server_settings[settings_name] = listeners
if self.configure_logging and debug:
logger.setLevel(logging.DEBUG)
if self.config.LOGO is not None:
logger.debug(self.config.LOGO)
if run_async:
server_settings['run_async'] = True
# Serve
if host and port:
proto = "http"
if ssl is not None:
proto = "https"
logger.info('Goin\' Fast @ {}://{}:{}'.format(proto, host, port))
return server_settings
async def _init_redis_async(_, loop):
logger.setLevel(logging.DEBUG)
global redis
url = "redis://{0}:{1}".format(*REDIS_SERVER)
redis = aioredis.from_url(url, encoding="utf-8")
from binancespottrader import create_app
from os import environ
from sanic.log import logger
APP_HOST = environ.get('APP_HOST')
APP_PORT = environ.get('APP_PORT')
APP_DEBUG = True if environ.get('APP_DEBUG') == '1' else False
if __name__ == '__main__':
app = create_app()
if APP_DEBUG:
logger.setLevel(level=10)
app.run(debug=APP_DEBUG,
host=APP_HOST,
port=APP_PORT)
import ujson
from os import environ
from sanic import Sanic
from sanic.log import logger
from sanic.request import Request
from sanic.response import HTTPResponse, text
from goingfast.traders.base import Actions, BaseTrader
from goingfast.traders.bybit import BybitTrader
from goingfast.traders.bitmex import BitmexTrader
from goingfast.notifications.telegram import send_telegram_message
APP_DEBUG = True if environ.get('APP_DEBUG') == '1' else False
log_level = logging.DEBUG if APP_DEBUG else logging.INFO
logger.setLevel(level=log_level)
TRADER = environ.get('TRADER')
CAPITAL_IN_USD = int(environ.get('CAPITAL_IN_USD'))
def is_valid_message(message: dict) -> bool:
check = map(lambda x: x in message,
['close', 'indicator', 'exchange', 'pair', 'action'])
return not (False in check)
def ok_response():
return text('ok')
sendtodc(c, channel_id=738943877699993631)
#dlh=discordlogginghandler()
#rootlogger=logging.getLogger()
#rootlogger.addHandler(dlh)
dlh = discordlogginghandler()
#dlh.setFormatter(logging.Formatter('%(asctime)s - (%(name)s)[%(levelname)s][%(host)s]: %(request)s %(message)s %(status)d %(byte)d'))
#logging.getLogger('sanic.root').addHandler(dlh)
#logging.getLogger('sanic.error').addHandler(dlh)
#logging.getLogger('sanic.access').addHandler(dlh)
if saniclogger.handlers:
for i in saniclogger.handlers:
saniclogger.removeHandler(i)
dlh.setLevel(10)
saniclogger.setLevel(10)
saniclogger.addHandler(dlh)
def render_html(file_, **kwargs) -> str:
template = jinja2env.get_template(file_)
return res.html(template.render(**kwargs))
def replaceurl(s):
url_list = re.findall(url_pattern, s)
if not url_list:
return s
for i in url_list:
s = s.replace(i, f'<a href="{i}">{i}</a>', 1)
return s
default=".*",
help='Regular expression used to filter meeting rooms.')
parser.add_argument('-i',
'--update-interval-seconds',
type=int,
default=0,
help='Update interval in seconds.')
parser.add_argument('-d',
'--debug',
action='store_true',
default=False,
help='Enable debug logging.')
args = parser.parse_args()
if args.debug:
sanic_logger.setLevel(logging.DEBUG)
sanic_logger.info("Starting exchange-meeting-room-exporter...")
collector = ExchangeMeetingRoomCollector(
logger=sanic_logger,
server=args.exchange_server,
username=args.username,
password=args.password_file.read().strip(),
room_name_regex=args.room_name_regex,
room_list_regex=args.room_list_regex,
update_interval_seconds=args.update_interval_seconds,
)
REGISTRY.register(collector)
if collector.use_cache:
app.add_task(collector.start_cache_update)
# @Email : [email protected] # @Software : PyCharm # @Description : import sys import socket # socket.SO_REUSEPORT = 15 from collections import OrderedDict from traceback import format_exc # https://www.cnblogs.com/klchang/p/4635040.html from sanic import Sanic, response import multiprocessing import logging from sanic.log import logger gunicorn_logger = logging.getLogger('gunicorn.error') logger.handlers = gunicorn_logger.handlers logger.setLevel(gunicorn_logger.level) class App(object): def __init__(self, debug=False, verbose=False, **kwargs): self.app = Sanic("SanicApp") # SanicScheduler(self.app, False) self.debug = True if socket.gethostname( ) == 'yuanjie-Mac.local' else debug self.verbose = verbose # Request Params def run(self, host="0.0.0.0", port=8000, access_log=False, workers=1,
from . import utils
# Signing can take a loooong time, so set a more reasonable
# default response timeout
class CodesignSanicDefaults:
RESPONSE_TIMEOUT = 180
L4T_TOOLS_BASE = '/opt/nvidia'
KEYFILE_URI = 'file:///please/configure/this/path'
LOG_LEVEL = 'INFO'
app = Sanic(name='digsigserver', load_env=False)
app.config.from_object(CodesignSanicDefaults)
app.config.load_environment_vars(prefix='DIGSIGSERVER_')
logger.setLevel(app.config.get("LOG_LEVEL"))
def config_get(item: str, default_value=None) -> str:
return app.config.get(item, default_value)
def validate_upload(req: request, name: str) -> request.File:
f = req.files.get(name)
return f if f and f.type == "application/octet-stream" else None
def parse_manifest(manifest_file: str) -> dict:
result = {}
if not os.path.exists(manifest_file):
return result
from sanic import Blueprint, Sanic
from sanic.response import json as json_response
from sanic.response import html, redirect, file_stream
from sanic.exceptions import NotFound
from sanic_session import Session, InMemorySessionInterface
from jinja2 import Environment, PackageLoader
app = Sanic(__name__)
app.static('/static', './server/static')
from sanic.log import logger
logger.setLevel(logging.WARN)
session = Session(app, interface=InMemorySessionInterface())
# we a very simple way for auth
app.token = uuid.uuid4().hex
jinja_env = Environment(loader=PackageLoader('server', 'server/templates'))
from mm_bot.config import config
from mm_bot.config.validator import REQUIRED_PARAMS, STRATEGY_NAME_KEY
from mm_bot.helpers import get_config_path, signal_config_reloaded, LOGS_FILE_PATTERN
from mm_bot.model.repository import OrderRepository
url = config('database_url', parser=str)
def disableLog(self):
logger.setLevel(logging.WARNING)
def _helper(self, host=None, port=None, debug=False,
ssl=None, sock=None, workers=1, loop=None,
protocol=HttpProtocol, backlog=100, stop_event=None,
register_sys_signals=True, run_async=False, access_log=True):
"""Helper function used by `run` and `create_server`."""
if isinstance(ssl, dict):
# try common aliaseses
cert = ssl.get('cert') or ssl.get('certificate')
key = ssl.get('key') or ssl.get('keyfile')
if cert is None or key is None:
raise ValueError("SSLContext or certificate and key required.")
context = create_default_context(purpose=Purpose.CLIENT_AUTH)
context.load_cert_chain(cert, keyfile=key)
ssl = context
if stop_event is not None:
if debug:
warnings.simplefilter('default')
warnings.warn("stop_event will be removed from future versions.",
DeprecationWarning)
self.error_handler.debug = debug
self.debug = debug
server_settings = {
'protocol': protocol,
'request_class': self.request_class,
'is_request_stream': self.is_request_stream,
'router': self.router,
'host': host,
'port': port,
'sock': sock,
'ssl': ssl,
'signal': Signal(),
'debug': debug,
'request_handler': self.handle_request,
'error_handler': self.error_handler,
'request_timeout': self.config.REQUEST_TIMEOUT,
'response_timeout': self.config.RESPONSE_TIMEOUT,
'keep_alive_timeout': self.config.KEEP_ALIVE_TIMEOUT,
'request_max_size': self.config.REQUEST_MAX_SIZE,
'keep_alive': self.config.KEEP_ALIVE,
'loop': loop,
'register_sys_signals': register_sys_signals,
'backlog': backlog,
'access_log': access_log,
'websocket_max_size': self.config.WEBSOCKET_MAX_SIZE,
'websocket_max_queue': self.config.WEBSOCKET_MAX_QUEUE,
'graceful_shutdown_timeout': self.config.GRACEFUL_SHUTDOWN_TIMEOUT
}
# -------------------------------------------- #
# Register start/stop events
# -------------------------------------------- #
for event_name, settings_name, reverse in (
("before_server_start", "before_start", False),
("after_server_start", "after_start", False),
("before_server_stop", "before_stop", True),
("after_server_stop", "after_stop", True),
):
listeners = self.listeners[event_name].copy()
if reverse:
listeners.reverse()
# Prepend sanic to the arguments when listeners are triggered
listeners = [partial(listener, self) for listener in listeners]
server_settings[settings_name] = listeners
if self.configure_logging and debug:
logger.setLevel(logging.DEBUG)
if self.config.LOGO is not None:
logger.debug(self.config.LOGO)
if run_async:
server_settings['run_async'] = True
# Serve
if host and port:
proto = "http"
if ssl is not None:
proto = "https"
logger.info('Goin\' Fast @ {}://{}:{}'.format(proto, host, port))
return server_settings
@app.route("/")
async def get_idioms(request):
if 'query' not in request.args:
return HTTPResponse(status=400, body='invalid query')
query = ''.join(request.args['query'])
if len(query) > 15:
return HTTPResponse(status=400, body='query too long')
try:
res = await scraper.scrape_idioms(query)
return json([{
'idiom': r[0],
'score': r[1]
} for r in res],
ensure_ascii=False)
except Exception as e:
logger.exception(e)
return HTTPResponse(status=503)
@app.route('/health')
async def health_check(request):
return json({'status': 'success'})
if __name__ == "__main__":
logger.setLevel(os.getenv('SANIC_LOGGING_LEVEL', 'INFO'))
app.add_task(init)
app.run(host="0.0.0.0", access_log=False)
def _helper(
self,
host=None,
port=None,
debug=False,
ssl=None,
sock=None,
unix=None,
workers=1,
loop=None,
protocol=HttpProtocol,
backlog=100,
register_sys_signals=True,
run_async=False,
auto_reload=False,
):
"""Helper function used by `run` and `create_server`."""
if isinstance(ssl, dict):
# try common aliaseses
cert = ssl.get("cert") or ssl.get("certificate")
key = ssl.get("key") or ssl.get("keyfile")
if cert is None or key is None:
raise ValueError("SSLContext or certificate and key required.")
context = create_default_context(purpose=Purpose.CLIENT_AUTH)
context.load_cert_chain(cert, keyfile=key)
ssl = context
if self.config.PROXIES_COUNT and self.config.PROXIES_COUNT < 0:
raise ValueError(
"PROXIES_COUNT cannot be negative. "
"https://sanic.readthedocs.io/en/latest/sanic/config.html"
"#proxy-configuration")
self.error_handler.debug = debug
self.debug = debug
server_settings = {
"protocol": protocol,
"host": host,
"port": port,
"sock": sock,
"unix": unix,
"ssl": ssl,
"app": self,
"signal": Signal(),
"loop": loop,
"register_sys_signals": register_sys_signals,
"backlog": backlog,
}
# -------------------------------------------- #
# Register start/stop events
# -------------------------------------------- #
for event_name, settings_name, reverse in (
("before_server_start", "before_start", False),
("after_server_start", "after_start", False),
("before_server_stop", "before_stop", True),
("after_server_stop", "after_stop", True),
):
listeners = self.listeners[event_name].copy()
if reverse:
listeners.reverse()
# Prepend sanic to the arguments when listeners are triggered
listeners = [partial(listener, self) for listener in listeners]
server_settings[settings_name] = listeners
if self.configure_logging and debug:
logger.setLevel(logging.DEBUG)
if (self.config.LOGO
and os.environ.get("SANIC_SERVER_RUNNING") != "true"):
logger.debug(self.config.LOGO if isinstance(self.config.LOGO, str
) else BASE_LOGO)
if run_async:
server_settings["run_async"] = True
# Serve
if host and port:
proto = "http"
if ssl is not None:
proto = "https"
if unix:
logger.info(f"Goin' Fast @ {unix} {proto}://...")
else:
logger.info(f"Goin' Fast @ {proto}://{host}:{port}")
return server_settings
import os
import logging
from sanic import Sanic, response
from sanic.log import logger
from sanic.request import Request
from sanic.response import HTTPResponse
from sanic.exceptions import NotFound, MethodNotSupported
app = Sanic(name="test server")
logger.setLevel(logging.WARNING)
@app.route("/endpoints")
async def endpoints(request: Request) -> HTTPResponse:
rules = sorted(elem[0] for elem in app.router.routes_names.values())
return response.text("\n".join(rules))
@app.route("/basic")
async def basic(request: Request) -> HTTPResponse:
return response.text("Hello, World!")
@app.route("/headers-test")
async def headers_test(request: Request) -> HTTPResponse:
return response.text("HeadersTest",
headers={
"x-test-1": "foo",
"OTHER-TEST": "bar"
})
