def main(argv=None):
if not argv:
argv = sys.argv
if len(argv) < 2:
usage(argv)
load_dotenv_vars()
env = Env()
config_uri = argv[1]
wsgi_app = get_app(config_uri)
setup_logging(config_uri)
import cherrypy
cherrypy.tree.graft(wsgi_app, '/')
cherrypy.server.unsubscribe()
from cherrypy._cpserver import Server
server = Server()
server.socket_host = env.host
server.socket_port = env.port
server.thread_pool = 10
server.subscribe()
cherrypy.engine.start()
cherrypy.engine.block()
def main(argv=None):
if not argv:
argv = sys.argv
if len(argv) < 2:
usage(argv)
load_dotenv_vars()
env = Env()
config_uri = argv[1]
setup_logging(config_uri)
# default args
loglevel = 'info'
queues = 'default'
if not env.is_production:
loglevel = 'debug'
os.system('celery worker -A aarau.tasks.worker '
'--ini {0!s} '
'-E '
'-l {1!s} '
'-Q {2!s}'.format(config_uri, loglevel, queues))
def __init__(self, *args, **kwargs):
env_dict = (args[0] or {})
# self.environ is request env.
# the `env` is os's environ handler (wrapper)
self.env = Env()
if self.env.is_production:
env_dict = self._force_ssl(env_dict)
env_dict = self.__class__.trim_port(env_dict)
new_args = (env_dict, args[1:])
# create base_url from pseudo values for tasks
if 'base_url' in kwargs and kwargs['base_url'] is None:
# pylint: disable=no-member
base_url = '{0!s}://{1!s}:{2!s}'.format(
self.settings.get('wsgi.url_scheme', 'https'),
self.environ.get('HTTP_HOST', '127.0.0.1'),
self.environ.get('HTTP_PORT', '8080'))
if self.env.is_production:
base_url = re.sub(':[0-9]+$', '', base_url)
kwargs['base_url'] = base_url
super().__init__(*new_args, **kwargs)
env_dict = (new_args[0] or {})
if not ASSET_PATH.match(env_dict['PATH_INFO']) and \
not HEALTH_CHECK_PATH.match(env_dict['PATH_INFO']):
self.__class__.open_db()
# finished callbacks
self.add_finished_callback(self.__class__.close_db)
def __init__(self, ctx: dict, req: CustomRequest, **kwargs: dict) -> None:
self.ctx, self.req = ctx, req
self.env = Env()
if getattr(req, 'util', None) is None:
req.util = self
self.__dict__.update(kwargs)
def set_cache_controls(event):
request = event['request']
env = Env()
# disable caching
if request and not env.is_production:
request.response.headerlist.extend(
(('Cache-Control', 'no-cache, no-store, must-revalidate'),
('Pragma', 'no-cache'), ('Expires', '0')))
def includeme(config):
env = Env()
# see also __init__.py for static files
cache_max_age = 3600 if env.is_production else 0
static_dir = path.join(path.dirname(path.abspath(__file__)), '../static')
filenames = [
f for f in ('robots.txt', 'humans.txt', 'favicon.ico')
if path.isfile((static_dir + '/{}').format(f))
]
if filenames:
filenames = sum([filenames, []], [])
config.add_asset_views('aarau:../static',
filenames=filenames,
http_cache=cache_max_age)
config.add_static_view(name='assets',
path='aarau:../static/',
cache_max_age=cache_max_age)
config.add_cache_buster(
'aarau:../static/',
QueryStringConstantCacheBuster(str(int(time.time()))))
subdomain = subdomain_manager_factory(config)
namespace = namespace_predicator()
with subdomain('console') as c:
define_console_routes(c, namespace)
with subdomain('carrell') as c:
define_carrell_routes(c)
with subdomain('registry') as c:
define_registry_routes(c, namespace)
with subdomain(None) as c:
c.add_route('top', '/')
c.add_route('login', '/login')
c.add_route('logout', '/logout')
c.add_route('signup', '/signup')
c.add_route('signup.activate', '/activate/{token}')
c.add_route('reset_password.request', '/password/reset')
c.add_route('reset_password', '/password/reset/{token}')
# login required
c.add_route('project.new', '/projects/new')
# public view
with subdomain(None) as c:
c.add_route('publication', '/{namespace}/{slug}')
c.add_route('article', '/{namespace}/{slug}/{path}')
def resolve_env_vars(settings):
"""Overrides settings with vars from `os.environ`."""
def get_new_v(env, value, expected_type):
new_v = env.get(value, None)
if not isinstance(new_v, expected_type):
return None
# split, but ignore empty string
if ',' in new_v:
new_v = [v for v in new_v.split(',') if v != '']
return new_v
env = Env()
s = settings.copy()
for k, v in Env.settings_mappings().items():
# ignores missing key or it has a already value in config
if k not in s or s[k]:
continue
new_v = get_new_v(env, v, str)
if new_v:
s[k] = new_v
return s
def subdomain_pregenerator(subdomain):
env = Env()
def pregenerator(_req, elements, kw):
domain = env.get('DOMAIN', None)
if subdomain:
kw['_host'] = '{0!s}.{1!s}'.format(subdomain, domain)
else:
kw['_host'] = '{0!s}'.format(domain)
return elements, kw
return pregenerator
def main(global_config, **settings):
from aarau.request import CustomRequest
config = Configurator(settings=resolve_settings(dict(settings)))
config.configure_celery(global_config['__file__'])
config.include('.mailers')
config.include('.models')
config.include('.views')
config.include('.services')
config.include('.tasks')
config.include('.route')
config.include('.security')
config.add_translation_dirs('aarau:../locale')
# this calls db connect/close to recycle connection
config.set_request_factory(CustomRequest)
config.set_default_csrf_options(require_csrf=True)
config.scan()
app = config.make_wsgi_app()
# enable file logger [wsgi/access_log]
# from paste.translogger import TransLogger
# app = TransLogger(app, setup_console_handler=False)
# basic auth
env = Env()
credentials = settings.get('wsgi.auth_credentials', None)
if not env.is_test and credentials:
env.set('WSGI_AUTH_CREDENTIALS', credentials)
from wsgi_basic_auth import BasicAuth
app = BasicAuth(app)
return app
def init_worker(settings):
"""Initializes and updates worker (app)."""
if not settings or not isinstance(settings, dict):
# for celery worker process
# see aarau/scripts/worker.py
import os
from pyramid.paster import get_appsettings
from aarau import resolve_env_vars
from aarau.env import Env
env = Env()
config_uri = '{0!s}/config/{1!s}.ini#aarau'.format(
os.path.dirname(__file__) + '/../..', env.name)
settings = get_appsettings(config_uri)
settings = resolve_env_vars(dict(settings))
options = { # duplicated for consistency
'broker_url': settings['queue.url'],
}
_worker.conf.update(**options)
return _worker
def deliver(self):
env = Env()
typ = env.get('MAILER_TYPE', 'smtp')
if typ == 'smtp':
self.mailer.send_immediately(self.message, fail_silently=False)
if typ == 'http': # use `HTTP` api
url = env.get('MAILER_URL',
'{}').format(env.get('MAILER_DOMAIN', ''))
auth = ('api', env.get('MAILER_API_KEY', ''))
data = {
'from': self.message.sender,
'to': self.message.recipients,
'subject': self.message.subject,
'text': self.message.body,
}
res = requests.post(url, auth=auth, data=data)
res.raise_for_status()
def env(dotenv) -> dict:
"""Returns env object."""
from aarau.env import Env
return Env()