class Public(email.Email, databases.Databases, common.Common):
"""General settings for all public servers."""
CSRF_COOKIE_HTTPONLY = True
SECRET_KEY = values.SecretValue()
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
SILENCED_SYSTEM_CHECKS = values.ListValue([])
X_FRAME_OPTIONS = 'DENY'
class Email(object):
"""Email settings for SMTP."""
EMAIL_HOST = values.Value('localhost')
EMAIL_HOST_PASSWORD = values.SecretValue()
EMAIL_HOST_USER = values.Value('*****@*****.**')
EMAIL_PORT = values.IntegerValue(465)
EMAIL_USE_SSL = values.BooleanValue(True)
EMAIL_USE_TLS = values.BooleanValue(False)
class Production(Staging):
"""
The in-production settings.
"""
AWS_REGION = values.Value("us-east-1", environ_prefix=None)
AWS_ACCESS_KEY_ID = values.SecretValue(environ_prefix=None)
AWS_SECRET_ACCESS_KEY = values.SecretValue(environ_prefix=None)
AWS_S3_BUCKET_NAME = values.Value(environ_prefix=None)
CONTRACTS_DOCUMENT_STORAGE = "django_s3_storage.storage.S3Storage"
@property
def CACHES(self):
return {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": f"{self.REDIS_URL}/1",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient"
},
}
}
class Production(Development):
"""
Production settings.
"""
DEBUG = False
TEMPLATE_DEBUG = DEBUG
# Empty by design to trigger a warning to fill it with something sensible.
SECRET_KEY = values.SecretValue()
# Switch the Celery broker URL to RabbitMQ
BROKER_URL = 'amqp://*****:*****@localhost:5672//'
CELERY_ALWAYS_EAGER = False
class Staging(BaseConfiguration):
DEBUG = False
# SENTRY_DSN = values.URLValue(environ_required=True)
STATIC_ROOT = "/host/static/"
MEDIA_ROOT = "/host/uploads/"
ALLOWED_HOSTS = ['*']
SECRET_KEY = values.SecretValue()
# EMAIL = values.EmailURLValue()
@classmethod
def post_setup(cls):
print('Using Staging config')
class Email(object):
"""Email settings for SMTP."""
EMAIL_HOST = values.Value('localhost')
EMAIL_HOST_PASSWORD = values.SecretValue()
EMAIL_HOST_USER = values.Value('*****@*****.**')
EMAIL_PORT = values.IntegerValue(465)
EMAIL_USE_SSL = values.BooleanValue(True)
EMAIL_USE_TLS = values.BooleanValue(False)
class Email(object):
"""Email settings for SMTP."""
EMAIL_HOST = values.Value('localhost')
EMAIL_HOST_PASSWORD = values.SecretValue()
EMAIL_HOST_USER = values.Value('*****@*****.**')
EMAIL_PORT = values.IntegerValue(465)
EMAIL_USE_SSL = values.BooleanValue(True)
EMAIL_USE_TLS = values.BooleanValue(False)
class Prod(Common):
"""Configuration settings used in production."""
# Ensure debug is always false in production
DEBUG = False
# Require that a `DJANGO_SECRET_KEY` environment
# variable is set during production
SECRET_KEY = values.SecretValue()
# In production, use wildcard because load balancers
# perform health checks without host specific Host header value
ALLOWED_HOSTS = ['*']
# Additional apps only used in production
INSTALLED_APPS = Common.INSTALLED_APPS + [
'raven.contrib.django.raven_compat'
]
# JWT secret must be set as environment
# variable when in production
JWT_SECRET = values.SecretValue()
# Ensure that the beta token is set
BETA_TOKEN = values.SecretValue()
# Use GoogleCloudStorage for uploads
DEFAULT_FILE_STORAGE = 'lib.storage.CustomPublicGoogleCloudStorage'
GS_PROJECT_ID = values.Value()
GS_BUCKET_NAME = values.Value()
# Use SendGrid for emails
EMAIL_BACKEND = 'sendgrid_backend.SendgridBackend'
SENDGRID_API_KEY = values.SecretValue()
# Use Sentry for error reporting
RAVEN_CONFIG = {'dsn': values.Value(environ_name='SENTRY_DSN')}
class StadeMixin(ConfigMixin):
WSGI_APPLICATION = 'stade.wsgi.application'
ROOT_URLCONF = 'stade.urls'
BASE_DIR = Path(__file__).resolve(strict=True).parent.parent
@staticmethod
def before_binding(configuration: ComposedConfiguration) -> None:
# Install local apps first, to ensure any overridden resources are found first
configuration.INSTALLED_APPS = [
'stade.core.apps.CoreConfig',
'stade.tracker.apps.TrackerConfig',
# jazzmin overrides django.contrib.admin templates
# jazzmin is broken as of Django 3.2, see https://github.com/farridav/django-jazzmin/issues/281 # noqa
# 'jazzmin',
] + configuration.INSTALLED_APPS
# Install additional apps
configuration.INSTALLED_APPS += [
'import_export',
'markdownify',
'rules.apps.AutodiscoverRulesConfig',
's3_file_field',
]
configuration.AUTHENTICATION_BACKENDS.insert(
0, 'rules.permissions.ObjectPermissionBackend')
JAZZMIN_SETTINGS = {'related_modal_active': True}
SHELL_PLUS_IMPORTS = ['from stade.core.tasks import *']
TIME_ZONE = 'America/New_York'
# Celery
# TODO: concurrency could be increased for non-memory intensive tasks
CELERY_WORKER_CONCURRENCY = 1
MARKDOWNIFY_BLEACH = False
STADE_MAILCHIMP_API_URL = 'https://us17.api.mailchimp.com/'
STADE_MAILCHIMP_API_KEY = values.SecretValue()
STADE_MAILCHIMP_LIST_ID = 'aa0e7aa1b1'
# TODO: is this needed?
ACCOUNT_FORMS = {
'signup': 'stade.core.forms.CustomSignupForm',
'reset_password_from_key':
'stade.core.forms.CustomResetPasswordKeyForm',
}
class BaseAuthConfigurationMixin:
"""
Basic Mixin class which all django projects using this library should include
"""
MAFIASI_AUTH_APPS = ["django_auth_mafiasi"]
"List of apps which need to be added to django's " \
"`INSTALLED_APPS <https://docs.djangoproject.com/en/3.1/ref/settings/#installed-apps>`_"
AUTH_GET_USER_FROM_ID_TOKEN_FUNCTION = "django_auth_mafiasi.auth.get_user_from_id_token"
"Import path of a function which is used when a user object needs to be derived from an OpenId **ID token**"
AUTH_GET_USER_FROM_ACCESS_TOKEN_FUNCTION = "django_auth_mafiasi.auth.get_user_from_access_token"
"Import path of a function which is used when a user object needs to be derived from an OpenId **access token**"
AUTH_USER_MODEL = "django_auth_mafiasi.MafiasiAuthModelUser"
"See `django documentation <https://docs.djangoproject.com/en/3.1/ref/settings/#auth-user-model>`_." \
"If you override this, your new model should inherit from MafiasiAuthModelUser"
AUTH_SERVER = values.URLValue(default="https://identity.mafiasi.de/auth/realms/mafiasi")
"OpenId Issuer. This defaults to our Mafiasi server but theoretically, any OpenId Issuer can be used"
AUTH_CLIENT_ID = values.Value(environ_required=True)
"OpenId client id\n\n" \
"It needs to be manually retrieved from the OpenId server and uniquely identifies this application"
AUTH_CLIENT_SECRET = values.SecretValue(environ_required=True)
"OpenId client secret\n\n" \
"It needs to be manually retrieved from the OpenId server and authenticates this application (not the user)"
AUTH_SCOPE = values.ListValue(default=["openid"])
"Scopes to request when logging a user in on the OpenId provider"
AUTH_STAFF_GROUPS = values.ListValue(default=["Server-AG"])
"Which groups are considered to be staff (have access to the admin panel)"
AUTH_SUPERUSER_GROUPS = values.ListValue(default=["Server-AG"])
"Which groups are considered to be superusers (have access to everything)"
REST_FRAMEWORK_REQUIRED_SCOPES = values.ListValue(default=["openid"])
"Scopes to which an access token needs to have access to in order to be allowed access the an API secured by the rest framework authenticator"
LOGIN_REDIRECT_URL = "/"
"Where to redirect a user after successful login"
LOGOUT_REDIRECT_URL = "/"
"Where to redirect a user after logout"
LOGIN_URL = "django_auth_mafiasi:login"
class Staging(BaseSettings):
SECRET_KEY = values.SecretValue()
# Security
SESSION_COOKIE_SECURE = values.BooleanValue(True)
SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_HSTS_SECONDS = values.IntegerValue(31536000)
SECURE_REDIRECT_EXEMPT = values.ListValue([])
SECURE_SSL_HOST = values.Value(None)
SECURE_SSL_REDIRECT = values.BooleanValue(True)
SECURE_PROXY_SSL_HEADER = values.TupleValue(
('HTTP_X_FORWARDED_PROTO', 'https'))
class Local(Common):
# DEBUG
DEBUG = values.BooleanValue(True)
TEMPLATE_DEBUG = DEBUG
# END DEBUG
# INSTALLED_APPS
INSTALLED_APPS = Common.INSTALLED_APPS
# END INSTALLED_APPS
# DATABASE CONFIGURATION
# See: https://docs.djangoproject.com/en/dev/ref/settings/#databases
# DATABASES = values.DatabaseURLValue('postgres://localhost/volunteerapp')
DATABASE_PWD = values.SecretValue(environ_prefix="",
environ_name="VOLAPP_DATABASE_PWD")
DATABASES = values.DatabaseURLValue('postgres://*****:*****@127.0.0.1:5432/' + 'volunteerapp')
# END DATABASE CONFIGURATION
# Mail settings
EMAIL_HOST = 'localhost'
EMAIL_PORT = 1025
EMAIL_BACKEND = values.Value(
'django.core.mail.backends.console.EmailBackend')
# End mail settings
# django-debug-toolbar
MIDDLEWARE_CLASSES = Common.MIDDLEWARE_CLASSES + (
'debug_toolbar.middleware.DebugToolbarMiddleware', )
INSTALLED_APPS += (
'debug_toolbar',
'django_extensions',
)
INTERNAL_IPS = (
'127.0.0.1',
'10.0.2.2',
)
DEBUG_TOOLBAR_CONFIG = {
'DISABLE_PANELS': [
'debug_toolbar.panels.redirects.RedirectsPanel',
],
'SHOW_TEMPLATE_CONTEXT': True,
}
class Development(Base):
DEBUG = values.BooleanValue(True)
SECRET_KEY = values.SecretValue()
POSTGRES_USER = os.environ.get('POSTGRES_USER', 'postgres')
POSTGRES_PASSWORD = os.environ.get('POSTGRES_PASSWORD', '')
DATABASE_HOST = os.environ.get('DATABASE_HOST', 'localhost')
POSTGRES_DB = os.environ.get('POSTGRES_DB', 'postgres')
DATABASE_URL = 'postgis://%s:%s@%s/%s' % (
POSTGRES_USER, POSTGRES_PASSWORD, DATABASE_HOST, POSTGRES_DB
)
DATABASES = values.DatabaseURLValue(DATABASE_URL)
ALLOWED_HOSTS = ['*']
class Production(Common):
DEBUG = False
TEMPLATE_DEBUG = False
SECRET_KEY = values.SecretValue(environ_prefix='ORE')
# EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
ADMINS = ((str(values.Value(
'xxx', environ_prefix='ORE', environ_name='ADMIN_NAME')),
str(values.Value(
'xxx', environ_prefix='ORE', environ_name='ADMIN_EMAIL'))),)
PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__))
TEMPLATE_DIRS = (PROJECT_ROOT + '/templates',
PROJECT_ROOT + '/static-release/img')
LOGGING = Common.LOGGING
LOGGING['loggers']['django.request']['handlers'] = ['mail_admins']
LOGGING['loggers']['ore']['handlers'] = ['console']
FOOTER = values.Value('ORE Development Team', environ_prefix='ORE')
class Staging(Base, Configuration):
BITCORE_SERVER_TYPE = "sta"
DEBUG = values.BooleanValue(True)
BASE_DIR = Base.BASE_DIR
SECRET_KEY = values.SecretValue()
DOMAIN_NAME = os.getenv('DOMAIN_NAME')
ALLOWED_HOSTS = [
"127.0.0.1",
"0.0.0.0",
"localhost",
"staging." + DOMAIN_NAME + ".local",
DOMAIN_NAME + ".com"
]
# WEBSOCKETS - DJANGO CHANNELS
ASGI_APPLICATION = "config.routing.application"
CHANNEL_LAYERS = {
'default': {
"BACKEND": "channels_redis.core.RedisChannelLayer",
"CONFIG": {
"hosts": [("redis", 6379)],
},
}
}
# HAYSTACK CONFIGURATION
HAYSTACK_SIGNAL_PROCESSOR = 'haystack.signals.RealtimeSignalProcessor'
HAYSTACK_CONNECTIONS = {
'default': {
'ENGINE': 'haystack.backends.elasticsearch2_backend.Elasticsearch2SearchEngine',
'URL': 'http://elasticsearch:9200/',
'INDEX_NAME': 'haystack',
},
}
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': "postgres",
'USER': "******",
'PASSWORD': "******",
'HOST': "postgres",
'PORT': 5432
}
}
class Production(Base):
"""Production environment settings
You must define the DJANGO_ALLOWED_HOSTS and DJANGO_SECRET_KEY environment
variables in Production configuration (and derived configurations):
DJANGO_ALLOWED_HOSTS="foo.com,foo.fr"
DJANGO_SECRET_KEY="your-secret-key"
"""
# Security
SECRET_KEY = values.SecretValue()
ALLOWED_HOSTS = values.ListValue(None)
CSRF_COOKIE_SECURE = True
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
SESSION_COOKIE_SECURE = True
# For static files in production, we want to use a backend that includes a hash in
# the filename, that is calculated from the file content, so that browsers always
# get the updated version of each file.
STATICFILES_STORAGE = (
"django.contrib.staticfiles.storage.ManifestStaticFilesStorage")
# For more details about CMS_CACHE_DURATION, see :
# http://docs.django-cms.org/en/latest/reference/configuration.html#cms-cache-durations
CMS_CACHE_DURATIONS = values.DictValue({
"menus": 3600,
"content": 86400,
"permissions": 86400
})
# By default, Django CMS sends cached responses with a
# Cache-control: max-age value that reflects the server cache TTL
# (CMS_CACHE_DURATIONS["content"])
#
# The thing is : we can invalidate a server side cache entry, but we cannot
# invalidate our client browser cache entries. That's why we want to set a
# long TTL on the server side, but a much lower TTL on the browser cache.
#
# This setting allows to define a maximum value for the max-age header
# returned by Django CMS views.
MAX_BROWSER_CACHE_TTL = 600
class Stage(Common):
DEBUG = True
SECRET_KEY = values.SecretValue()
EMAIL_HOST = values.Value('localhost')
EMAIL_HOST_USER = values.Value()
EMAIL_HOST_PASSWORD = values.Value()
EMAIL_PORT = values.Value()
EMAIL_USE_TLS = values.BooleanValue(False)
Common.LOGGING['handlers']['sentry'] = { 'class': 'raven.contrib.django.raven_compat.handlers.SentryHandler', }
Common.LOGGING['loggers'] = {
'': {
'handlers': ['sentry'],
'level': Common.LOG_LEVEL,
'propagate': True,
}
}
class _Security:
"""Configure security"""
SECRET_KEY = values.SecretValue()
# Use PBKDF2PasswordHasher that uses 4 times the default number of iterations
PASSWORD_HASHERS = [
'ctflex.hashers.PBKDF2PasswordHasher4',
'django.contrib.auth.hashers.PBKDF2PasswordHasher'
]
# Number of days that a password reset link is valid for
PASSWORD_RESET_TIMEOUT_DAYS = 1
# Request modern browsers to block suspected XSS attacks. Not to be relied upon.
SECURE_BROWSER_XSS_FILTER = True
# Prevent browsers from guessing content types (reducing security risk).
SECURE_CONTENT_TYPE_NOSNIFF = True
# Minimum password strength validation
AUTH_PASSWORD_VALIDATORS = [
{
'NAME':
'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.MinimumLengthValidator',
'OPTIONS': {
'min_length': 10,
}
},
{
'NAME':
'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
class Production(Common):
# This ensures that Django will be able to detect a secure connection
# properly on Heroku.
# SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
# INSTALLED_APPS
INSTALLED_APPS = Common.INSTALLED_APPS
# END INSTALLED_APPS
# SECRET KEY
SECRET_KEY = values.SecretValue()
# END SECRET KEY
# sentry
RAVEN_CONFIG = values.DictValue()
INSTALLED_APPS += ('raven.contrib.django.raven_compat', )
# end sentry
# django-secure
# INSTALLED_APPS += ("djangosecure", )
# set this to 60 seconds and then to 518400 when you can prove it works
# SECURE_HSTS_SECONDS = 60
# SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
# SECURE_FRAME_DENY = values.BooleanValue(True)
# SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
# SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
# SESSION_COOKIE_SECURE = values.BooleanValue(False)
# SESSION_COOKIE_HTTPONLY = values.BooleanValue(True)
# SECURE_SSL_REDIRECT = values.BooleanValue(True)
# end django-secure
# SITE CONFIGURATION
# Hosts/domain names that are valid for this site
# See https://docs.djangoproject.com/en/1.6/ref/settings/#allowed-hosts
ALLOWED_HOSTS = ["*"]
# END SITE CONFIGURATION
INSTALLED_APPS += ("gunicorn", )
class Production(Base):
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DEBUG = False
SECRET_KEY = values.SecretValue()
ALLOWED_HOSTS = ['.kinesicband.com']
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': os.environ.get('DB_DEFAULT_NAME'),
'HOST': os.environ.get('DB_DEFAULT_HOST'),
'PORT': os.environ.get('DB_DEFAULT_PORT'),
'USER': os.environ.get('DB_DEFAULT_USER'),
'PASSWORD': os.environ.get('DB_DEFAULT_PASSWORD'),
},
}
class Production(Common):
@property
def JWT_AUTH(self):
return get_jwt_auth()
DEBUG = False
TEMPLATE_DEBUG = DEBUG
PAGE_CACHE_SECONDS = values.IntegerValue(1)
# TODO: n a real production server this should have a proper url
ALLOWED_HOSTS = values.ListValue(['getfission.com'])
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = values.SecretValue()
# ########### Sentry configuration
RAVEN_DSN = values.URLValue()
RAVEN_CONFIG = {'dsn': os.environ.get('RAVEN_DSN')}
class Production(Common):
# INSTALLED_APPS
INSTALLED_APPS = Common.INSTALLED_APPS
# END INSTALLED_APPS
# SECRET KEY
SECRET_KEY = values.SecretValue()
# END SECRET KEY
# django-secure
INSTALLED_APPS += ("djangosecure", )
# set this to 60 seconds and then to 518400 when you can prove it works
SECURE_HSTS_SECONDS = 60
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_FRAME_DENY = values.BooleanValue(True)
SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
SESSION_COOKIE_SECURE = values.BooleanValue(False)
SESSION_COOKIE_HTTPONLY = values.BooleanValue(True)
SECURE_SSL_REDIRECT = values.BooleanValue(True)
# end django-secure
# SITE CONFIGURATION
# Hosts/domain names that are valid for this site
# See https://docs.djangoproject.com/en/1.6/ref/settings/#allowed-hosts
ALLOWED_HOSTS = ["*"]
# END SITE CONFIGURATION
# TEMPLATE CONFIGURATION
# See: https://docs.djangoproject.com/en/dev/ref/settings/#template-dirs
TEMPLATE_LOADERS = (('django.template.loaders.cached.Loader', (
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
)), )
# END TEMPLATE CONFIGURATION
# GA configuration
GOOGLE_ANALYTICS_PROPERTY_ID = values.Value()
GOOGLE_ANALYTICS_DOMAIN = values.Value()
class Dev(BaseSettings):
# .env file used to set environment variables locally during development
DOTENV = join(BaseSettings.ROOT_DIR, '.env')
SECRET_KEY = values.SecretValue()
DEBUG = values.BooleanValue(True)
DATABASES = values.DatabaseURLValue(
'postgresql://*****:*****@localhost:15432/dev')
INTERNAL_IPS = ['127.0.0.1']
INSTALLED_APPS = BaseSettings.INSTALLED_APPS + [
'debug_toolbar',
]
MIDDLEWARE = BaseSettings.MIDDLEWARE + [
'debug_toolbar.middleware.DebugToolbarMiddleware'
]
class Production(Common):
INSTALLED_APPS = Common.INSTALLED_APPS
SECRET_KEY = values.SecretValue()
GEOS_LIBRARY_PATH = values.Value('', environ_prefix=False)
GDAL_LIBRARY_PATH = values.Value('', environ_prefix=False)
PROJ4_LIBRARY_PATH = values.Value('', environ_prefix=False)
ALLOWED_HOSTS = ['beta.tulsawebdevs.org', 'twd.destos.com']
# django-secure
# This ensures that Django will be able to detect a secure connection
# properly on Heroku.
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
# Django secure disabled for now TODO, get ssl key for beta server
# INSTALLED_APPS += ("djangosecure", )
# set this to 60 seconds and then to 518400 when you can prove it works
SECURE_HSTS_SECONDS = 60
SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True)
SECURE_FRAME_DENY = values.BooleanValue(True)
SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True)
SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True)
SESSION_COOKIE_SECURE = values.BooleanValue(False)
SESSION_COOKIE_HTTPONLY = values.BooleanValue(True)
SECURE_SSL_REDIRECT = values.BooleanValue(True)
# end django-secure
INSTALLED_APPS += ("gunicorn", )
# Simplified static file serving.
# https://warehouse.python.org/project/whitenoise/
STATICFILES_STORAGE = 'whitenoise.django.GzipManifestStaticFilesStorage'
ADMINS = values.SingleNestedTupleValue()
class Base(Configuration):
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
INSTALLED_APPS = [
"django.contrib.contenttypes",
"probes",
]
MIDDLEWARE = []
ALLOWED_HOSTS = []
SECRET_KEY = values.SecretValue()
ROOT_URLCONF = "probe_search.urls"
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
],
},
},
]
DEBUG = values.BooleanValue(default=False)
LANGUAGE_CODE = "en-us"
TIME_ZONE = "UTC"
USE_I18N = False
USE_L10N = False
USE_TZ = True
class Development(Base, Configuration):
DEBUG = values.BooleanValue(True)
BASE_DIR = Base.BASE_DIR
SECRET_KEY = values.SecretValue()
ALLOWED_HOSTS = ["*"]
# DJANGO CHANNELS
ASGI_APPLICATION = "config.routing.application"
CHANNEL_LAYERS = {
'default': {
"BACKEND": "channels_redis.core.RedisChannelLayer",
"CONFIG": {
"hosts": [(os.getenv('REDIS_URL'), 6379)],
},
}
}
# HAYSTACK CONFIGURATION
HAYSTACK_SIGNAL_PROCESSOR = 'haystack.signals.RealtimeSignalProcessor'
HAYSTACK_CONNECTIONS = {
'default': {
'ENGINE':
'haystack.backends.elasticsearch2_backend.Elasticsearch2SearchEngine',
'URL': os.getenv('ELASTICSEARCH_URL'),
'INDEX_NAME': 'haystack',
},
}
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': "postgres",
'USER': "******",
'PASSWORD': "******",
'HOST': "0.0.0.0",
'PORT': 5432
}
}
class Prod(Common):
"""
The in-production settings.
"""
DEBUG = TEMPLATE_DEBUG = False
SECRET_KEY = values.SecretValue()
EMAIL_HOST = values.Value()
EMAIL_HOST_USER = values.Value()
EMAIL_HOST_PASSWORD = values.Value()
EMAIL_PORT = values.Value()
EMAIL_USE_TLS = values.BooleanValue(True)
DSN_VALUE = values.Value()
# If we're on production, connect to Sentry
RAVEN_CONFIG = {
'dsn': DSN_VALUE,
}
INSTALLED_APPS = Common.INSTALLED_APPS + (
'raven.contrib.django.raven_compat', )
class Production(BaseSettings):
DEBUG = values.BooleanValue(False)
ALLOWED_HOSTS = values.ListValue(
['*'], environ_prefix="{{cookiecutter.repo_name}}".upper())
SECRET_KEY = values.SecretValue(
environ_prefix="{{cookiecutter.repo_name}}".upper())
DATABASES = values.DatabaseURLValue(
'sqlite://dev.db',
alias='default',
environ_prefix="{{cookiecutter.repo_name}}".upper())
CACHES = values.CacheURLValue(
'locmem://',
alias='default',
environ_prefix="{{cookiecutter.repo_name}}".upper())
STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.CachedStaticFilesStorage'
TEMPLATE_LOADERS = (
#'django.template.loaders.cached.Loader',
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
)
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
class Production(Base):
DEBUG = values.BooleanValue(False)
ALLOWED_HOSTS = values.ListValue(['wheels-o-tron.herokuapp.com'])
DATABASES = values.DatabaseURLValue()
SECRET_KEY = values.SecretValue()
MIDDLEWARE = [
'raven.contrib.django.raven_compat.middleware.SentryMiddleware',
] + Base.MIDDLEWARE
# configure our sentry connection
INSTALLED_APPS = Base.INSTALLED_APPS + [
'raven.contrib.django.raven_compat'
]
SENTRY_DSN = values.Value(None, environ_prefix=None)
SENTRY_DSN_PUBLIC = values.Value(None, environ_prefix=None)
@property
def RAVEN_CONFIG(self):
return {
'dsn': self.SENTRY_DSN,
'release': os.environ.get('HEROKU_SLUG_COMMIT'),
# 'release': raven.fetch_git_sha(os.path.abspath(os.pardir)),
}
class Staging(Base, Configuration):
BITCORE_SERVER_TYPE = "sta"
DEBUG = values.BooleanValue(True)
BASE_DIR = Base.BASE_DIR
SECRET_KEY = values.SecretValue()
ALLOWED_HOSTS = [
"127.0.0.1",
"0.0.0.0",
"localhost",
"nuxtstaging.bitcoregaming.local",
"nuxtstaging.bitcoregaming.com",
"staging.bitcoregaming.com",
"backendstaging"
]
# WEBSOCKETS - DJANGO CHANNELS
ASGI_APPLICATION = "config.routing.application"
CHANNEL_LAYERS = {
'default': {
"BACKEND": "channels_redis.core.RedisChannelLayer",
"CONFIG": {
"hosts": [("redis", 6379)],
},
}
}
# HAYSTACK CONFIGURATION
HAYSTACK_SIGNAL_PROCESSOR = 'haystack.signals.RealtimeSignalProcessor'
HAYSTACK_CONNECTIONS = {
'default': {
'ENGINE': 'haystack.backends.elasticsearch2_backend.Elasticsearch2SearchEngine',
'URL': 'http://elasticsearch:9200/',
'INDEX_NAME': 'haystack',
},
}
