def configure_cors(app: Sanic, cors_origins: Union[Text, List[Text]] = "") -> None:
"""Configure CORS origins for the given app."""
# Workaround so that socketio works with requests from other origins.
# https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183
app.config.CORS_AUTOMATIC_OPTIONS = True
app.config.CORS_SUPPORTS_CREDENTIALS = True
CORS(app, resources={r"/*": {"origins": cors_origins}}, automatic_options=True)
def configure_cors(app: Sanic,
cors_origins: Union[Text, List[Text], None] = "") -> None:
"""Configure CORS origins for the given app."""
CORS(app,
resources={r"/*": {
"origins": cors_origins or ""
}},
automatic_options=True)
def __init__(self):
self.app = Sanic()
CORS(self.app)
self.document = Document()
self.app.add_route(self.verify, '/verify', methods=['GET'])
self.app.add_route(self.publish, '/publish', methods=['POST'])
self.app.add_route(self.details, '/details', methods=['GET'])
def configure_app(
input_channels=None,
cors=None,
auth_token=None,
enable_api=True,
jwt_secret=None,
jwt_method=None,
route="/webhooks/",
port=None,
):
"""Run the agent."""
from rasa.core import server
if enable_api:
app = server.create_app(
cors_origins=cors,
auth_token=auth_token,
jwt_secret=jwt_secret,
jwt_method=jwt_method,
)
else:
app = Sanic(__name__)
CORS(app,
resources={r"/*": {
"origins": cors or ""
}},
automatic_options=True)
if input_channels:
rasa.core.channels.channel.register(input_channels, app, route=route)
else:
input_channels = []
if logger.isEnabledFor(logging.DEBUG):
utils.list_routes(app)
# configure async loop logging
async def configure_logging():
if logger.isEnabledFor(logging.DEBUG):
rasa.utils.io.enable_async_loop_debugging(asyncio.get_event_loop())
app.add_task(configure_logging)
if "cmdline" in {c.name() for c in input_channels}:
async def run_cmdline_io(running_app: Sanic):
"""Small wrapper to shut down the server once cmd io is done."""
await asyncio.sleep(1) # allow server to start
await console.record_messages(
server_url=constants.DEFAULT_SERVER_FORMAT.format(port))
logger.info("Killing Sanic server now.")
running_app.stop() # kill the sanic serverx
app.add_task(run_cmdline_io)
return app
def create_app():
app = Sanic(__name__)
CORS(app, resources={r"/api/*": {"origins": "*"}})
from .controllers import api_blueprint
app.register_blueprint(api_blueprint)
return app
def create_app() -> Sanic:
error_handler = CustomHandler()
app: Sanic = Sanic(name="stock", error_handler=error_handler)
app.config.from_object(settings) # 导入 Sanic 配置
configure_blueprints(app) # 配置蓝图
configure_listeners(app) # 配置监听：redis
configure_middlewares(app) # 配置中间件
configure_exception_handlers(app) # 配置异常处理Handler
CORS(app, automatic_options=True)
return app
def create_app() -> Sanic:
error_handler = CustomHandler()
app: Sanic = Sanic(error_handler=error_handler)
app.config.PROXIES_COUNT = settings.PROXIES_COUNT
configure_blueprints(app)
configure_listeners(app)
configure_middlewares(app)
configure_exception_handlers(app)
CORS(app, automatic_options=True)
return app
def _setup_application(self, app: Sanic, config: Config) -> None:
cors_config = config["cors"]
if cors_config:
cors_params = cors_config if isinstance(cors_config, dict) else {}
CORS(app, **cors_params)
bp = Blueprint(f"idom_renderer_{id(self)}",
url_prefix=config["url_prefix"])
self._setup_blueprint_routes(bp, config)
app.blueprint(bp)
def run(host, port):
path = os.path.join(os.getcwd(), 'tmp/')
if not os.path.exists(path):
os.mkdir(path)
global app
app = Sanic()
CORS(app)
app.add_route(index, '/', methods=['GET'])
stage_add_route(app)
app.run(host=host, port=port)
def create_app(config):
"""
Set blueprint for app sanic
:param config: config decouple
:return: app sanic
"""
app = Sanic(__name__)
app.config.from_object(config)
app.blueprint(bp_products)
CORS(app, automatic_options=True)
return app
def __init__(self, project=None, production=False):
self.project = project or load_project()
self.project.prepare()
self.production = production
self.port = 80 if production else 8000
self.sanic_app = Sanic()
CORS(self.sanic_app, automatic_options=True)
self.sanic_app.add_route(self.index, '/', methods=['GET'])
self.sanic_app.add_route(
self.index,
'/<path:path>',
methods=['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTION'])
def init_app(config=None):
app = Sanic(__name__)
app.config.update(config or {})
app.db = functools.partial(
_get_db,
host=app.config.get('MONGO_HOST'),
port=app.config.get('MONGO_PORT'),
user=app.config.get('MONGO_USER'),
passwd=app.config.get('MONGO_PASSWD'),
db_name=app.config.get('MONGO_DB_NAME'),
)
CORS(app)
return app
def __app_setup():
global app
app = Sanic(__name__)
CORS(app)
@app.route("/", methods=["POST"])
async def index(request: Request):
return await tunnel(request.json)
@app.route("/", methods=["GET"])
async def index_get(request: Request):
return response.json({"Ecency": "Aspire to greatness", "jussi_num": -1, "status": "OK"})
def main():
"""RBAC API server main event loop"""
app = Sanic(__name__)
app.blueprint(AUTH_BP)
app.blueprint(BLOCKS_BP)
app.blueprint(CHATBOT_BP)
app.blueprint(ERRORS_BP)
app.blueprint(FEED_BP)
app.blueprint(PACKS_BP)
app.blueprint(PROPOSALS_BP)
app.blueprint(ROLES_BP)
app.blueprint(SEARCH_BP)
app.blueprint(SWAGGER_BP)
app.blueprint(TASKS_BP)
app.blueprint(USERS_BP)
app.blueprint(WEBHOOKS_BP)
app.blueprint(APP_BP)
load_config(app)
CORS(
app,
automatic_options=True,
supports_credentials=True,
resources={
r"/api/*": {
"origins": "*"
},
r"/webhooks/*": {
"origins": "*"
}
},
)
zmq = ZMQEventLoop()
asyncio.set_event_loop(zmq)
server = app.create_server(host="0.0.0.0",
port=app.config.PORT,
debug=False,
access_log=False)
loop = asyncio.get_event_loop()
asyncio.ensure_future(server)
asyncio.ensure_future(init(app, loop))
signal(SIGINT, lambda s, f: loop.close())
try:
loop.run_forever()
except KeyboardInterrupt:
finish(app)
loop.stop()
def __init__(self, config=None):
self.slave_registry = {}
self.config = config or self._load_config_from_cli()
self.master_host = self.config[
'MASTER_HOST'] or self.DEFAULT_MASTER_HOST
self.master_port = self.config[
'MASTER_PORT'] or self.DEFAULT_MASTER_PORT
self.http_port = self.config[
'MASTER_HTTP_PORT'] or self.DEFAULT_HTTP_PORT
self.http_server = Sanic(__name__)
CORS(self.http_server)
self.create_http_app()
def configure_cors(app: Sanic,
cors_origins: Union[Text, List[Text], None] = "") -> None:
"""
解决跨域问题
:param app:
:param cors_origins:
:return:
"""
CORS(app,
resources={r"/*": {
"origins": cors_origins or ""
}},
automatic_options=True)
def configure_extensions(sanic_app):
"""
Register All of Extensions
:param sanic_app: sanic app
:return:
"""
for extension in core.__all__:
obj = getattr(core, extension)
if hasattr(obj, 'init_app'):
obj.init_app(sanic_app)
# cors
if sanic_app.config.get('ENABLE_CORS'):
CORS(sanic_app)
def create_app(env):
app = Sanic("auth-center")
app.config.from_object(env)
CORS(app, automatic_options=True)
Redis(app)
orm = AioOrm(app)
orm.init_proxys(defaultdb=db)
orm.create_tables(User=[{
"_id": uuid.uuid4(),
"username": "******",
"password": '******',
"main_email": "*****@*****.**",
"ctime": datetime.datetime.now()
}],
Role=[{
"service_name": app.name
}, {
"service_name": "msg_reverse_indexing"
}])
app.serializer = URLSafeTimedSerializer(app.config['SECRET_KEY'],
salt=app.config['SALT'])
app.blueprint(api, url_prefix='/api')
app.blueprint(auth, url_prefix='/auth')
app.blueprint(captcha, url_prefix='/captcha')
@app.listener('after_server_start')
async def creat_relationship(app, loop):
realtionship_table = AioOrm._regist_classes['UserRoleThrough']
if (await realtionship_table.select().count()) == 0:
user = await User.get(User.username == "admin")
roles = await Role.select()
for role in roles:
await user.roles.add(role)
@app.listener('after_server_start')
async def creat_zmq_client(app, loop):
#zmq.asyncio.install()
context = zmq.asyncio.Context()
socket = context.socket(zmq.REQ)
print("Connecting to server...")
socket.connect(app.config["ZMQ_URLS"]['captcha-gene'])
app.ZMQ_Sockets = {}
app.ZMQ_Sockets["captcha-gene"] = socket
@app.get("/ping")
async def ping(request):
return json({"message": "pong"})
return app
def create_app(settings):
app = Sanic(__name__, log_config=settings['LOGGING_CONFIG_FILE_HANDLER'])
CORS(app, automatic_options=True)
app.config.update(**settings)
app.config.update({'LOGO': None})
app.blueprint(bp_dog)
from app.receiver import on_message_common, on_ad_message
from app.temp_receiver import temp_ad_on_message_commom
@app.listener('before_server_start')
async def before_server_start(_app, _loop):
_app.db = await db.init_app(_loop, _app.config['DATABASES'])
_app.redis = redis.init_app(_loop, _app.config['REDIS'])
_app.client_session = csa.init_session(loop=_loop)
# gbot mq connect
_app.mq = await sanic_mq.init_app(_loop, _app.config['MQ_CONFIG'])
await sanic_mq.channel()
await sanic_mq.exchange('gemii.gbot.topic')
await sanic_mq.bind_async_receiver('queue.bot.common.dog',
'queue.bot.common.dog',
on_message_common)
await sanic_mq.bind_async_receiver('queue.bot.common.temp_ad',
'queue.bot.common.temp_ad',
temp_ad_on_message_commom)
# gdog mq connect
_app.inner_mq = await inner_mq.init_app(_loop,
_app.config['INNER_MQ_CONFIG'])
await inner_mq.channel()
await inner_mq.exchange('gemii.gdog.topic')
await inner_mq.bind_async_receiver('queue.rs.msg_class',
'queue.rs.msg_class', on_ad_message)
@app.listener('after_server_stop')
async def after_server_stop(_app, _loop):
await _app.client_session.close()
await _app.db.close()
_app.redis.connection_pool.disconnect()
await sanic_mq.disconnection()
Initialize(app,
authentication_class=CustomAuthentication,
responses_class=CustomerResponses,
refresh_token_enabled=False,
secret=settings['JWT_SECRET'],
expiration_delta=1 * 60 * 60)
return app
async def init_app():
# 初始化服务进程
init_pid_name()
app = Application.current()
from sanic_cors import CORS
# 跨域处理
CORS(app, automatic_options=True)
from kervice.app.config import init_config
init_config()
from kervice.utils.redis_util import init_redis
init_redis()
from kervice.app.urls import init_url
init_url()
from kervice.utils.log_util import KLog
from kervice.bussiness.log import log_callback
KLog(callback=log_callback).init_log()
# 把服务添加到redis
app.url = "{}:{}".format(get_host_ip(), app.port)
st, _ = await app.redis.execute("sadd", "{}.urls".format(app.name),
app.url)
assert st != 0
await pp("info:\n 注册服务{} ok".format(app.url), yellow, print)
# 检查服务状态，检查配置更改，检查队列
asyncio.run_coroutine_threadsafe(service_check(), asyncio.get_event_loop())
asyncio.run_coroutine_threadsafe(service_handler(),
asyncio.get_event_loop())
# 处理服务退出后的问题
from signal import signal, SIGTERM, SIGINT, SIGQUIT
_func = lambda sig, stack_frame: asyncio.ensure_future(
close_service(sig, stack_frame))
signal(SIGTERM, _func)
signal(SIGINT, _func)
signal(SIGQUIT, _func)
@app.middleware('response')
async def custom_banner(request, response):
response.headers["content-type"] = "application/json"
def start_server():
app = get_app()
config = app.config
set_logging(config)
inject_endpoints(app=app, config=config)
inject_exceptions_responses(app=app, config=config)
CORS(app, resources={r"/api/*": {"origins": "*"}})
*host, port = app.config.BACKEND_URL.split(":")
app.run(
host="".join(host),
port=int(port),
workers=config.WORKER_COUNT,
debug=config.SANIC_DEBUG,
)
def create_app():
app = Sanic(__name__, request_class=Request)
app.config.from_object(config)
auth.setup(app)
CORS(app, automatic_options=True)
register_blueprints('app.views', app)
@app.listener('before_server_start')
async def server_init(app, loop):
app.db = await db_setup()
app.redis = await aioredis.create_redis_pool(app.config['REDIS_URL'])
session.init_app(app=app,
interface=AIORedisSessionInterface(app.redis))
return app
def setup_routes(app):
app.add_route(UserView.as_view(), '/api/v1.0/users')
app.add_route(ProjectView.as_view(), '/api/v1.0/projects')
app.add_route(RecordView.as_view(),
'/api/v1.0/records',
methods=['GET', 'POST', 'OPTIONS'])
app.add_route(healthView, '/api/v1.0/version', methods=[
'GET',
])
# app.router.add_static('/static/', path='../static', name='static')
CORS(app, resources={
r"/*": {
"origins": "*"
},
}, automatic_options=True)
return app
def get_app(session):
Config.REQUEST_TIMEOUT = 9999999999
app = Sanic()
person = PersonBP(session)
school = SchoolBP(session)
student = StudentBP(session)
diary = DiaryBP(session)
classes = ClassesBP(session)
app.blueprint(person.blueprint)
app.blueprint(school.blueprint)
app.blueprint(student.blueprint)
app.blueprint(diary.blueprint)
app.blueprint(classes.blueprint)
CORS(app)
return app
def create_app():
_app = Sanic(__name__)
_app.config.from_object(DevConfig)
JWTManager(_app)
CORS(_app, automatic_options=True)
_app.blueprint(swagger_blueprint)
from motor.motor_asyncio import AsyncIOMotorClient
@_app.listener('before_server_start')
def init(app, loop):
_app.db = AsyncIOMotorClient(_app.config.MONGO_URI)['inu']
from server.api import api
_app.blueprint(api)
return _app
def run(port: int,
workers: int,
trained_models: Dict[str, str],
static_dir: str = None) -> None:
"""Run the server programatically"""
print("Starting a sanic server on port {}.".format(port))
app = make_app(static_dir)
CORS(app) # It is acceptible to enable CORS because we have no auth.
if port != 8000:
logger.warning("The demo requires the API to be run on port 8000.")
for predictor_name, archive_file in trained_models.items():
archive = load_archive(archive_file)
predictor = Predictor.from_archive(archive, predictor_name)
app.predictors[predictor_name] = predictor
app.run(port=port, host="0.0.0.0", workers=workers)
def _setup_application(self, config: Config, app: Sanic) -> None:
bp = Blueprint(f"idom_dispatcher_{id(self)}",
url_prefix=config["url_prefix"])
self._setup_blueprint_routes(config, bp)
self._did_stop = did_stop = Event()
@app.listener("before_server_stop") # type: ignore
async def server_did_stop(app: Sanic,
loop: asyncio.AbstractEventLoop) -> None:
did_stop.set()
cors_config = config["cors"]
if cors_config: # pragma: no cover
cors_params = cors_config if isinstance(cors_config, dict) else {}
CORS(bp, **cors_params)
app.blueprint(bp)
def __init__(self, config=None):
#this object will kep track of all the nodes
#including the agent nodes and parent Node
self.nodes = {}
# we will make sure that only one instance of the node
#is active at any request to the web socket
#get the config object(dict)
self.config = self._load_args_config()
self.app = None
self.clients_alias = None
self.http_server = Sanic(__name__)
CORS(self.http_server)
self.master_server = None
self.slave_server = None
self._create_app()
def main():
parser = argparse.ArgumentParser(description='Fast VectorTile server with PostGIS backend')
parser.add_argument('--tm2', type=str, help='TM2 source file (yaml)')
parser.add_argument('--style', type=str, help='GL Style to serve at /style.json')
parser.add_argument('--pgdatabase', type=str, help='database name', default='osm')
parser.add_argument('--pghost', type=str, help='postgres hostname', default='')
parser.add_argument('--pgport', type=int, help='postgres port', default=5432)
parser.add_argument('--pguser', type=str, help='postgres user', default='')
parser.add_argument('--pgpassword', type=str, help='postgres password', default='')
parser.add_argument('--listen', type=str, help='listen address', default='127.0.0.1')
parser.add_argument('--listen-port', type=str, help='listen port', default=8080)
parser.add_argument('--cors', action='store_true', help='make cross-origin AJAX possible')
parser.add_argument('--debug', action='store_true', help='activate sanic debug mode')
parser.add_argument('--fonts', type=str, help='fonts location')
args = parser.parse_args()
if args.tm2:
if not os.path.exists(args.tm2):
print(f'file does not exists: {args.tm2}')
sys.exit(1)
# build the SQL query for all layers found in TM2 file
Config.tm2query = prepared_query(args.tm2)
# add route dedicated to tm2 queries
app.add_route(get_tile_tm2, r'/<z:int>/<x:int>/<y:int>.pbf', methods=['GET'])
else:
# no tm2 file given, switching to direct connection to postgis layers
app.add_route(get_tile_postgis, r'/<layer>/<z:int>/<x:int>/<y:int>.pbf', methods=['GET'])
Config.style = args.style
Config.fonts = args.fonts
# interpolate values for postgres connection
Config.dsn = Config.dsn.format(**args.__dict__)
if args.cors:
CORS(app)
app.run(
host=args.listen,
port=args.listen_port,
debug=args.debug)
def run(port: int, workers: int,
trained_models: Dict[str, DemoModel],
static_dir: str = None) -> None:
"""Run the server programatically"""
print("Starting a sanic server on port {}.".format(port))
if port != 8000:
logger.warning("The demo requires the API to be run on port 8000.")
# This will be ``None`` if all the relevant environment variables are not defined.
demo_db = PostgresDemoDatabase.from_environment()
app = make_app(static_dir, demo_db)
CORS(app)
for name, demo_model in trained_models.items():
predictor = demo_model.predictor()
app.predictors[name] = predictor
app.run(port=port, host="0.0.0.0", workers=workers)
