def test_setting_env_var_name(self):
environ["HERP"] = "memcached://127.0.0.1:11211/"
backend = "django.core.cache.backends.memcached.PyLibMCCache"
config = django_cache_url.config(env="HERP")
self.assertEqual(config["BACKEND"], backend)
self.assertEqual(config["LOCATION"], "127.0.0.1:11211")
def test_env_var(self):
environ["CACHE_URL"] = "memcached://127.0.0.1:11211/"
backend = "django.core.cache.backends.memcached.PyLibMCCache"
config = django_cache_url.config()
self.assertEqual(config["BACKEND"], backend)
self.assertEqual(config["LOCATION"], "127.0.0.1:11211")
def factorise():
"""
Returns a dict of settings suitable for Django, acquired from the environment in a 12factor-y way - see http://12factor.net/config
Caller probably wants to, in `settings.py`:
globals().update(factorise())
"""
settings = {}
settings['LOGGING'] = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'stdout': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
}
},
'loggers': {
'root': {
'handlers': ['stdout'],
'propagate': True,
},
},
}
settings['DATABASES'] = {
'default': dj_database_url.config(default='sqlite://:memory:')
}
settings['DEBUG'] = getenv_bool('DEBUG')
if 'TEMPLATE_DEBUG' in os.environ:
settings['TEMPLATE_DEBUG'] = getenv_bool('TEMPLATE_DEBUG')
else:
settings['TEMPLATE_DEBUG'] = settings['DEBUG']
# Slightly opinionated...
if 'SECRET_KEY' in os.environ:
settings['SECRET_KEY'] = os.environ['SECRET_KEY']
elif not settings['DEBUG']:
sys.exit('DEBUG is False but no SECRET_KEY is set in the environment - either it has been hardcoded (bad) or not set at all (bad) - exit()ing for safety reasons')
settings['CACHES'] = {
'default': django_cache_url.config(default='locmem://')
}
settings.update(dj_email_url.config(default='dummy://'))
settings['ALLOWED_HOSTS'] = os.getenv('ALLOWED_HOSTS', '').split(',')
return settings
def factorise():
"""
Returns a dict of settings suitable for Django, acquired from the environment in a 12factor-y way - see http://12factor.net/config
Caller probably wants to, in `settings.py`:
globals().update(factorise())
"""
settings = {}
# Slightly opinionated...
if 'SECRET_KEY' in os.environ:
settings['SECRET_KEY'] = os.environ['SECRET_KEY']
else:
logger.warn('No SECRET_KEY provided, using UUID')
settings['SECRET_KEY'] = str(uuid.uuid4())
settings['LOGGING'] = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'stdout': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
}
},
'loggers': {
'root': {
'handlers': ['stdout'],
'propagate': True,
},
},
}
settings['DATABASES'] = {
'default': dj_database_url.config(default='sqlite://:memory:') # Note this'll currently break due to https://github.com/kennethreitz/dj-database-url/pull/21
}
settings['DEBUG'] = getenv_bool('DEBUG')
if 'TEMPLATE_DEBUG' in os.environ:
settings['TEMPLATE_DEBUG'] = getenv_bool('TEMPLATE_DEBUG')
else:
settings['TEMPLATE_DEBUG'] = settings['DEBUG']
settings['CACHES'] = {
'default': django_cache_url.config(default='locmem://')
}
settings.update(dj_email_url.config(default='dummy://'))
return settings
def test_setting_default_var():
config = django_cache_url.config(default='memcached://127.0.0.1:11211')
assert config['BACKEND'] == LOCATION
assert config['LOCATION'] == '127.0.0.1:11211'
def test_setting_env_var_name():
os.environ['HERP'] = 'memcached://127.0.0.1:11211'
config = django_cache_url.config(env='HERP')
assert config['BACKEND'] == LOCATION
assert config['LOCATION'] == '127.0.0.1:11211'
def test_hiredis_url_sets_hiredis_parser(self):
config = django_cache_url.config()
assert_equals(config['OPTIONS']['PARSER_CLASS'],
'redis.connection.HiredisParser')
import os
from django.core.urlresolvers import reverse_lazy
import django_cache_url
import dj_database_url
PROJECT_DIR = os.path.abspath(os.path.dirname(__file__))
ROOT_DIR = os.path.dirname(PROJECT_DIR)
DEBUG = bool(os.environ.get('DEBUG', False))
DEVELOPMENT_SITE = bool(os.environ.get('DEVELOPMENT_SITE', False))
DATABASES = {'default': dj_database_url.config(default='postgres://localhost/simplelivepoll')}
CACHES = {'default': django_cache_url.config()}
ALLOWED_HOSTS = [
'livepoll.incuna.com', 'www.livepoll.incuna.com',
'turnbullspeech.co.uk', 'www.turnbullspeech.co.uk'
]
ADMINS = (('Admin', '*****@*****.**'),)
MANAGERS = ADMINS
ADMIN_EMAILS = zip(*ADMINS)[1]
EMAIL_SUBJECT_PREFIX = '[simplelivepoll] '
SERVER_EMAIL = DEFAULT_FROM_EMAIL = '*****@*****.**'
EMAIL_BACKEND = os.environ.get('EMAIL_BACKEND', 'django.core.mail.backends.smtp.EmailBackend')
TIME_ZONE = 'UTC'
USE_L10N = True # Locale
def test_memcached_url_returns_prefix_from_url(self):
config = django_cache_url.config()
assert_equals(config['PREFIX'], 'prefix')
def test_config_defaults_to_locmem(self):
config = django_cache_url.config()
assert_equals(config['BACKEND'], self.location)
def test_db_url_returns_location_from_url(self):
config = django_cache_url.config()
assert_equals(config['LOCATION'], 'super_caching_table')
def test_memcached_url_returns_pylibmc_cache(self):
location = 'django.core.cache.backends.memcached.PyLibMCCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
def test_locmem_url_returns_locmem_cache(self):
environ['CACHE_URl'] = 'locmem://'
config = django_cache_url.config('')
assert_equals(config['BACKEND'], self.location)
def test_config_defaults_to_locmem(self):
config = django_cache_url.config()
assert_equals(config['BACKEND'], self.location)
def test_file_url_returns_location_from_url(self):
config = django_cache_url.config()
assert_equals(config['LOCATION'], '/herp')
def test_file_url_returns_file_cache_backend(self):
location = 'django.core.cache.backends.filebased.FileBasedCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
def test_dummy_url_returns_dummy_cache(self):
environ['CACHE_URL'] = 'dummy://'
location = 'django.core.cache.backends.dummy.DummyCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
def test_db_url_returns_location_from_url(self):
config = django_cache_url.config()
assert_equals(config['LOCATION'], 'super_caching_table')
DATABASES['default']['ENGINE'] = 'django.contrib.gis.db.backends.postgis'
if 'DEBUG' in environ:
DEBUG = (environ['DEBUG'].lower() == 'true')
TEMPLATE_DEBUG = DEBUG
SHOW_DEBUG_TOOLBAR = DEBUG
# Look for the following redis environment variables, in order
for REDIS_URL_ENVVAR in ('REDIS_URL', 'OPENREDIS_URL'):
if REDIS_URL_ENVVAR in environ: break
else:
REDIS_URL_ENVVAR = None
if REDIS_URL_ENVVAR:
import django_cache_url
CACHES = {'default': django_cache_url.config(env=REDIS_URL_ENVVAR)}
# Django sessions
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
# Celery broker
BROKER_URL = environ[REDIS_URL_ENVVAR].strip('/') + '/1'
if all([
key in environ
for key in ('SHAREABOUTS_AWS_KEY', 'SHAREABOUTS_AWS_SECRET',
'SHAREABOUTS_AWS_BUCKET')
]):
AWS_ACCESS_KEY_ID = environ['SHAREABOUTS_AWS_KEY']
AWS_SECRET_ACCESS_KEY = environ['SHAREABOUTS_AWS_SECRET']
AWS_STORAGE_BUCKET_NAME = environ['SHAREABOUTS_AWS_BUCKET']
def test_setting_env_var_name(self):
environ['HERP'] = 'memcached://127.0.0.1:11211'
config = django_cache_url.config(env='HERP')
assert_equals(config['BACKEND'], self.location)
assert_equals(config['LOCATION'], '127.0.0.1:11211')
def test_memcached_url_returns_location_from_url(self):
config = django_cache_url.config()
assert_equals(config['LOCATION'], '127.0.0.1:11211')
def test_file_url_returns_file_cache_backend(self):
location = 'django.core.cache.backends.filebased.FileBasedCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
# translating the EMAIL_URL env var into django email settings
email_config = dj_email_url.config(env="EMAIL_URL", default="console:")
vars().update(
email_config
) # this loads the standard django email settings such as EMAIL_HOST, etc.
# EMAIL_FROM should be included in the EMAIL_URL, see https://github.com/migonzalvar/dj-email-url#set-from-email-addresses
SERVER_EMAIL = email_config.get('SERVER_EMAIL', 'root@localhost')
DEFAULT_FROM_EMAIL = email_config.get('DEFAULT_FROM_EMAIL',
f'{SITE_NAME} <info@{DOMAIN}>')
if DJANGO_ENV == DjangoEnv.LOCAL:
CACHE_URL = 'dummy://' # to disable a warning from aldryn-django
# avoid locmem as default on production, it doesn't work properly
CACHES = {'default': django_cache_url.config(default="dummy://")}
SECURE_SSL_REDIRECT = env.bool('SECURE_SSL_REDIRECT', default=True)
# PREPEND_WWW = True (if you want to redirect domain.com/... to www.domain.com/...
HTTP_PROTOCOL = env.str('HTTP_PROTOCOL', 'https')
STATICFILES_DIRS = [
os.path.join(BASE_DIR, 'frontend/'),
]
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BACKEND_DIR, 'static_collected/')
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
STATICFILES_DEFAULT_MAX_AGE = 60 * 60 * 24 * 365 # the default is 5m
WHITENOISE_MAX_AGE = STATICFILES_DEFAULT_MAX_AGE
# Media files
def test_memcached_url_returns_pylibmc_cache(self):
location = 'django.core.cache.backends.memcached.PyLibMCCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
def factorise(custom_settings=None):
"""
Return a dict of settings for Django, acquired from the environment.
This is done in a 12factor-y way - see http://12factor.net/config
Caller probably wants to, in `settings.py`:
globals().update(factorise())
"""
settings = {}
settings['LOGGING'] = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'stdout': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
}
},
'root': {
'handlers': ['stdout'],
},
}
settings['DATABASES'] = {
'default': dj_database_url.config(default='sqlite://:memory:')
}
for (key, value) in six.iteritems(os.environ):
_SUFFIX = "_DATABASE_URL"
_OFFSET = len(_SUFFIX)
if key.endswith(_SUFFIX):
prefix = key[:-_OFFSET]
if prefix != prefix.upper():
# i.e. it was not already all upper-cased
logger.warn(
"Not parsing %s as a database url because the "
"prefix (%s) was not all upper-case - django12factor "
"will convert prefixes to lower-case for use as database "
"names" % (key, prefix))
continue
dbname = key[:-_OFFSET].lower()
if dbname == "default" and 'DATABASE_URL' in os.environ:
logger.warn(
"You have set the environment variables DATABASE_URL "
"_and_ {key}, both of which would configure "
"`DATABASES['default']`. {key} is being "
"ignored.".format(key=key))
continue
db = dj_database_url.parse(value)
settings['DATABASES'][dbname] = db
settings['DEBUG'] = getenv_bool('DEBUG')
if 'TEMPLATE_DEBUG' in os.environ:
settings['TEMPLATE_DEBUG'] = getenv_bool('TEMPLATE_DEBUG')
else:
settings['TEMPLATE_DEBUG'] = settings['DEBUG']
# Slightly opinionated...
if 'SECRET_KEY' in os.environ:
settings['SECRET_KEY'] = os.environ['SECRET_KEY']
elif not settings['DEBUG']:
sys.exit(
"""DEBUG is False but no SECRET_KEY is set in the environment -
either it has been hardcoded (bad) or not set at all (bad) - exit()ing for
safety reasons""")
settings['CACHES'] = {
'default': django_cache_url.config(default='locmem://')
}
settings.update(dj_email_url.config(default='dummy://'))
settings['ALLOWED_HOSTS'] = os.getenv('ALLOWED_HOSTS', '').split(',')
# For keys to different apis, etc.
if custom_settings is None:
custom_settings = []
for cs in custom_settings:
settings[cs] = os.getenv(cs)
return settings
def test_db_url_returns_database_cache(self):
location = 'django.core.cache.backends.db.DatabaseCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
class Base(Core):
"""Settings that may change per-environment, some with defaults."""
SECRET_KEY = values.SecretValue()
DEBUG = values.BooleanValue(default=False)
DEBUG_PROPAGATE_EXCEPTIONS = values.BooleanValue(default=False)
ALLOWED_HOSTS = values.ListValue([])
# The URL under which this instance is running
SITE_URL = values.URLValue('http://*****:*****@db/postgres')
CACHES = {
'default':
django_cache_url.config(
default='redis://redis-cache:6379/0',
env='REDIS_URL',
),
'store':
django_cache_url.config(
default='redis://redis-store:6379/0',
env='REDIS_STORE_URL',
)
}
LOGGING_USE_JSON = values.BooleanValue(False)
def LOGGING(self):
return {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'json': {
'()': 'dockerflow.logging.JsonLogFormatter',
'logger_name': 'tecken',
},
'verbose': {
'format': '%(levelname)s %(asctime)s %(name)s %(message)s',
},
},
'handlers': {
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter':
('json' if self.LOGGING_USE_JSON else 'verbose'),
},
'sentry': {
'level':
'ERROR',
'class': ('raven.contrib.django.raven_compat.handlers'
'.SentryHandler'),
},
},
'loggers': {
'root': {
'level': 'INFO',
'handlers': ['sentry', 'console'],
},
'django.db.backends': {
'level': 'ERROR',
'handlers': ['console'],
'propagate': False,
},
'raven': {
'level': 'DEBUG',
'handlers': ['console'],
'propagate': False,
},
'sentry.errors': {
'level': 'DEBUG',
'handlers': ['console'],
'propagate': False,
},
'tecken': {
'level': 'DEBUG',
'handlers': ['console'],
'propagate': False,
},
'request.summary': {
'handlers': ['console'],
'level': 'DEBUG',
'propagate': False,
},
},
}
SYMBOL_URLS = values.ListValue([
'https://s3-us-west-2.amazonaws.com/org.mozilla.crash-stats.'
'symbols-public/v1/',
])
# Number of seconds to wait for a symbol download. If this
# trips, no error will be raised and we'll just skip using it
# as a known symbol file.
# The value gets cached as an empty dict for one hour.
SYMBOLS_GET_TIMEOUT = values.Value(5)
def test_setting_default_var(self):
config = django_cache_url.config(default='memcached://127.0.0.1:11211')
assert_equals(config['BACKEND'], self.location)
assert_equals(config['LOCATION'], '127.0.0.1:11211')
# ===============================
# = Databases, Caches, Sessions =
# ===============================
DATABASES = {
'default':
dj_database_url.parse('postgres://postgres@{host}:{port}/postgres'.format(
host=os.environ.get('DB_PORT_5432_TCP_ADDR'),
port=os.environ.get('DB_PORT_5432_TCP_PORT')))
}
CACHES = {
'default':
django_cache_url.config('hiredis://{host}:{port}/1/webapp'.format(
host=os.environ.get('REDIS_PORT_6379_TCP_ADDR'),
port=os.environ.get('REDIS_PORT_6379_TCP_PORT'))),
'sessions':
django_cache_url.config('hiredis://{host}:{port}/2/webapp'.format(
host=os.environ.get('REDIS_PORT_6379_TCP_ADDR'),
port=os.environ.get('REDIS_PORT_6379_TCP_PORT'))),
}
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
SESSION_CACHE_ALIAS = 'sessions'
SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'
SESSION_COOKIE_HTTPONLY = True
# ===========================
# = Directory Declaractions =
# ===========================
class FragDenStaat(FragDenStaatBase):
DEBUG = False
TEMPLATE_DEBUG = False
CELERY_TASK_ALWAYS_EAGER = False
CELERY_TASK_EAGER_PROPAGATES = False
CELERY_SEND_TASK_ERROR_EMAILS = True
ADMINS = (('FragDenStaat.de', '*****@*****.**'), )
MANAGERS = (('FragDenStaat.de', '*****@*****.**'), )
SECURE_FRAME_DENY = True
SECURE_CONTENT_TYPE_NOSNIFF = True
SECURE_BROWSER_XSS_FILTER = True
CSRF_COOKIE_SECURE = True
SESSION_COOKIE_SECURE = True
DATA_UPLOAD_MAX_MEMORY_SIZE = 15728640
STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'
STATIC_URL = 'https://static.frag-den-staat.de/static/'
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTOCOL', 'https')
USE_X_ACCEL_REDIRECT = True
X_ACCEL_REDIRECT_PREFIX = '/protected'
ALLOWED_HOSTS = ('fragdenstaat.de', 'media.frag-den-staat.de',
'testserver')
ALLOWED_REDIRECT_HOSTS = (
'fragdenstaat.de',
'sanktionsfrei.de',
)
PAYMENT_HOST = 'fragdenstaat.de'
PAYMENT_USES_SSL = True
PAYMENT_VARIANTS = {
'creditcard': ('froide_payment.provider.StripeIntentProvider', {
'public_key': env('STRIPE_PUBLIC_KEY'),
'secret_key': env('STRIPE_PRIVATE_KEY'),
'signing_secret': env('STRIPE_WEBHOOK_CC_SIGNING_KEY'),
}),
# 'sepa': ('froide_payment.provider.StripeSourceProvider', {
# 'public_key': env('STRIPE_PUBLIC_KEY'),
# 'secret_key': env('STRIPE_PRIVATE_KEY'),
# }),
'paypal': ('payments.paypal.PaypalProvider', {
'client_id': env('PAYPAL_CLIENT_ID'),
'secret': env('PAYPAL_CLIENT_SECRET'),
'endpoint': env('PAYPAL_API_URL'),
'capture': True
}),
'sofort': (
'froide_payment.provider.StripeSofortProvider',
{
# Test API keys
'public_key': env('STRIPE_PUBLIC_KEY'),
'secret_key': env('STRIPE_PRIVATE_KEY'),
# separate Webhook signing secret
'signing_secret': env('STRIPE_WEBHOOK_SOFORT_SIGNING_KEY'),
}),
}
CACHES = {'default': django_cache_url.config()}
DATABASES = {
'default': {
'ENGINE': 'django.contrib.gis.db.backends.postgis',
'NAME': env('DATABASE_NAME'),
'OPTIONS': {},
'HOST': env('DATABASE_HOST'),
'USER': env('DATABASE_USER'),
'PASSWORD': env('DATABASE_PASSWORD'),
'PORT': ''
}
}
@property
def TEMPLATES(self):
TEMP = super(FragDenStaat, self).TEMPLATES
TEMP[0]['OPTIONS']['debug'] = False
loaders = TEMP[0]['OPTIONS']['loaders']
TEMP[0]['OPTIONS']['loaders'] = [
('django.template.loaders.cached.Loader', loaders)
]
return TEMP
CELERY_BROKER_URL = env('DJANGO_CELERY_BROKER_URL')
CUSTOM_AUTH_USER_MODEL_DB = 'auth_user'
DEFAULT_FROM_EMAIL = 'FragDenStaat.de <*****@*****.**>'
EMAIL_BACKEND = 'djcelery_email.backends.CeleryEmailBackend'
CELERY_EMAIL_BACKEND = 'froide.foirequest.smtp.EmailBackend'
# EMAIL_HOST
# EMAIL_HOST_PASSWORD
# EMAIL_HOST_USER
EMAIL_SUBJECT_PREFIX = '[AdminFragDenStaat] '
EMAIL_USE_TLS = True
EMAIL_PORT = 25
# FOI_EMAIL_ACCOUNT_NAME
# FOI_EMAIL_ACCOUNT_PASSWORD
FOI_EMAIL_DOMAIN = ['fragdenstaat.de', 'echtemail.de']
FOI_EMAIL_FIXED_FROM_ADDRESS = False
FOI_EMAIL_FUNC = None
# Values from env
# FOI_EMAIL_HOST
# FOI_EMAIL_HOST_FROM
# FOI_EMAIL_HOST_IMAP
# FOI_EMAIL_HOST_PASSWORD
# FOI_EMAIL_HOST_USER
FOI_EMAIL_PORT = 25
FOI_EMAIL_PORT_IMAP = 143
FOI_EMAIL_USE_SSL = False
FOI_EMAIL_USE_TLS = True
FOI_MEDIA_PATH = 'foi'
BOUNCE_EMAIL_PORT_IMAP = 143
GEOIP_PATH = env('DJANGO_GEOIP_PATH')
ELASTICSEARCH_INDEX_PREFIX = 'fragdenstaat_de'
ELASTICSEARCH_DSL = {
'default': {
'hosts': 'localhost:9200'
},
}
ELASTICSEARCH_DSL_SIGNAL_PROCESSOR = 'froide.helper.search.CelerySignalProcessor'
LOGGING = {
'loggers': {
'froide': {
'level': 'INFO',
'propagate': True,
'handlers': ['normal']
},
'sentry.errors': {
'handlers': ['normal'],
'propagate': False,
'level': 'DEBUG'
},
'django.request': {
'level': 'ERROR',
'propagate': True,
'handlers': ['normal']
},
'raven': {
'handlers': ['normal'],
'propagate': False,
'level': 'DEBUG'
}
},
'disable_existing_loggers': False,
'handlers': {
'normal': {
'filename': os.path.join(env('DJANGO_LOG_DIR'), 'froide.log'),
'class': 'logging.FileHandler',
'level': 'INFO'
}
},
'formatters': {
'verbose': {
'format':
'%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
}
},
'version': 1,
'filters': {
'require_debug_false': {
'()': 'django.utils.log.RequireDebugFalse'
}
},
'root': {
'handlers': ['normal'],
'level': 'WARNING'
}
}
MANAGERS = (('FragDenStaat.de', '*****@*****.**'), )
MEDIA_ROOT = env('DJANGO_MEDIA_ROOT')
MEDIA_URL = 'https://media.frag-den-staat.de/files/'
FOI_MEDIA_TOKENS = True
FOI_MEDIA_DOMAIN = 'https://media.frag-den-staat.de'
FILE_UPLOAD_DIRECTORY_PERMISSIONS = 0o2750
FILE_UPLOAD_PERMISSIONS = 0o640
SECRET_KEY = env('DJANGO_SECRET_KEY')
SECRET_URLS = {'admin': env('DJANGO_SECRET_URL_ADMIN')}
THUMBNAIL_OPTIMIZE_COMMAND = {
'png': '/usr/bin/optipng {filename}',
'gif': '/usr/bin/optipng {filename}',
'jpeg': '/usr/bin/jpegoptim {filename}'
}
_base_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..'))
RAVEN_CONFIG = {'release': raven.fetch_git_sha(_base_dir)}
if env('DJANGO_SENTRY_DSN') is not None:
RAVEN_CONFIG['dsn'] = env('DJANGO_SENTRY_DSN')
RAVEN_JS_URL = env('DJANGO_SENTRY_PUBLIC_DSN')
SERVER_EMAIL = '*****@*****.**'
SITE_EMAIL = '*****@*****.**'
SITE_ID = 1
SITE_NAME = 'FragDenStaat'
SITE_URL = 'https://fragdenstaat.de'
META_SITE_PROTOCOL = 'https'
TASTYPIE_DEFAULT_FORMATS = ['json']
@property
def OAUTH2_PROVIDER(self):
P = super(FragDenStaat, self).OAUTH2_PROVIDER
P['ALLOWED_REDIRECT_URI_SCHEMES'] = ['https', 'fragdenstaat']
return P
WSGI_APPLICATION = 'ology.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.8/ref/settings/#databases
DATABASES = {
'default': dj_database_url.config(env='DATABASE_URL')
}
if DATABASES['default']['ENGINE'] == 'django.db.backends.postgresql_psycopg2':
DATABASES['default']['OPTIONS'] = {}
DATABASES['default']['OPTIONS']['autocommit'] = True
CACHES = {
'default': django_cache_url.config(env='DEFAULT_CACHE_URL')
}
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'
# Internationalization
# https://docs.djangoproject.com/en/1.8/topics/i18n/
LANGUAGE_CODE = 'zh-hant'
TIME_ZONE = 'Asia/Taipei'
USE_I18N = True
USE_L10N = True
def test_setting_env_var():
os.environ['CACHE_URL'] = 'redis://127.0.0.1:6379/0?key_prefix=site1'
config = django_cache_url.config()
assert config['BACKEND'] == 'django_redis.cache.RedisCache'
assert config['LOCATION'] == 'redis://127.0.0.1:6379/0'
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.9/howto/static-files/
STATIC_URL = '/static/'
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
STATIC_ROOT = '/mnt/static'
# Caches settings
CACHES = {'default': django_cache_url.config('REDIS_URL')}
# Celery settings
BROKER_URL = os.getenv('REDIS_URL')
CELERY_RESULT_BACKEND = BROKER_URL
CELERY_ACCEPT_CONTENT = ['json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
# Ceryx settings
CERYX_API_HOST = os.getenv('STOLOS_WATCHD_CERYX_API_HOST')
# Docker settings
def factorise(custom_settings=None):
"""
Return a dict of settings for Django, acquired from the environment.
This is done in a 12factor-y way - see http://12factor.net/config
Caller probably wants to, in `settings.py`:
globals().update(factorise())
"""
settings = {}
settings['LOGGING'] = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'stdout': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
}
},
'root': {
'handlers': ['stdout'],
},
}
settings['DATABASES'] = {
'default': dj_database_url.config(default='sqlite://:memory:')
}
settings['DEBUG'] = getenv_bool('DEBUG')
if 'TEMPLATE_DEBUG' in os.environ:
settings['TEMPLATE_DEBUG'] = getenv_bool('TEMPLATE_DEBUG')
else:
settings['TEMPLATE_DEBUG'] = settings['DEBUG']
# Slightly opinionated...
if 'SECRET_KEY' in os.environ:
settings['SECRET_KEY'] = os.environ['SECRET_KEY']
elif not settings['DEBUG']:
sys.exit("""DEBUG is False but no SECRET_KEY is set in the environment -
either it has been hardcoded (bad) or not set at all (bad) - exit()ing for
safety reasons""")
settings['CACHES'] = {
'default': django_cache_url.config(default='locmem://')
}
settings.update(dj_email_url.config(default='dummy://'))
settings['ALLOWED_HOSTS'] = os.getenv('ALLOWED_HOSTS', '').split(',')
# For keys to different apis, etc.
if custom_settings is None:
custom_settings = []
for cs in custom_settings:
settings[cs] = os.getenv(cs)
return settings
import mimetypes
import os
from django.core.urlresolvers import reverse_lazy
import django_cache_url
import dj_database_url
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
ROOT_DIR = os.path.join(BASE_DIR, os.path.pardir)
DEBUG = bool(os.environ.get('DEBUG', False))
DATABASES = {'default': dj_database_url.config(default='postgres://localhost/{{ project_name }}')}
CACHES = {'default': django_cache_url.config(default='memcached://127.0.0.1:11211')}
ADMINS = (('Admin', '*****@*****.**'),)
ADMIN_EMAILS = zip(*ADMINS)[1]
EMAIL_SUBJECT_PREFIX = '[{{ project_name }}] '
EMAIL_BACKEND = os.environ.get('EMAIL_BACKEND', 'django.core.mail.backends.smtp.EmailBackend')
TIME_ZONE = 'UTC'
USE_L10N = True # Locale
USE_TZ = True
LANGUAGE_CODE = 'en-GB'
USE_I18N = False # Internationalization
# AWS
AWS_ACCESS_KEY_ID = os.environ.get('AWS_ACCESS_KEY_ID')
def test_setting_default_var(self):
config = django_cache_url.config(default='memcached://127.0.0.1:11211')
assert_equals(config['BACKEND'], self.location)
assert_equals(config['LOCATION'], '127.0.0.1:11211')
def test_config_defaults_to_locmem():
if os.environ.get('CACHE_URL'):
del os.environ['CACHE_URL']
config = django_cache_url.config()
assert config['BACKEND'] == 'django.core.cache.backends.locmem.LocMemCache'
def test_db_url_returns_database_cache(self):
location = 'django.core.cache.backends.db.DatabaseCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
from functools import wraps
import django_cache_url
# import redis
from graphql_jwt import exceptions
from graphql_jwt.decorators import context
_cache_url = django_cache_url.config().get("LOCATION")
# _blacklist_storage = redis.StrictRedis(decode_responses=True).from_url(_cache_url)
BANNED_TOKENS_COLLECTION = "banned_tokens_collection"
def _user_passes_test(test_func):
def decorator(f):
@wraps(f)
@context(f)
def wrapper(context, *args, **kwargs):
if test_func(context):
return f(*args, **kwargs)
raise exceptions.PermissionDenied()
return wrapper
return decorator
# def _blacklisted_token(token):
# return _blacklist_storage.sismember(BANNED_TOKENS_COLLECTION, token)
def test_dummy_url_returns_dummy_cache(self):
environ['CACHE_URL'] = 'dummy://'
location = 'django.core.cache.backends.dummy.DummyCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
SITE_ID = 1
PROJECT_ROOT = os.path.normpath(os.path.join(os.path.dirname(__file__), ".."))
ROOT_URLCONF = "saleor.urls"
WSGI_APPLICATION = "saleor.wsgi.application"
ADMINS = (
# ('Your Name', '*****@*****.**'),
)
MANAGERS = ADMINS
INTERNAL_IPS = os.environ.get("INTERNAL_IPS", "127.0.0.1").split()
CACHES = {"default": django_cache_url.config()}
if os.environ.get("REDIS_URL"):
CACHES["default"] = {"BACKEND": "django_redis.cache.RedisCache", "LOCATION": os.environ.get("REDIS_URL")}
SQLITE_DB_URL = "sqlite:///" + os.path.join(PROJECT_ROOT, "dev.sqlite")
DATABASES = {"default": dj_database_url.config(default=SQLITE_DB_URL)}
TIME_ZONE = "America/Chicago"
LANGUAGE_CODE = "en-us"
USE_I18N = True
USE_L10N = True
USE_TZ = True
def test_file_url_returns_location_from_url(self):
config = django_cache_url.config()
assert_equals(config['LOCATION'], '/herp')
def test_hiredis_url_sets_hiredis_parser(self):
config = django_cache_url.config()
assert_equals(config['OPTIONS']['PARSER_CLASS'],
'redis.connection.HiredisParser')
def test_locmem_url_returns_locmem_cache(self):
environ['CACHE_URl'] = 'locmem://'
config = django_cache_url.config('')
assert_equals(config['BACKEND'], self.location)
SITE_ID = 1
PROJECT_ROOT = os.path.normpath(os.path.join(os.path.dirname(__file__), '..'))
ROOT_URLCONF = 'saleor.urls'
WSGI_APPLICATION = 'saleor.wsgi.application'
ADMINS = (
# ('Your Name', '*****@*****.**'),
)
MANAGERS = ADMINS
INTERNAL_IPS = get_list(os.environ.get('INTERNAL_IPS', '127.0.0.1'))
CACHES = {'default': django_cache_url.config()}
if os.environ.get('REDIS_URL'):
CACHES['default'] = {
'BACKEND': 'django_redis.cache.RedisCache',
'LOCATION': os.environ.get('REDIS_URL')
}
DATABASES = {
'default':
dj_database_url.config(
default='postgres://*****:*****@localhost:5432/biglight',
conn_max_age=600)
}
DEFAULT_TAX_RATE_COUNTRY = 'FR'
def test_memcached_url_returns_location_from_url(self):
config = django_cache_url.config()
assert_equals(config['LOCATION'], '127.0.0.1:11211')
DATABASES['default']['ENGINE'] = 'django.contrib.gis.db.backends.postgis'
if 'DEBUG' in environ:
DEBUG = (environ['DEBUG'].lower() == 'true')
TEMPLATE_DEBUG = DEBUG
SHOW_DEBUG_TOOLBAR = DEBUG
# Look for the following redis environment variables, in order
for REDIS_URL_ENVVAR in ('REDIS_URL', 'OPENREDIS_URL'):
if REDIS_URL_ENVVAR in environ: break
else:
REDIS_URL_ENVVAR = None
if REDIS_URL_ENVVAR:
import django_cache_url
CACHES = {'default': django_cache_url.config(env=REDIS_URL_ENVVAR)}
# Django sessions
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
# Celery broker
BROKER_URL = environ[REDIS_URL_ENVVAR].strip('/') + '/1'
if all([key in environ for key in ('SHAREABOUTS_AWS_KEY',
'SHAREABOUTS_AWS_SECRET',
'SHAREABOUTS_AWS_BUCKET')]):
AWS_ACCESS_KEY_ID = environ['SHAREABOUTS_AWS_KEY']
AWS_SECRET_ACCESS_KEY = environ['SHAREABOUTS_AWS_SECRET']
AWS_STORAGE_BUCKET_NAME = environ['SHAREABOUTS_AWS_BUCKET']
AWS_QUERYSTRING_AUTH = False
AWS_PRELOAD_METADATA = True
ROOT_URLCONF = '{{ cookiecutter.app_name }}.urls'
WSGI_APPLICATION = '{{ cookiecutter.app_name }}.wsgi.application'
# Database
# https://docs.djangoproject.com/en/dev/ref/settings/#databases
DATABASES = {
'default':
dj_database_url.parse(excavator.env_string('DATABASE_URL', required=True)),
}
DATABASES['default'].setdefault('ATOMIC_REQUESTS', True)
# Cache
CACHES = {
'default': django_cache_url.config(),
}
# Internationalization
# https://docs.djangoproject.com/en/dev/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'MST'
USE_I18N = True
USE_L10N = True
USE_TZ = True
def test_setting_env_var_name(self):
environ['HERP'] = 'memcached://127.0.0.1:11211'
config = django_cache_url.config(env='HERP')
assert_equals(config['BACKEND'], self.location)
assert_equals(config['LOCATION'], '127.0.0.1:11211')
"local_agent": {
"reporting_port":
os.environ.get("JAEGER_AGENT_PORT",
jaeger_client.config.DEFAULT_REPORTING_PORT),
"reporting_host":
os.environ.get("JAEGER_AGENT_HOST"),
},
"logging": get_bool_from_env("JAEGER_LOGGING", False),
},
service_name="saleor",
validate=True,
).initialize_tracer()
# Some cloud providers (Heroku) export REDIS_URL variable instead of CACHE_URL
REDIS_URL = os.environ.get("REDIS_URL")
if REDIS_URL:
CACHE_URL = os.environ.setdefault("CACHE_URL", REDIS_URL)
CACHES = {"default": django_cache_url.config()}
# Default False because storefront and dashboard don't support expiration of token
JWT_EXPIRE = get_bool_from_env("JWT_EXPIRE", False)
JWT_TTL_ACCESS = timedelta(
seconds=parse(os.environ.get("JWT_TTL_ACCESS", "5 minutes")))
JWT_TTL_APP_ACCESS = timedelta(
seconds=parse(os.environ.get("JWT_TTL_APP_ACCESS", "5 minutes")))
JWT_TTL_REFRESH = timedelta(
seconds=parse(os.environ.get("JWT_TTL_REFRESH", "30 days")))
JWT_TTL_REQUEST_EMAIL_CHANGE = timedelta(seconds=parse(
os.environ.get("JWT_TTL_REQUEST_EMAIL_CHANGE", "1 hour")), )
def test_memcached_url_multiple_locations(self):
environ['CACHE_URL'] = 'memcached://127.0.0.1:11211,192.168.0.100:11211/prefix'
config = django_cache_url.config()
assert_equals(config['LOCATION'], ['127.0.0.1:11211', '192.168.0.100:11211'])
volunteer)
ROOT_URLCONF = '{{ cookiecutter.app_name }}.urls'
WSGI_APPLICATION = '{{ cookiecutter.app_name }}.wsgi.application'
# Database
# https://docs.djangoproject.com/en/dev/ref/settings/#databases
DATABASES = {
'default': dj_database_url.parse(excavator.env_string('DATABASE_URL', required=True)),
}
DATABASES['default'].setdefault('ATOMIC_REQUESTS', True)
# Cache
CACHES = {
'default': django_cache_url.config(),
}
# Internationalization
# https://docs.djangoproject.com/en/dev/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'MST'
USE_I18N = True
USE_L10N = True
USE_TZ = True
def test_hiredis_url_returns_redis_cache(self):
location = 'redis_cache.cache.RedisCache'
config = django_cache_url.config()
assert_equals(config['BACKEND'], location)
def test_hiredis_url_returns_location_and_port_from_url(self):
config = django_cache_url.config()
assert_equals(config['LOCATION'], '127.0.0.1:6379:0')
def test_hiredis_url_returns_prefix_from_url(self):
config = django_cache_url.config()
assert_equals(config['KEY_PREFIX'], 'prefix')
def test_config_defaults_to_locmem():
if os.environ.get('CACHE_URL'):
del os.environ['CACHE_URL']
config = django_cache_url.config()
assert config['BACKEND'] == 'django.core.cache.backends.locmem.LocMemCache'
def test_socket_url_returns_prefix_from_url(self):
config = django_cache_url.config()
assert_equals(config['KEY_PREFIX'], 'prefix')
