matthias/mayan-edms
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor the initial setting bootstrap code

Browse Source 
Signed-off-by: Roberto Rosario <roberto.rosario@mayan-edms.com>
This commit is contained in:
Roberto Rosario
2019-11-14 00:40:05 -04:00
parent 4a1607afad
commit c3793699c5
11 changed files with 420 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
HISTORY.rst
View File

@@ -138,6 +138,7 @@
for compatibility with version 3.2 settings.
These are now a fallback if the new 'DATABASES'
setting is not specified.
- Refactor the initial setting bootstrap code.
3.2.10 (2019-XX-XX)
===================

26
mayan/apps/smart_settings/classes.py
View File

@@ -18,12 +18,32 @@ from django.utils.encoding import (
from mayan.apps.common.serialization import yaml_dump, yaml_load
from .utils import read_configuration_file
logger = logging.getLogger(__name__)
SMART_SETTINGS_NAMESPACES_NAME = 'SMART_SETTINGS_NAMESPACES'
def read_configuration_file(filepath):
try:
with open(filepath) as file_object:
file_object.seek(0, os.SEEK_END)
if file_object.tell():
file_object.seek(0)
try:
return yaml_load(stream=file_object)
except yaml.YAMLError as exception:
exit(
'Error loading configuration file: {}; {}'.format(
filepath, exception
)
)
except IOError as exception:
if exception.errno == errno.ENOENT:
# No config file, return empty dictionary
return {}
else:
raise
@python_2_unicode_compatible
class Namespace(object):
_registry = {}
@@ -169,7 +189,7 @@ class Setting(object):
# Cache content of config file to speed up initial boot up
if not cls._config_file_cache:
cls._config_file_cache = read_configuration_file(
path=settings.CONFIGURATION_FILEPATH
filepath=settings.CONFIGURATION_FILEPATH
)
return cls._config_file_cache

43
mayan/apps/smart_settings/literals.py
View File

@@ -1,43 +1,4 @@
from __future__ import unicode_literals
# Default in YAML format
BOOTSTRAP_SETTING_LIST = (
{'name': 'ALLOWED_HOSTS', 'default': "['127.0.0.1', 'localhost', '[::1]']"},
{'name': 'APPEND_SLASH'},
{'name': 'AUTH_PASSWORD_VALIDATORS'},
{'name': 'COMMON_DISABLED_APPS'},
{'name': 'COMMON_EXTRA_APPS'},
{'name': 'DATA_UPLOAD_MAX_MEMORY_SIZE'},
{'name': 'DATABASES'},
{'name': 'DATABASE_ENGINE'},
{'name': 'DATABASE_NAME'},
{'name': 'DATABASE_USER'},
{'name': 'DATABASE_PASSWORD'},
{'name': 'DATABASE_HOST'},
{'name': 'DATABASE_PORT'},
{'name': 'DATABASE_CONN_MAX_AGE'},
{'name': 'DEBUG', 'default': 'false'},
{'name': 'DEFAULT_FROM_EMAIL'},
{'name': 'DISALLOWED_USER_AGENTS'},
{'name': 'EMAIL_BACKEND'},
{'name': 'EMAIL_HOST'},
{'name': 'EMAIL_HOST_PASSWORD'},
{'name': 'EMAIL_HOST_USER'},
{'name': 'EMAIL_PORT'},
{'name': 'EMAIL_TIMEOUT'},
{'name': 'EMAIL_USE_SSL'},
{'name': 'EMAIL_USE_TLS'},
{'name': 'FILE_UPLOAD_MAX_MEMORY_SIZE'},
{'name': 'HOME_VIEW'},
{'name': 'INSTALLED_APPS'},
{'name': 'INTERNAL_IPS', 'default': "['127.0.0.1']"},
{'name': 'LANGUAGES'},
{'name': 'LANGUAGE_CODE'},
{'name': 'LOGIN_REDIRECT_URL', 'default': 'common:home'},
{'name': 'LOGIN_URL', 'default': 'authentication:login_view'},
{'name': 'LOGOUT_REDIRECT_URL', 'default': 'authentication:login_view'},
{'name': 'STATIC_URL'},
{'name': 'STATICFILES_STORAGE'},
{'name': 'TIME_ZONE'},
{'name': 'WSGI_APPLICATION'}
)
CONFIGURATION_FILENAME = 'config.yml'
CONFIGURATION_LAST_GOOD_FILENAME = 'config_backup.yml'

414
mayan/apps/smart_settings/utils.py
View File

@@ -5,73 +5,369 @@ import os
import yaml
try:
from yaml import CSafeLoader as SafeLoader
except ImportError:
from yaml import SafeLoader
from mayan.apps.common.serialization import yaml_load
from .literals import BOOTSTRAP_SETTING_LIST
from .literals import (
CONFIGURATION_FILENAME, CONFIGURATION_LAST_GOOD_FILENAME
)
def get_default(name, fallback_default=None):
for item in BOOTSTRAP_SETTING_LIST:
if item['name'] == name:
return item.get('default', fallback_default)
class SettingNamespaceSingleton(object):
"""
Self hosting bootstrap setting class.
Allow managing setting in a compatible way before Mayan EDMS starts.
"""
_setting_kwargs = {}
_settings = {}
return fallback_default
class SettingNotFound(Exception):
"""Mostly a stand-in or typecast for KeyError for readability."""
def get_environment_variables():
result = {}
for setting in BOOTSTRAP_SETTING_LIST:
environment_value = os.environ.get('MAYAN_{}'.format(setting['name']))
if environment_value:
environment_value = yaml.load(stream=environment_value, Loader=SafeLoader)
result[setting['name']] = environment_value
return result
def get_environment_setting(name, fallback_default=None):
value = os.environ.get(
'MAYAN_{}'.format(name), get_default(
name=name, fallback_default=fallback_default
)
)
if value:
return yaml.load(stream=value, Loader=SafeLoader)
def read_configuration_file(path):
try:
with open(path) as file_object:
file_object.seek(0, os.SEEK_END)
if file_object.tell():
file_object.seek(0)
try:
return yaml.load(stream=file_object, Loader=SafeLoader)
except yaml.YAMLError as exception:
exit(
'Error loading configuration file: {}; {}'.format(
path, exception
@classmethod
def load_config_file(cls, filepath):
try:
with open(filepath) as file_object:
file_object.seek(0, os.SEEK_END)
if file_object.tell():
file_object.seek(0)
try:
return yaml_load(stream=file_object)
except yaml.YAMLError as exception:
exit(
'Error loading configuration file: {}; {}'.format(
filepath, exception
)
)
)
except IOError as exception:
if exception.errno == errno.ENOENT:
return {} # No config file, return empty dictionary
except IOError as exception:
if exception.errno == errno.ENOENT:
# No config file, return empty dictionary
return {}
else:
raise
@classmethod
def register_setting(cls, name, klass, kwargs=None):
cls._settings[name] = klass
cls._setting_kwargs[name] = kwargs or {}
def __init__(self, global_symbol_table):
self.global_symbol_table = global_symbol_table
self.settings = {}
for name, klass in self.__class__._settings.items():
kwargs = self.__class__._setting_kwargs[name].copy()
kwargs['name'] = name
setting = klass(**kwargs)
setting.namespace = self
self.settings[name] = setting
def get_config_file_setting(self, name):
"""
Wrapper for load_config_file to cache the result.
"""
if hasattr(self, '_cache_file_data'):
file_data = self._cache_file_data
else:
raise
filepath = self.get_setting_value(
name='CONFIGURATION_FILEPATH'
)
file_data = self.load_config_file(filepath=filepath)
try:
return file_data[name]
except KeyError:
raise SettingNamespaceSingleton.SettingNotFound
def get_setting_value(self, name):
"""
Wrapper that calls the individual setting .get_value method.
Convenience method to allow returning setting values from the
namespace.
"""
try:
return self.settings[name].get_value()
except KeyError:
raise SettingNamespaceSingleton.SettingNotFound
def get_values(self, only_critical=False):
"""
Return a dictionary will all the settings and their respective
resolved values.
"""
result = {}
for name, setting in self.settings.items():
# If only_critical is set to True load only the settings with
# the critical flag. Otherwise load all.
if only_critical and setting.critical or not only_critical:
try:
result[name] = setting.get_value()
except SettingNamespaceSingleton.SettingNotFound:
"""
Not critical, we just avoid adding it to the result
dictionary.
"""
return result
def update_globals(self, only_critical=False):
"""
Insert all resolved values into the symbol table of the caller.
"""
result = self.get_values(only_critical=only_critical)
self.global_symbol_table.update(result)
def yaml_loads(data, error_message=None):
if not error_message:
error_message = 'Error loading: {}; {}'
class BaseSetting(object):
def __init__(
self, name, critical=False, has_default=False, default_value=None
):
self.critical = critical
self.name = name
self.has_default = has_default
self.default_value = default_value
try:
return yaml.load(stream=data, Loader=SafeLoader)
except yaml.YAMLError as exception:
exit(
error_message.format(data, exception)
def _get_environment_value(self):
return os.environ.get(self.get_environment_name())
def get_default_value(self):
return self.default_value
def get_environment_name(self):
return 'MAYAN_{}'.format(self.name)
def get_value(self):
"""
By default will try to get the value from the namespace symbol table,
then the configuration file, and finally from the environment.
"""
try:
return self.namespace.global_symbol_table.get(
self.name, self.namespace.get_config_file_setting(name=self.name)
)
except SettingNamespaceSingleton.SettingNotFound:
return self.load_environment_value()
def load_environment_value(self):
value = self._get_environment_value()
if value:
try:
return yaml_load(stream=value)
except yaml.YAMLError as exception:
exit(
'Error loading setting environment value: {}; {}'.format(
self.name, exception
)
)
else:
if self.has_default:
return self.get_default_value()
else:
raise SettingNamespaceSingleton.SettingNotFound
class FilesystemBootstrapSetting(BaseSetting):
def __init__(self, name, critical=False, path_parts=None):
self.critical = critical
self.has_default = True
self.name = name
self.path_parts = path_parts
def get_default_value(self):
"""
The default value of this setting class is not static but calculated.
"""
return os.path.join(
# Can't use BASE_DIR from django.conf.settings
# Use it from the global_symbol_table which should be the same
self.namespace.global_symbol_table.get('BASE_DIR'), *self.path_parts
)
def get_value(self):
"""
It is not possible to look for this setting in the config file
because not even the config file setup has completed.
This setting only supports being set from the environment.
"""
return self.load_environment_value()
# FilesystemBootstrapSetting setting
SettingNamespaceSingleton.register_setting(
name='CONFIGURATION_FILEPATH', klass=FilesystemBootstrapSetting,
kwargs={
'critical': True, 'path_parts': ('media', CONFIGURATION_FILENAME,)
}
)
SettingNamespaceSingleton.register_setting(
name='CONFIGURATION_LAST_GOOD_FILEPATH', klass=FilesystemBootstrapSetting,
kwargs={
'critical': True, 'path_parts': ('media', CONFIGURATION_LAST_GOOD_FILENAME,)
}
)
SettingNamespaceSingleton.register_setting(
name='MEDIA_ROOT', klass=FilesystemBootstrapSetting, kwargs={
'critical': True, 'path_parts': ('media',)
}
)
# Normal settings
SettingNamespaceSingleton.register_setting(
name='ALLOWED_HOSTS', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': ['127.0.0.1', 'localhost', '[::1]']
}
)
SettingNamespaceSingleton.register_setting(
name='APPEND_SLASH', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='AUTH_PASSWORD_VALIDATORS', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='DATA_UPLOAD_MAX_MEMORY_SIZE', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='DATABASES', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': None
}
)
SettingNamespaceSingleton.register_setting(
name='DEBUG', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': False
}
)
SettingNamespaceSingleton.register_setting(
name='DEFAULT_FROM_EMAIL', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='DISALLOWED_USER_AGENTS', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='EMAIL_BACKEND', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='EMAIL_HOST', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='EMAIL_HOST_PASSWORD', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='EMAIL_HOST_USER', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='EMAIL_PORT', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='EMAIL_TIMEOUT', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='EMAIL_USE_SSL', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='EMAIL_USE_TLS', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='FILE_UPLOAD_MAX_MEMORY_SIZE', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='INTERNAL_IPS', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': ['127.0.0.1']
}
)
SettingNamespaceSingleton.register_setting(
name='LOGIN_REDIRECT_URL', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': 'common:home'
}
)
SettingNamespaceSingleton.register_setting(
name='LOGIN_URL', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': 'authentication:login_view'
}
)
SettingNamespaceSingleton.register_setting(
name='LOGOUT_REDIRECT_URL', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': 'authentication:login_view'
}
)
SettingNamespaceSingleton.register_setting(
name='LANGUAGES', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='LANGUAGE_CODE', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='STATIC_URL', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='STATICFILES_STORAGE', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='TIME_ZONE', klass=BaseSetting,
)
SettingNamespaceSingleton.register_setting(
name='WSGI_APPLICATION', klass=BaseSetting,
)
# Celery
SettingNamespaceSingleton.register_setting(
name='CELERY_TASK_ALWAYS_EAGER', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': True
}
)
SettingNamespaceSingleton.register_setting(
name='CELERY_BROKER_URL', klass=BaseSetting
)
SettingNamespaceSingleton.register_setting(
name='CELERY_RESULT_BACKEND', klass=BaseSetting
)
# Mayan
SettingNamespaceSingleton.register_setting(
name='COMMON_DISABLED_APPS', klass=BaseSetting, kwargs={
'critical': True, 'has_default': True, 'default_value': ()
}
)
SettingNamespaceSingleton.register_setting(
name='COMMON_EXTRA_APPS', klass=BaseSetting, kwargs={
'critical': True, 'has_default': True, 'default_value': ()
}
)
SettingNamespaceSingleton.register_setting(
name='DATABASE_ENGINE', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': None
}
)
SettingNamespaceSingleton.register_setting(
name='DATABASE_NAME', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': None
}
)
SettingNamespaceSingleton.register_setting(
name='DATABASE_USER', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': None
}
)
SettingNamespaceSingleton.register_setting(
name='DATABASE_PASSWORD', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': None
}
)
SettingNamespaceSingleton.register_setting(
name='DATABASE_HOST', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': None
}
)
SettingNamespaceSingleton.register_setting(
name='DATABASE_PORT', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': None
}
)
SettingNamespaceSingleton.register_setting(
name='DATABASE_CONN_MAX_AGE', klass=BaseSetting, kwargs={
'has_default': True, 'default_value': None
}
)

126
mayan/settings/base.py
View File

@@ -1,14 +1,3 @@
"""
Django settings for mayan10 project.
Generated by 'django-admin startproject' using Django 1.10.4.
For more information on this file, see
https://docs.djangoproject.com/en/1.10/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.10/ref/settings/
"""
from __future__ import unicode_literals
import os
@@ -17,15 +6,9 @@ import sys
from django.core.exceptions import ImproperlyConfigured
from django.utils.translation import ugettext_lazy as _
from mayan.apps.smart_settings.literals import BOOTSTRAP_SETTING_LIST
from mayan.apps.smart_settings.utils import (
get_environment_setting, get_environment_variables, read_configuration_file
)
from mayan.apps.smart_settings.utils import SettingNamespaceSingleton
from .literals import (
CONFIGURATION_FILENAME, CONFIGURATION_LAST_GOOD_FILENAME,
DEFAULT_SECRET_KEY, SECRET_KEY_FILENAME, SYSTEM_DIR
)
from .literals import DEFAULT_SECRET_KEY, SECRET_KEY_FILENAME, SYSTEM_DIR
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
@@ -34,9 +17,17 @@ BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/
MEDIA_ROOT = get_environment_setting(
name='MEDIA_ROOT', fallback_default=os.path.join(BASE_DIR, 'media')
)
setting_namespace = SettingNamespaceSingleton(global_symbol_table=globals())
if 'revertsettings' in sys.argv:
setting_namespace.update_globals(only_critical=True)
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(MEDIA_ROOT, 'db.sqlite3'), # NOQA: F821
}
}
else:
setting_namespace.update_globals()
# SECURITY WARNING: keep the secret key used in production secret!
environment_secret_key = os.environ.get('MAYAN_SECRET_KEY')
@@ -44,15 +35,12 @@ if environment_secret_key:
SECRET_KEY = environment_secret_key
else:
try:
with open(os.path.join(MEDIA_ROOT, SYSTEM_DIR, SECRET_KEY_FILENAME)) as file_object:
with open(os.path.join(MEDIA_ROOT, SYSTEM_DIR, SECRET_KEY_FILENAME)) as file_object: # NOQA: F821
SECRET_KEY = file_object.read().strip()
except IOError:
SECRET_KEY = DEFAULT_SECRET_KEY
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = get_environment_setting(name='DEBUG')
ALLOWED_HOSTS = get_environment_setting(name='ALLOWED_HOSTS')
# Application definition
@@ -243,7 +231,7 @@ LANGUAGES = (
SITE_ID = 1
STATIC_ROOT = os.environ.get(
'MAYAN_STATIC_ROOT', os.path.join(MEDIA_ROOT, 'static')
'MAYAN_STATIC_ROOT', os.path.join(MEDIA_ROOT, 'static') # NOQA: F821
)
STATICFILES_FINDERS = (
@@ -255,13 +243,6 @@ STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
TEST_RUNNER = 'mayan.apps.common.tests.runner.MayanTestRunner'
# --------- Django -------------------
LOGIN_URL = get_environment_setting(name='LOGIN_URL')
LOGIN_REDIRECT_URL = get_environment_setting(name='LOGIN_REDIRECT_URL')
LOGOUT_REDIRECT_URL = get_environment_setting(name='LOGOUT_REDIRECT_URL')
INTERNAL_IPS = get_environment_setting(name='INTERNAL_IPS')
# ---------- Django REST framework -----------
REST_FRAMEWORK = {
@@ -283,12 +264,6 @@ PAGINATION_SETTINGS = {
# ----------- Celery ----------
CELERY_BROKER_URL = get_environment_setting(name='CELERY_BROKER_URL')
CELERY_RESULT_BACKEND = get_environment_setting(name='CELERY_RESULT_BACKEND')
CELERY_TASK_ALWAYS_EAGER = get_environment_setting(
name='CELERY_TASK_ALWAYS_EAGER'
)
CELERY_ACCEPT_CONTENT = ('json',)
CELERY_BEAT_SCHEDULE = {}
CELERY_BEAT_SCHEDULER = 'django_celery_beat.schedulers.DatabaseScheduler'
@@ -329,54 +304,6 @@ SWAGGER_SETTINGS = {
AJAX_REDIRECT_CODE = 278
BASE_INSTALLED_APPS = INSTALLED_APPS
COMMON_EXTRA_APPS = ()
COMMON_DISABLED_APPS = ()
CONFIGURATION_FILEPATH = get_environment_setting(
name='CONFIGURATION_FILEPATH', fallback_default=os.path.join(
MEDIA_ROOT, CONFIGURATION_FILENAME
)
)
CONFIGURATION_LAST_GOOD_FILEPATH = get_environment_setting(
name='CONFIGURATION_LAST_GOOD_FILEPATH', fallback_default=os.path.join(
MEDIA_ROOT, CONFIGURATION_LAST_GOOD_FILENAME
)
)
if 'revertsettings' not in sys.argv:
configuration_result = read_configuration_file(CONFIGURATION_FILEPATH)
environment_result = get_environment_variables()
for setting in BOOTSTRAP_SETTING_LIST:
if setting['name'] in configuration_result:
globals().update(
{setting['name']: configuration_result[setting['name']]}
)
elif setting['name'] in environment_result:
globals().update(
{setting['name']: environment_result[setting['name']]}
)
else:
# Apply the default only if it has not yet been defined previously
# in this module.
if setting['name'] not in globals():
globals().update(
{
setting['name']: get_environment_setting(
name=setting['name']
)
}
)
else:
# Safe fallback to allow the revertsettings command to complete.
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(MEDIA_ROOT, 'db.sqlite3'),
}
}
for app in INSTALLED_APPS:
if 'mayan.apps.{}'.format(app) in BASE_INSTALLED_APPS:
@@ -385,32 +312,31 @@ for app in INSTALLED_APPS:
'in https://docs.mayan-edms.com/releases/3.2.html#backward-incompatible-changes'
)
for APP in (COMMON_EXTRA_APPS or ()):
for APP in (COMMON_EXTRA_APPS or ()): # NOQA: F821
INSTALLED_APPS = INSTALLED_APPS + (APP,)
INSTALLED_APPS = [
APP for APP in INSTALLED_APPS if APP not in (COMMON_DISABLED_APPS or ())
APP for APP in INSTALLED_APPS if APP not in (COMMON_DISABLED_APPS or ()) # NOQA: F821
]
if not DATABASES:
if DATABASE_ENGINE:
if DATABASE_ENGINE: # NOQA: F821
DATABASES = {
'default': {
'ENGINE': DATABASE_ENGINE,
'NAME': DATABASE_NAME,
'USER': DATABASE_USER,
'PASSWORD': DATABASE_PASSWORD,
'HOST': DATABASE_HOST,
'PORT': DATABASE_PORT,
'CONN_MAX_AGE': DATABASE_CONN_MAX_AGE
'ENGINE': DATABASE_ENGINE, # NOQA: F821
'NAME': DATABASE_NAME, # NOQA: F821
'USER': DATABASE_USER, # NOQA: F821
'PASSWORD': DATABASE_PASSWORD, # NOQA: F821
'HOST': DATABASE_HOST, # NOQA: F821
'PORT': DATABASE_PORT, # NOQA: F821
'CONN_MAX_AGE': DATABASE_CONN_MAX_AGE # NOQA: F821
}
}
else:
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(MEDIA_ROOT, 'db.sqlite3'),
'NAME': os.path.join(MEDIA_ROOT, 'db.sqlite3'), # NOQA: F821
}
}

17
mayan/settings/development.py
View File

@@ -1,33 +1,28 @@
from __future__ import absolute_import, unicode_literals
from mayan.apps.smart_settings.utils import get_environment_setting
from . import * # NOQA
ALLOWED_HOSTS = ['*']
DEBUG = True
CELERY_TASK_ALWAYS_EAGER = get_environment_setting(
name='CELERY_TASK_ALWAYS_EAGER', fallback_default='true'
)
CELERY_TASK_EAGER_PROPAGATES = CELERY_TASK_ALWAYS_EAGER
CELERY_TASK_EAGER_PROPAGATES = CELERY_TASK_ALWAYS_EAGER # NOQA: F405
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
if 'rosetta' not in INSTALLED_APPS:
if 'rosetta' not in INSTALLED_APPS: # NOQA: F405
try:
import rosetta
import rosetta # NOQA: F401
except ImportError:
pass
else:
INSTALLED_APPS += (
INSTALLED_APPS += ( # NOQA: F405
'rosetta',
)
if 'django_extensions' not in INSTALLED_APPS:
try:
import django_extensions
import django_extensions # NOQA: F401
except ImportError:
pass
else:
@@ -37,7 +32,7 @@ if 'django_extensions' not in INSTALLED_APPS:
ROOT_URLCONF = 'mayan.urls.development'
TEMPLATES[0]['OPTIONS']['loaders'] = (
TEMPLATES[0]['OPTIONS']['loaders'] = ( # NOQA: F405
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
)

6
mayan/settings/development_ddt.py
View File

@@ -6,11 +6,11 @@ from .development import * # NOQA
# see https://github.com/django-debug-toolbar/django-debug-toolbar/issues/524
DEBUG_TOOLBAR_PATCH_SETTINGS = False
if 'debug_toolbar' not in INSTALLED_APPS:
INSTALLED_APPS += (
if 'debug_toolbar' not in INSTALLED_APPS: # NOQA: F405
INSTALLED_APPS += ( # NOQA: F405
'debug_toolbar',
)
MIDDLEWARE_CLASSES = (
'debug_toolbar.middleware.DebugToolbarMiddleware',
) + MIDDLEWARE_CLASSES
) + MIDDLEWARE_CLASSES # NOQA: F405

3
mayan/settings/literals.py
View File

@@ -3,6 +3,3 @@ from __future__ import unicode_literals
DEFAULT_SECRET_KEY = 'secret-key-missing!'
SECRET_KEY_FILENAME = 'SECRET_KEY'
SYSTEM_DIR = 'system'
CONFIGURATION_FILENAME = 'config.yml'
CONFIGURATION_LAST_GOOD_FILENAME = 'config_backup.yml'

2
mayan/settings/production.py
View File

@@ -4,7 +4,7 @@ from . import * # NOQA
CELERY_TASK_ALWAYS_EAGER = False
TEMPLATES[0]['OPTIONS']['loaders'] = (
TEMPLATES[0]['OPTIONS']['loaders'] = ( # NOQA: F405
(
'django.template.loaders.cached.Loader', (
'django.template.loaders.filesystem.Loader',

6
mayan/settings/testing/base.py
View File

@@ -12,7 +12,7 @@ DOCUMENT_PARSING_AUTO_PARSING = False
FILE_METADATA_AUTO_PROCESS = False
INSTALLED_APPS += ('test_without_migrations',)
INSTALLED_APPS += ('test_without_migrations',) # NOQA: F405
INSTALLED_APPS = [
cls for cls in INSTALLED_APPS if cls != 'whitenoise.runserver_nostatic'
@@ -21,7 +21,7 @@ INSTALLED_APPS = [
# Remove whitenoise from middlewares. Causes out of memory errors during test
# suit
MIDDLEWARE = [
cls for cls in MIDDLEWARE if cls != 'whitenoise.middleware.WhiteNoiseMiddleware'
cls for cls in MIDDLEWARE if cls != 'whitenoise.middleware.WhiteNoiseMiddleware' # NOQA: F405
]
# Remove middlewares not used for tests
@@ -48,7 +48,7 @@ PASSWORD_HASHERS = (
STATICFILES_STORAGE = None
# Cache templates in memory
TEMPLATES[0]['OPTIONS']['loaders'] = (
TEMPLATES[0]['OPTIONS']['loaders'] = ( # NOQA: F405
(
'django.template.loaders.cached.Loader', (
'django.template.loaders.filesystem.Loader',

1
mayan/settings/testing/gitlab-ci/base.py
View File

@@ -3,4 +3,3 @@ from __future__ import unicode_literals
from ..base import * # NOQA
SIGNATURES_GPG_PATH = '/usr/bin/gpg1'