def wsgi():
"""Simple Pyramid wsgi server for development purpose
"""
load_init_function_from_entry_points()
Configuration.load('pyramid')
configuration_post_load()
BlokManager.load()
config = Configurator()
config.include_from_entry_point()
config.load_config_bloks()
wsgi_host = Configuration.get('wsgi_host')
wsgi_port = int(Configuration.get('wsgi_port'))
app = config.make_wsgi_app()
server = make_server(wsgi_host, wsgi_port, app)
preload_databases(loadwithoutmigration=False)
try:
from colorama import Fore, Style
start_msg = ("Pyramid development server running at %shttp://%s:%s%s" %
(Fore.BLUE, wsgi_host, wsgi_port, Style.RESET_ALL))
except ImportError:
logger.info("`pip install colorama` to get colored link")
start_msg = "Pyramid development server running at http://%s:%s" % (
wsgi_host, wsgi_port)
logger.info(start_msg)
print(start_msg)
server.serve_forever()
def anyblok_wsgi(application, configuration_groups, **kwargs):
"""
:param application: name of the application
:param configuration_groups: list configuration groupe to load
:param \**kwargs: ArgumentParser named arguments
"""
format_configuration(configuration_groups, 'preload', 'pyramid-debug',
'wsgi')
load_init_function_from_entry_points()
Configuration.load(application,
configuration_groups=configuration_groups, **kwargs)
BlokManager.load()
config = Configurator()
config.include_from_entry_point()
config.load_config_bloks()
wsgi_host = Configuration.get('wsgi_host')
wsgi_port = int(Configuration.get('wsgi_port'))
app = config.make_wsgi_app()
server = make_server(wsgi_host, wsgi_port, app)
preload_databases()
logger.info("Serve forever on %r:%r" % (wsgi_host, wsgi_port))
server.serve_forever()
def anyblok_createdb():
"""Create a database and install blok from config"""
load_init_function_from_entry_points()
Configuration.load('createdb')
configuration_post_load()
BlokManager.load()
db_name = get_db_name()
db_template_name = Configuration.get('db_template_name', None)
url = Configuration.get('get_url')(db_name=db_name)
create_database(url, template=db_template_name)
registry = RegistryManager.get(db_name)
if registry is None:
return
if Configuration.get('install_all_bloks'):
bloks = registry.System.Blok.list_by_state('uninstalled')
else:
install_bloks = Configuration.get('install_bloks') or []
iou_bloks = Configuration.get('install_or_update_bloks') or []
bloks = list(set(install_bloks + iou_bloks))
registry.upgrade(install=bloks)
registry.commit()
registry.close()
def anyblok_createdb():
"""Create a database and install blok from config"""
load_init_function_from_entry_points()
Configuration.load('createdb')
configuration_post_load()
BlokManager.load()
db_name = get_db_name()
db_template_name = Configuration.get('db_template_name', None)
url = Configuration.get('get_url')(db_name=db_name)
create_database(url, template=db_template_name)
anyblok_registry = RegistryManager.get(db_name)
if anyblok_registry is None:
return
anyblok_registry.System.Parameter.set(
"with-demo", Configuration.get('with_demo', False))
if Configuration.get('install_all_bloks'):
bloks = anyblok_registry.System.Blok.list_by_state('uninstalled')
else:
install_bloks = Configuration.get('install_bloks') or []
iou_bloks = Configuration.get('install_or_update_bloks') or []
bloks = list(set(install_bloks + iou_bloks))
anyblok_registry.upgrade(install=bloks)
anyblok_registry.commit()
anyblok_registry.close()
def anyblok_wsgi(application, configuration_groups, **kwargs):
"""
:param application: name of the application
:param configuration_groups: list configuration groupe to load
:param \**kwargs: ArgumentParser named arguments
"""
format_configuration(configuration_groups, 'preload', 'pyramid-debug',
'wsgi')
load_init_function_from_entry_points()
Configuration.load(application,
configuration_groups=configuration_groups,
**kwargs)
BlokManager.load()
config = Configurator()
config.include_from_entry_point()
config.load_config_bloks()
wsgi_host = Configuration.get('wsgi_host')
wsgi_port = int(Configuration.get('wsgi_port'))
app = config.make_wsgi_app()
server = make_server(wsgi_host, wsgi_port, app)
preload_databases()
logger.info("Serve forever on %r:%r" % (wsgi_host, wsgi_port))
server.serve_forever()
def createdb(application, configuration_groups, **kwargs):
""" Create a database and install blok from config
:param application: name of the application
:param configuration_groups: list configuration groupe to load
:param \**kwargs: ArgumentParser named arguments
"""
format_configuration(configuration_groups,
'create_db', 'install-bloks',
'install-or-update-bloks')
load_init_function_from_entry_points()
Configuration.load(application, configuration_groups=configuration_groups,
**kwargs)
BlokManager.load()
db_name = Configuration.get('db_name')
db_template_name = Configuration.get('db_template_name', None)
url = Configuration.get('get_url')(db_name=db_name)
create_database(url, template=db_template_name)
registry = RegistryManager.get(db_name)
if registry is None:
return
if Configuration.get('install_all_bloks'):
bloks = registry.System.Blok.list_by_state('uninstalled')
else:
install_bloks = Configuration.get('install_bloks') or []
iou_bloks = Configuration.get('install_or_update_bloks') or []
bloks = list(set(install_bloks + iou_bloks))
registry.upgrade(install=bloks)
registry.commit()
registry.close()
def anyblok_dramatiq():
"""Run dramatiq workers process to consume en execute
actors
:param application: name of the application
:param configuration_groups: list configuration groupe to load
:param \**kwargs: ArgumentParser named arguments
"""
load_init_function_from_entry_points()
Configuration.load('dramatiq')
worker_pipes = []
worker_processes = []
for worker_id in range(Configuration.get('dramatiq_processes', 1)):
read_fd, write_fd = os.pipe()
pid = os.fork()
if pid != 0:
os.close(write_fd)
worker_pipes.append(os.fdopen(read_fd))
worker_processes.append(pid)
continue
os.close(read_fd)
return worker_process(worker_id, write_fd)
def sighandler(signum, frame):
nonlocal worker_processes
signum = {
signal.SIGINT: signal.SIGTERM,
signal.SIGTERM: signal.SIGTERM,
signal.SIGHUP: signal.SIGHUP,
}[signum]
logger.info("Sending %r to worker processes...", signum.name)
for pid in worker_processes:
try:
os.kill(pid, signum)
except OSError:
logger.warning(
"Failed to send %r to pid %d.", signum.name, pid)
retcode = 0
signal.signal(signal.SIGINT, sighandler)
signal.signal(signal.SIGTERM, sighandler)
signal.signal(signal.SIGHUP, sighandler)
for pid in worker_processes:
pid, rc = os.waitpid(pid, 0)
retcode = max(retcode, rc >> 8)
running = False # noqa
for pipe in worker_pipes:
pipe.close()
return retcode
def asgi() -> None:
"""uvicorn ASGI dev server"""
load_init_function_from_entry_points()
argv: List[str] = copy(sys.argv)
Configuration.load("uvicorn")
sys.argv = argv
configuration_post_load()
BlokManager.load()
kwargs = {
"app": create_app(preload_database(loadwithoutmigration=False)),
"host": Configuration.get("host"),
"port": Configuration.get("port"),
# "uds": uds,
# "fd": fd,
# "loop": loop,
# "http": http,
# "ws": ws,
# "lifespan": lifespan,
# "env_file": env_file,
# "log_config": LOGGING_CONFIG if log_config is None else log_config,
# "log_level": log_level,
# "access_log": access_log,
# "interface": interface,
# "debug": debug,
# "reload": reload,
# "reload_dirs": reload_dirs if reload_dirs else None,
# "workers": workers,
# "proxy_headers": proxy_headers,
# "forwarded_allow_ips": forwarded_allow_ips,
# "root_path": root_path,
# "limit_concurrency": limit_concurrency,
# "backlog": backlog,
# "limit_max_requests": limit_max_requests,
# "timeout_keep_alive": timeout_keep_alive,
# "ssl_keyfile": ssl_keyfile,
# "ssl_certfile": ssl_certfile,
# "ssl_version": ssl_version,
# "ssl_cert_reqs": ssl_cert_reqs,
# "ssl_ca_certs": ssl_ca_certs,
# "ssl_ciphers": ssl_ciphers,
# "headers": list([header.split(":") for header in headers]),
# "use_colors": use_colors,
}
run(**kwargs)
def update_project():
anyblok.load_init_function_from_entry_points()
Configuration.load('update-project')
anyblok.configuration_post_load()
BlokManager.load()
db_name = Configuration.get('db_name')
logger.info("update project: db_name=%r", db_name)
to_install = []
to_update = []
to_uninstall = []
url = get_url()
options = {}
if not database_exists(url):
db_template_name = Configuration.get('db_template_name', None)
create_database(url, template=db_template_name)
to_install.append('team')
version = None
else:
options.update(dict(loadwithoutmigration=True))
registry = RegistryManager.get(db_name, **options)
registry.update_blok_list() # case, new blok added
version = registry.System.Blok.query().filter_by(
name='team').one().installed_version
if version is None:
pass
else:
to_update.append('team')
registry.upgrade(install=to_install,
update=to_update,
uninstall=to_uninstall)
if version is None:
registry.Pyramid.User.insert(login='******')
registry.Pyramid.CredentialStore.insert(login='******',
password='******')
registry.commit()
registry.close()
logger.info("Project updated: db_name=%r", db_name)
def wsgi():
"""Simple wsgi server for dev
"""
load_init_function_from_entry_points()
Configuration.load('pyramid')
configuration_post_load()
BlokManager.load()
config = Configurator()
config.include_from_entry_point()
config.load_config_bloks()
wsgi_host = Configuration.get('wsgi_host')
wsgi_port = int(Configuration.get('wsgi_port'))
app = config.make_wsgi_app()
server = make_server(wsgi_host, wsgi_port, app)
preload_databases(loadwithoutmigration=False)
logger.info("Serve forever on %r:%r" % (wsgi_host, wsgi_port))
server.serve_forever()
def wsgi():
"""Simple wsgi server for dev
"""
load_init_function_from_entry_points()
Configuration.load('pyramid')
configuration_post_load()
BlokManager.load()
config = Configurator()
config.include_from_entry_point()
config.load_config_bloks()
wsgi_host = Configuration.get('wsgi_host')
wsgi_port = int(Configuration.get('wsgi_port'))
app = config.make_wsgi_app()
server = make_server(wsgi_host, wsgi_port, app)
preload_databases(loadwithoutmigration=False)
logger.info("Serve forever on %r:%r" % (wsgi_host, wsgi_port))
server.serve_forever()
def test_load_without_configuration_groupes(self):
self.assertEqual(Configuration.load('default'), None)
def test_load_with_bad_configuration_groupes(self):
Configuration.load('default', configuration_groups=['bad-groups'])
self.assertConfig(MockArguments.vals)
def test_load_with_configuration_groupes(self):
Configuration.load('default', configuration_groups=['install-bloks'])
self.assertConfig(MockArguments.vals)
def test_load_without_configuration_groupes(self):
self.assertEqual(Configuration.load('default'), None)
def test_load_with_configuration_groupes(self):
Configuration.load('default', configuration_groups=['install-bloks'])
self.assertConfig(MockArguments.vals)
def test_load_with_bad_configuration_groupes(self):
Configuration.load('default', configuration_groups=['bad-groups'])
self.assertConfig(MockArguments.vals)
def test_load_without_configuration_groupes(self):
assert Configuration.load('default') is None
