def get_release_name(base_dir, server_env):
release_dir = base_dir.split('/')[-1]
if re.match('\d{4}-\d{2}-\d{2}_\d{2}.\d{2}', release_dir):
release = "{}-{}-deploy".format(release_dir, server_env)
else:
release = fetch_git_sha(base_dir)
return release
def RAVEN_CONFIG(self):
import raven
return {
'dsn': str(super().SENTRY_DSN),
'release': raven.fetch_git_sha(super().BASE_DIR),
}
def setup(cls):
super(Base, cls).setup()
cls.RAVEN_CONFIG = {
'dsn': cls.SENTRY_DSN,
'release': raven.fetch_git_sha(cls.PROJECT_PATH),
}
def get_odoo_commit(odoo_dir):
'''Attempts to get Odoo git commit from :param:`odoo_dir`.'''
if not odoo_dir:
return
try:
return fetch_git_sha(odoo_dir)
except InvalidGitRepository:
pass
def on_configure(self):
if settings.PDB_ENABLE_SENTRY: # ignore for coverage
client = raven.Client(settings.PDB_SENTRY_DSN)
client.release = raven.fetch_git_sha(os.path.dirname(os.pardir))
# register a custom filter to filter out duplicate logs
register_logger_signal(client)
# hook into the Celery error handler
register_signal(client)
def RAVEN_CONFIG(self):
if not hasattr(self, 'RAVEN_SECRET_KEY'):
return {}
return {
'dsn': 'https://{public_key}:{secret_key}@app.getsentry.com/{project_id}'.format(
public_key=self.RAVEN_PUBLIC_KEY,
secret_key=self.RAVEN_SECRET_KEY,
project_id=self.RAVEN_PROJECT_ID
),
'release': raven.fetch_git_sha(self.TOP_DIR),
}
def get_release():
config = get_raven_config()
if config.project_dist:
try:
return get_distribution(config.project_dist).version
except DistributionNotFound:
LOG.error('The distribution "{}" could not be found.'.format(config.project_dist))
return None
if config.buildout_root:
try:
return fetch_git_sha(config.buildout_root)
except InvalidGitRepository:
LOG.error("The path {} does not exist or is not" " a git repository".format(config.buildout_root))
return None
return None
def create_update_sentry_release():
from settingshelper import get_release_name
from raven import fetch_git_sha
release = get_release_name(settings.BASE_DIR, settings.SERVER_ENVIRONMENT)
headers = {'Authorization': 'Bearer {}'.format(settings.SENTRY_API_KEY), }
payload = {
'version': release,
'refs': [{
'repository': 'dimagi/commcare-hq',
'commit': fetch_git_sha(settings.BASE_DIR)
}],
'projects': ['commcarehq']
}
releases_url = 'https://sentry.io/api/0/organizations/dimagi/releases/'
response = requests.post(releases_url, headers=headers, json=payload)
if response.status_code == 208:
# already created so update
payload.pop('version')
requests.put('{}{}/'.format(releases_url, release), headers=headers, json=payload)
def init(args):
if args.log_config:
log_config = json.load(args.log_config)
logging.config.dictConfig(log_config)
else:
logging.basicConfig(level=args.log_level,
format='%(asctime)s %(levelname)8s [%(name)s] %(message)s')
log.info('--- Starting ---')
git_sha = raven.fetch_git_sha(os.path.dirname(os.path.dirname(__file__)))
log.info('Git commit: %s', git_sha)
# Log errors to Sentry
client = raven.Client(
# dsn=os.environ.get('SENTRY_DSN'),
include_paths=['fewerror'],
release=git_sha,
ignore_exceptions=[
KeyboardInterrupt,
],
)
handler = SentryHandler(client)
handler.setLevel(logging.WARNING)
raven.conf.setup_logging(handler)
}
MIDDLEWARE_CLASSES = tuple([pair[1] for pair in sorted(MIDDLEWARE_GLOBAL + MIDDLEWARE_LOCAL)])
# set tempdir so that we don't have to worry about collision
if not getattr(tempfile, 'alreadytwiddled', False): # Python appears to run this multiple times
tempdir = os.path.join(tempfile.gettempdir(), "esptmp__" + CACHE_PREFIX)
if not os.path.exists(tempdir):
os.makedirs(tempdir)
tempfile.tempdir = tempdir
tempfile.alreadytwiddled = True
# change csrf cookie name from default to prevent collisions with misbehaving sites
# that set a cookie on the top-level domain
# NOTE: don't change this value; it's hard coded into various JavaScript files
CSRF_COOKIE_NAME = 'esp_csrftoken'
if SENTRY_DSN:
# If SENTRY_DSN is set, send errors to Sentry via the Raven exception
# handler. Note that our exception middleware (i.e., ESPErrorMiddleware)
# will remain enabled and will receive exceptions before Raven does.
import raven
INSTALLED_APPS += (
'raven.contrib.django.raven_compat',
)
RAVEN_CONFIG = {
'dsn': SENTRY_DSN,
'release': raven.fetch_git_sha(os.path.join(PROJECT_ROOT, '..')),
}
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
if secrets.get('raven_dsn', ''):
import raven
INSTALLED_APPS.append('raven.contrib.django.raven_compat')
RAVEN_CONFIG = {
'dsn': secrets.get('raven_dsn', ''),
'release': raven.fetch_git_sha(REPO_DIR),
}
MIDDLEWARE_CLASSES = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
REST_FRAMEWORK = {
'DEFAULT_RENDERER_CLASSES': (
COMPRESS_CSS_FILTERS = [
"compressor.filters.css_default.CssAbsoluteFilter",
"compressor.filters.cssmin.CSSMinFilter",
]
COMPRESS_CSS_HASHING_METHOD = None
# Celery settings
CELERY_BROKER_URL = "redis://localhost:6379/0"
CELERY_RESULT_BACKEND = "django-db"
# Meta tags info
META_TITLE = "Welcome to official blog of Alex Manti."
META_DESCRIPTION = "Official blog of Alex Manti. My music, photos and info about me."
# Instagram settings
INSTAGRAM_USER_ID = ""
INSTAGRAM_CLIENT_ID = ""
INSTAGRAM_ACCESS_TOKEN = ""
INSTAGRAM_CLIENT_SECRET = ""
# Sentry integration
ROOT_DIR = os.path.dirname((os.path.dirname(PROJECT_DIR)))
RAVEN_CONFIG = {"dsn": "", "release": raven.fetch_git_sha(ROOT_DIR)}
# Number of days used to consider a register staled
DAYS_TO_STALE_REGISTER = config("DAYS_TO_STALE_REGISTER", default=90, cast=int)
SOCIAL_AUTH_FACEBOOK_KEY = config("SOCIAL_AUTH_FACEBOOK_KEY", default="")
SOCIAL_AUTH_FACEBOOK_SECRET = config("SOCIAL_AUTH_FACEBOOK_SECRET", default="")
SOCIAL_AUTH_TWITTER_KEY = config("SOCIAL_AUTH_TWITTER_KEY", default="")
SOCIAL_AUTH_TWITTER_SECRET = config("SOCIAL_AUTH_TWITTER_SECRET", default="")
FACEBOOK_SHARE_GRAPH_API_VERSION = config("FACEBOOK_SHARE_GRAPH_API_VERSION", default="3.1")
FACEBOOK_SHARE_URL = "https://www.facebook.com/sharer.php?u=https://cademeubicho.com/pets/{}/"
TWITTER_SHARE_URL = "https://twitter.com/share?url=https://cademeubicho.com/pets/{}/"
REPO_ROOT = config("REPO_ROOT", default=os.path.abspath(os.pardir))
RAVEN_CONFIG = {"dsn": config("RAVEN_DSN", default=""), "release": raven.fetch_git_sha(REPO_ROOT)}
SENDGRID_API_KEY = config("SENDGRID_API_KEY", default="")
DEFAULT_FROM_EMAIL = config("EMAIL_HOST_USER", default="*****@*****.**")
CORS_ORIGIN_ALLOW_ALL = True
CORS_URLS_REGEX = r"^/api/.*$"
REST_FRAMEWORK = {
"DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.LimitOffsetPagination",
"PAGE_SIZE": 20,
}
GOOGLE_API_KEY = config("GOOGLE_API_KEY", default="")
HOTJAR_TRACKING_KEY = config("HOTJAR_TRACKING_KEY", default="")
EMAIL_HOST_PASSWORD = '******'passwordstore', 'privacymail/admin/send-pass' )}}'
EMAIL_SUBJECT_PREFIX = '[PMail] '
# For debugging you may use the console backend
# EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
# Profiling
SILKY_PYTHON_PROFILER = True
# Authentication
SILKY_AUTHENTICATION = True # User must login
SILKY_AUTHORISATION = True # User must have permissions
RAVEN_CONFIG = {
'dsn': '{{ lookup('passwordstore', 'privacymail/raven-dsn') }}',
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha("{{ install_path }}"),
'transport': RequestsHTTPTransport,
}
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'root': {
'level': 'WARNING',
'handlers': ['sentry'],
},
'formatters': {
'verbose': {
'format': ('%(levelname)s %(asctime)s %(module)s %(process)d '
'%(thread)d %(message)s')
},
COMPRESS_OFFLINE = True
# media settings
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'
LOGIN_URL = '/'
# sentry.io
if not DEBUG:
RAVEN_CONFIG = {
'dsn': JSON_DATA['sentry_dsn'],
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha(os.path.dirname(os.pardir)),
}
# cache
CACHEOPS_REDIS = {
'host': 'localhost', # redis-server is on same machine
'port': 6379, # default redis port
'db': 14, # SELECT non-default redis database
}
CACHEOPS = {
# Automatically cache any User.objects.get() calls for 15 minutes
# This includes request.user or post.author access,
# where Post.author is a foreign key to auth.User
'auth.user': {'ops': 'all', 'timeout': 60*60*24*30},
'*.*': {'ops': 'all', 'timeout': 60*60*24*2}, # enable cache for all model for 2 days
addr='*****@*****.**',
)
# Securiy related settings
SECURE_HSTS_SECONDS = 2592000
SECURE_BROWSER_XSS_FILTER = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
CSRF_COOKIE_HTTPONLY = True
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
X_FRAME_OPTIONS = 'DENY'
# Setting for sentry
INSTALLED_APPS += (
'raven.contrib.django.raven_compat',
)
import raven # noqa
RAVEN_CONFIG = {
'dsn': env('DSN_URL'),
'release': raven.fetch_git_sha(os.path.dirname(BASE_DIR)),
}
GA_TRACK_ID = env('GA_TRACK_ID', default=None)
GTM_TRACK_ID = env('GTM_TRACK_ID', default=None)
DJANGO_Q_DEBUG = False
# https://django-extensions.readthedocs.io/en/latest/shell_plus.html
SHELL_PLUS = 'ipython'
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework.authentication.SessionAuthentication',
),
'DEFAULT_PERMISSION_CLASSES': (
'rest_framework.permissions.IsAuthenticated',
),
'DEFAULT_FILTER_BACKENDS': [
'django_filters.rest_framework.DjangoFilterBackend'
],
}
try:
RELEASE = raven.fetch_git_sha(BASE_DIR)
except InvalidGitRepository:
RELEASE = None
RAVEN_CONFIG = {
'dsn': os.getenv('SENTRY_KEY'),
'release': RELEASE,
'environment': 'base',
}
RECAPTCHA_PUBLIC_KEY = os.getenv('RECAPTCHA_PUBLIC_KEY')
RECAPTCHA_PRIVATE_KEY = os.getenv('RECAPTCHA_PRIVATE_KEY')
CORS_ORIGIN_WHITELIST = []
'propagate': False,
},
'django.request': {
'handlers': ['file'],
'level': 'ERROR',
'propagate': False,
},
}
}
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': '127.0.0.1:11211',
}
}
try:
from .sentry_settings import DSN
import raven
INSTALLED_APPS.append(
'raven.contrib.django.raven_compat'
)
RAVEN_CONFIG = {
'dsn': DSN,
'release': raven.fetch_git_sha(os.path.dirname(BASE_DIR)),
}
except ImportError:
pass
from .debug import DEBUG
import os
import raven
from .base import BASE_DIR
if not DEBUG:
# sentry post url settings(https://docs.sentry.io/clients/python/integrations/django/)
RAVEN_CONFIG = {
'dsn': os.getenv('DSN'),
'release': raven.fetch_git_sha(os.path.abspath(BASE_DIR)),
}
# log format setting
LOGGING = {
'version': 1,
'disable_existing_loggers': True,
'root': {
'level': 'WARNING',
'handlers': ['console', 'sentry'],
},
'formatters': {
'verbose': {
'format':
'%(levelname)s %(asctime)s %(module)s '
'%(process)d %(thread)d %(message)s'
},
},
'handlers': {
'sentry': {
'level':
'ERROR', # To capture more than ERROR, change to WARNING, INFO, etc.
class CommunityProdSettings(CommunityBaseSettings):
"""Settings for local development"""
SERVE_DOCS = ['private']
PYTHON_MEDIA = True
PRODUCTION_DOMAIN = '{{ rtd_domain }}'
USE_SUBDOMAIN = False
PUBLIC_DOMAIN = '{{ PUBLIC_DOMAIN }}'
PUBLIC_API_URL = '{{ PUBLIC_API_URL }}'
GLOBAL_ANALYTICS_CODE = '{{ GLOBAL_ANALYTICS_CODE }}'
PUBLIC_DOMAIN_USES_HTTPS = '{{ rtd_proto }}' == 'https'
# default build versions
RTD_LATEST = 'bozza'
RTD_LATEST_VERBOSE_NAME = RTD_LATEST
RTD_STABLE = 'stabile'
RTD_STABLE_VERBOSE_NAME = RTD_STABLE
RTD_LATEST_EN = 'draft'
RTD_STABLE_EN = 'stable'
# General settings
DEBUG = {{ DEBUG }}
TEMPLATE_DEBUG = False
DOCS_BASE = os.environ.get('DOCS_BASE', CommunityBaseSettings.SITE_ROOT)
MEDIA_ROOT = os.path.join(DOCS_BASE, 'media/')
STATIC_ROOT = os.path.join(DOCS_BASE, 'media/static/')
MEDIA_URL = '{{ MEDIA_URL }}'
STATIC_URL = '{{ MEDIA_URL }}static/'
ADMIN_MEDIA_PREFIX = MEDIA_URL + 'admin/'
SECRET_KEY = '{{ SECRET_KEY }}'
DEFAULT_FROM_EMAIL = '{{ DEFAULT_FROM_EMAIL }}'
SESSION_COOKIE_DOMAIN = '{{ rtd_domain }}'
TAGGIT_TAGS_FROM_STRING = 'readthedocs.docsitalia.utils.docsitalia_parse_tags'
DOCROOT = os.path.join(DOCS_BASE, 'user_builds')
UPLOAD_ROOT = os.path.join(DOCS_BASE, 'user_uploads')
CNAME_ROOT = os.path.join(DOCS_BASE, 'cnames')
LOGS_ROOT = os.path.join(DOCS_BASE, 'logs')
PRODUCTION_ROOT = os.path.join(DOCS_BASE, 'prod_artifacts')
PUBLIC_BASE = DOCS_BASE
PRIVATE_BASE = DOCS_BASE
@property
def TEMPLATES(self): # noqa
TEMPLATES = super().TEMPLATES
TEMPLATE_OVERRIDES = os.path.join(super().TEMPLATE_ROOT, 'docsitalia', 'overrides')
TEMPLATES[0]['DIRS'].insert(0, TEMPLATE_OVERRIDES)
return TEMPLATES
@property
def INSTALLED_APPS(self): # noqa
apps = super(CommunityProdSettings, self).INSTALLED_APPS
# Insert our depends above RTD applications, after guaranteed third
# party package
apps.append('readthedocs.docsitalia')
apps.append('dal', )
apps.append('dal_select2', )
{% if USE_CONVERTER %}apps.insert(apps.index('rest_framework'), 'docs_italia_convertitore_web'){% endif %}
{% if SENTRY_DSN|string|length %}apps.insert(apps.index('rest_framework'), 'raven.contrib.django.raven_compat'){% endif %}
return apps
# Celery
CACHES = dict(
(cache_name, {
'BACKEND': 'redis_cache.RedisCache',
'LOCATION': '{host}:{port}'.format(**cache),
'OPTIONS': {
'DB': cache['db'],
},
})
for (cache_name, cache)
in _redis.items()
if cache_name is not 'celery'
)
BROKER_URL = 'redis://{{ rtd_redis_celery }}'
CELERY_RESULT_BACKEND = 'redis://{{ rtd_redis_celery }}'
# Docker
DOCKER_SOCKET = 'tcp://{{ docker_main_ip }}:2375'
DOCKER_ENABLE = {{ DOCKER_ENABLE }}
DOCKER_IMAGE = '{{ docker_rtd_image }}'
DOCKER_VERSION = '1.33'
DOCKER_LIMITS = {
'memory': '999m',
'time': 3600,
}
{% if SENTRY_DSN|string|length %}
import raven
RAVEN_CONFIG = {
'dsn': '{{ SENTRY_DSN }}',
'release': raven.fetch_git_sha(CommunityBaseSettings.SITE_ROOT),
'environment': '{{ SENTRY_ENVIRONMENT }}'
}
{% endif %}
# Haystack - we don't really use it. ES API is used instead
HAYSTACK_CONNECTIONS = {
'default': {
'ENGINE': 'haystack.backends.simple_backend.SimpleEngine',
},
}
CELERY_ALWAYS_EAGER = False
CELERY_HAYSTACK_DEFAULT_ALIAS = None
CELERY_TASK_RESULT_EXPIRES = 7200
# Elastic Search
ES_HOSTS = '{{ es_hosts }}'.split(',')
ELASTICSEARCH_DSL = {
'default': {
'hosts': ES_HOSTS
},
}
# RTD settings
# This goes together with FILE_SYNCER setting
# eg: FILE_SINCER = 'readthedocs.builds.syncers.*' (likely RemoteSyncer)
MULTIPLE_APP_SERVERS = '{{ app_hosts }}'.split(',')
MULTIPLE_BUILD_SERVERS = '{{ worker_hosts }}'.split(',')
SLUMBER_API_HOST = 'http://{{ api_host }}'
SLUMBER_USERNAME = '******'
SLUMBER_PASSWORD = '******'
SYNC_USER = '******'
#DOCROOT = '/var/build'
ACCOUNT_EMAIL_VERIFICATION = 'mandatory'
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
REPO_LOCK_SECONDS = 300
DONT_HIT_DB = False
# Override classes
CLASS_OVERRIDES = {
'readthedocs.builds.syncers.Syncer': 'readthedocs.builds.syncers.LocalSyncer',
'readthedocs.core.resolver.Resolver': 'readthedocs.docsitalia.resolver.ItaliaResolver',
'readthedocs.oauth.services.GitHubService': 'readthedocs.docsitalia.oauth.services.github.DocsItaliaGithubService',
}
# Email
if {{ USE_SMTP }}:
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_USE_TLS = True
EMAIL_HOST = '{{ EMAIL_HOST }}'
EMAIL_HOST_USER = '******'
EMAIL_HOST_PASSWORD = '******'
else:
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
# Social Auth
GITHUB_APP_ID = '{{ GITHUB_APP_ID }}'
GITHUB_API_SECRET = '{{ GITHUB_API_SECRET }}'
SOCIALACCOUNT_PROVIDERS = {
'github': {'SCOPE': ['user:email', 'read:org', 'admin:repo_hook', 'repo:status']}
}
ACCOUNT_DEFAULT_HTTP_PROTOCOL = 'https'
ADMINS = (
('Test', 'test@{{ rtd_domain }}'),
)
TIME_ZONE = 'Europe/Rome'
LANGUAGE_CODE = 'it-it'
CORS_ORIGIN_WHITELIST = (
'{{ rtd_domain }}:8000',
)
# Prevent logging errors from the django shell.
# Errors from other management commands will be still logged.
if len(sys.argv) > 1 and sys.argv[1] in ["shell", "shell_plus"]:
RAVEN_CONFIG["ignore_exceptions"] = ["*"]
# There's a chooser to toggle between environments at the top right corner on sentry.io
# Values are typically 'staging' or 'production' but can be set to anything else if needed.
# dokku config:set mresponse SENTRY_ENVIRONMENT=staging
# heroku config:set SENTRY_ENVIRONMENT=production
if "SENTRY_ENVIRONMENT" in env:
RAVEN_CONFIG["environment"] = env["SENTRY_ENVIRONMENT"]
# We first assume that the Git repository is present and we can detect the
# commit hash from it.
try:
RAVEN_CONFIG["release"] = raven.fetch_git_sha(BASE_DIR)
except InvalidGitRepository:
try:
# But if it's not, we assume that the commit hash is available in
# the GIT_REV environment variable. It's a default environment
# variable used on Dokku:
# http://dokku.viewdocs.io/dokku/deployment/methods/git/#configuring-the-git_rev-environment-variable
RAVEN_CONFIG["release"] = env["GIT_REV"]
except KeyError:
# If there's no commit hash, we do not set a specific release.
pass
# Security configuration
# This configuration is required to achieve good security rating.
# You can test it using https://securityheaders.com/
# https://docs.djangoproject.com/en/stable/ref/middleware/#module-django.middleware.security
TIME_ZONE = "UTC"
USE_I18N = True
USE_L10N = True
USE_TZ = True
LOGLEVEL = "DEBUG" if DEBUG else "INFO"
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"formatters": {"simple": {"format": "[%(asctime)s] [%(levelname)s] %(message)s"}},
"filters": {"require_debug_true": {"()": "django.utils.log.RequireDebugTrue"}},
"handlers": {"console": {"class": "logging.StreamHandler", "formatter": "simple"}},
"loggers": {
"actions": {"handlers": ["console"], "level": LOGLEVEL},
"capabilities": {"handlers": ["console"], "level": LOGLEVEL},
"hardware": {"handlers": ["console"], "level": LOGLEVEL},
"schedule": {"handlers": ["console"], "level": LOGLEVEL},
"scheduler": {"handlers": ["console"], "level": LOGLEVEL},
"sensor": {"handlers": ["console"], "level": LOGLEVEL},
"status": {"handlers": ["console"], "level": LOGLEVEL},
"tasks": {"handlers": ["console"], "level": LOGLEVEL},
},
}
SENTRY_DSN = env("SENTRY_DSN", default="")
if SENTRY_DSN:
import raven
RAVEN_CONFIG = {"dsn": SENTRY_DSN, "release": raven.fetch_git_sha(REPO_ROOT)}
ACCOUNT_DEFAULT_HTTP_PROTOCOL = 'https'
ACCOUNT_USERNAME_MIN_LENGTH = 5
ACCOUNT_USERNAME_BLACKLIST = ['admin', 'owner', 'user']
ACCOUNT_USERNAME_REQUIRED = True
ACCOUNT_PASSWORD_MIN_LENGTH = 6
ACCOUNT_LOGIN_ON_EMAIL_CONFIRMATION = True
ACCOUNT_LOGIN_ON_PASSWORD_RESET = True
ACCOUNT_SESSION_REMEMBER = True
SOCIALACCOUNT_QUERY_EMAIL = ACCOUNT_EMAIL_REQUIRED
SOCIALACCOUNT_PROVIDERS = {'google': {
'SCOPE': ['profile', 'email'],
'AUTH_PARAMS': {'access_type': 'online'}
}}
RAVEN_CONFIG = {'dsn': '', 'release': raven.fetch_git_sha(BASE_DIR)}
ENTREZ_TERMS = ['chordoma', 'breast cancer', 'diabetes']
ENTREZ_MAX_COUNT = 10
NCBO_API_KEY = '5dbf6de8-fda5-4ef7-a3a8-bcea293f3715'
STOP_WORDS = 'protein,gene,disease,disorder,syndrome,chromosome,receptor,cell,\
orphan,thumb,center,with,involved,image,type,known,encoded,this,both,\
human,second,near,observed,from,family,width,name,caption,state,\
structure,MEROPS,Pfam,domain,Symbol,SMART,crystal,analogue,\
protein family,SCOP,InterPro,EC number,Name,group,related,then,Some,\
form,http,abstract,content,liter,levels,enzyme,drugs,into,slow,\
intermediate,bound,Citation,when,down,After'
POSTIVE_FLATTER = ['Bravo', 'Wow', 'Super', 'Terrific', 'Cool', 'Amazing', 'Superb', 'Brilliant', 'Fantastic', 'Fabulous', 'You\'re a Champion', 'Well done', 'You rock', 'Great job', 'Tip top', 'Good thinking', 'Keep it up', 'Way to go', 'Right on', 'Top stuff', 'Take a bow', 'Unreal', 'Impressed', 'Great stuff', 'Awesome', 'Nice going', 'Very Creative', 'Thank You', 'Beautiful', 'Very proud', 'Good for you', 'Give me five', 'You make me happy', 'A+', 'A++', 'AA+', 'Fab', 'Rad', 'A+++', 'AAA+', 'A-OK', 'Best', 'Cool', 'Deal', 'Fast', 'Fine', 'Item', 'Nice', 'Safe', 'Thx!', 'WOW!', 'Prime', 'Solid', 'Super', 'Sweet', 'Thanx', 'Whoa!', 'Groovy', 'Honest', 'Speedy', 'Superb', 'Sweeet', 'Thanks', 'Zowie!', 'Amazing', 'Awesome', 'Quality', 'Service', 'Sweeeet', 'Glorious', 'Stunning', 'Superior', 'The Best', 'The Bomb', 'Thrilled', 'Way Cool', 'Brilliant', 'Competent', 'Delighted', 'Excellent', 'Exquisite', 'Marvelous', 'Overjoyed', 'Satisfied', 'Thank You', 'Top Notch', 'Unrivaled', 'Wonderful', 'A Home Run', 'Astounding', 'Delightful', 'Impressive', 'Incredible', 'Super Cool', 'Super Fast', 'Supersonic', 'Astonishing', 'Fascinating', 'Interesting', 'Magnificent', 'No Problems', 'Outstanding', 'Splendorous', 'Trustworthy', 'Unsurpassed', 'Wicked Cool', 'Breathtaking', 'Looking Good', 'Overwhelming!', 'Unbelievable!', 'Awe Inspiring', 'Lickety Split', 'Splendiferous', 'Thanks A Ton!', 'Extremely Cool', 'Satisfied 100%', 'Extremely Happy', 'Great Condition', 'Above And Beyond', 'State Of The Art', 'Thanks A Million!', 'Unbelievably Cool', 'Expertly Described', 'Extremely Satisfied', 'Great Communication', 'Greatly Appreciated', 'Beyond My Wildest Dreams', 'Supercalifragilisticexpialidocious', 'Thank You! Thank You! Thank You!']
SUPPORT_FLATTER = ['You can do it', 'Nice Try', 'Don\'t give up', 'Every bit counts', 'Thank you', 'Keep going', 'You can do better than that']
# Port that the Notifications Server listens on
#NOTIFICATIONS_SERVER_PORT = 7887
# Domain to use for serving IP to hostname mappings
# using ./manage.py ipauth-dnsserver
#IPAUTH_DNSSERVER_DOMAIN = 'oioioi.example.com'
# Error reporting
import raven
RAVEN_CONFIG = {
# Won't do anything with no dsn
# tip: append ?timeout=5 to avoid dropouts during high reporting traffic
'dsn':
'',
# This should be a path to git repo
'release':
raven.fetch_git_sha(
os.path.join(os.path.dirname(oioioi.__file__), os.pardir)),
}
# Bonus to judging priority ang judging weight for each contest on this
# OIOIOI instance.
#OIOIOI_INSTANCE_PRIORITY_BONUS = 0
#OIOIOI_INSTANCE_WEIGHT_BONUS = 0
# If set to True, usercontests will become read-only: it will be impossible to
# change, delete or submit to existing usercontests, as well as add new ones.
# This operation is fully reversible.
#ARCHIVE_USERCONTESTS = True
DAYS_TO_STALE_REGISTER = config('DAYS_TO_STALE_REGISTER', default=90, cast=int)
SOCIAL_AUTH_FACEBOOK_KEY = config('SOCIAL_AUTH_FACEBOOK_KEY', default='')
SOCIAL_AUTH_FACEBOOK_SECRET = config('SOCIAL_AUTH_FACEBOOK_SECRET', default='')
SOCIAL_AUTH_TWITTER_KEY = config('SOCIAL_AUTH_TWITTER_KEY', default='')
SOCIAL_AUTH_TWITTER_SECRET = config('SOCIAL_AUTH_TWITTER_SECRET', default='')
FACEBOOK_SHARE_GRAPH_API_VERSION = config('FACEBOOK_SHARE_GRAPH_API_VERSION', default='3.1')
FACEBOOK_SHARE_URL = 'https://www.facebook.com/sharer.php?u=https://cademeubicho.com/pets/{}/'
TWITTER_SHARE_URL = 'https://twitter.com/share?url=https://cademeubicho.com/pets/{}/'
REPO_ROOT = config('REPO_ROOT', default=os.path.abspath(os.pardir))
RAVEN_CONFIG = {
'dsn': config('RAVEN_DSN', default=''),
'release': raven.fetch_git_sha(REPO_ROOT),
}
SENDGRID_API_KEY = config('SENDGRID_API_KEY', default='')
DEFAULT_FROM_EMAIL = config('EMAIL_HOST_USER', default='*****@*****.**')
CORS_ORIGIN_ALLOW_ALL = True
CORS_URLS_REGEX = r'^/api/.*$'
REST_FRAMEWORK = {
'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
'PAGE_SIZE': 20
}
GOOGLE_API_KEY = config('GOOGLE_API_KEY', default='')
HOTJAR_TRACKING_KEY = config('HOTJAR_TRACKING_KEY', default='')
DEFAULT_FROM_EMAIL = "{{cookiecutter.project_name}} <noreply@{{cookiecutter.domain_name}}>"
# https://docs.djangoproject.com/en/dev/ref/settings/#server-email
SERVER_EMAIL = DEFAULT_FROM_EMAIL
# https://docs.djangoproject.com/en/dev/ref/settings/#email-subject-prefix
EMAIL_SUBJECT_PREFIX = default="[{{cookiecutter.project_name}}]"
# SENTRY VALIDATION
# ------------------------------------------------------------------------------
INSTALLED_APPS.append(
'raven.contrib.django.raven_compat',
)
RAVEN_CONFIG = {
'dsn': '',
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha(BASE_DIR),
}
# LOGGING
# ------------------------------------------------------------------------------
ROTATING_FILE_HANDLER = {
'class': 'logging.handlers.RotatingFileHandler',
'maxBytes': 1024 * 1024 * 50, # 50MB
'backupCount': 10,
}
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'filters': {
'require_debug_false': {
'()': 'django.utils.log.RequireDebugFalse',
"""
from .base import * # noqa
import logging
import os
import raven
SITE_ID = 2
ROOT_URLCONF = 'config.urls_comingsoon'
print('Loading comingsoon_production')
RAVEN_CONFIG = {
'dsn': env('DJANGO_SENTRY_DSN'),
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha(str(ROOT_DIR - 1)),
}
# DEBUG
# ------------------------------------------------------------------------------
DEBUG = env.bool('DJANGO_DEBUG')
# See: https://docs.djangoproject.com/en/dev/ref/settings/#template-debug
TEMPLATES[0]['OPTIONS']['debug'] = DEBUG
# SECRET CONFIGURATION
# ------------------------------------------------------------------------------
# See: https://docs.djangoproject.com/en/dev/ref/settings/#secret-key
# Raises ImproperlyConfigured exception if DJANGO_SECRET_KEY not in os.environ
SECRET_KEY = env('DJANGO_SECRET_KEY')
# DATABASE CONFIGURATION
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
INTERNAL_IPS = ['127.0.0.1']
# Chapter 25
from django.contrib.messages import constants
MESSAGE_LEVEL = constants.DEBUG
# 장고 기본설정으로 debug 메세지는 무시. 위와같이 설정해야 debug레벨의 메시지를 남길 수 있음
# 그러나 debug 거의 잘 안쓰니까 안 하는 것도 좋은 방법
MESSAGE_TAGS = {constants.ERROR: 'danger'}
# ERROR level은 유지하나, 이에 대한 tag는 danger로 출력되도록 설정
NAVER_CLIENT_ID = 'fPxIUCZvzoI_d0aHAVAY'
import raven
GIT_ROOT = os.path.join(BASE_DIR, '..') # .git 파일을 담고있는 디렉토리가 GIT_ROOT가 되도록 설정
if os.path.exists(os.path.join(GIT_ROOT, '.git')):
release = raven.fetch_git_sha(GIT_ROOT) # 현재 최근 커밋해시 획득
else:
release = 'dev'
RAVEN_CONFIG = {
'dsn':
'https://*****:*****@sentry.io/264500',
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': release,
}
'easy_thumbnails.processors.autocrop',
'filer.thumbnail_processors.scale_and_crop_with_subject_location',
'easy_thumbnails.processors.filters'
)
SITE_ID = 1
# Sentry.io
# https://docs.sentry.io/clients/python/integrations/django/
RAVEN_CONFIG = {
'dsn': os.getenv('SENTRY_DSN', ''),
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha(BASE_DIR),
}
LOGGING = {
'version': 1,
'disable_existing_loggers': True,
'root': {
'level': 'WARNING',
'handlers': ['sentry'],
},
'formatters': {
'verbose': {
'format': '%(levelname)s %(asctime)s %(module)s '
'%(process)d %(thread)d %(message)s'
},
},
import os
from raven import fetch_git_sha
# Flask config
DEBUG = True
ROOT_DIR = os.path.dirname(__file__)
HOST_NAME = 'localhost'
APP_NAME = 'conditional'
IP = '0.0.0.0'
PORT = 6969
# LDAP config
LDAP_RO = True
LDAP_BIND_DN = 'cn=conditional,ou=Apps,dc=csh,dc=rit,dc=edu'
LDAP_BIND_PW = ''
# Sentry config
# Do not set the DSN for local development
SENTRY_CONFIG = {
'dsn': '',
'release': fetch_git_sha(ROOT_DIR),
}
# Database config
SQLALCHEMY_DATABASE_URI = 'sqlite:///{}'.format(
os.path.join(os.getcwd(), "data.db"))
ZOO_DATABASE_URI = 'mysql+pymysql://user:pass@host/database'
# General config
DUES_PER_SEMESTER = 80
MAIN_APP_NAME + '.apps.network',
MAIN_APP_NAME + '.apps.orientation',
MAIN_APP_NAME + '.apps.printers',
MAIN_APP_NAME + '.apps.residents',
MAIN_APP_NAME + '.apps.rosters',
MAIN_APP_NAME + '.apps.technicians',
MAIN_APP_NAME + '.apps.uploaders',
)
# ================================================================================================ #
# Logging Configuration #
# ================================================================================================ #
RAVEN_CONFIG = {
'dsn': get_env_variable('RESNET_INTERNAL_SENTRY_DSN'),
'release': raven.fetch_git_sha(str(PROJECT_DIR.resolve())),
}
LOGGING = {
'version': 1,
'disable_existing_loggers': True,
'root': {
'level': 'WARNING',
'handlers': ['sentry'],
},
'formatters': {
'verbose': {
'format':
'%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
},
},
'handlers': ['console'],
'level': LOGLEVEL
},
'schedule': {
'handlers': ['console'],
'level': LOGLEVEL
},
'scheduler': {
'handlers': ['console'],
'level': LOGLEVEL
},
'sensor': {
'handlers': ['console'],
'level': LOGLEVEL
},
'status': {
'handlers': ['console'],
'level': LOGLEVEL
}
}
}
SENTRY_DSN = environ.get('SENTRY_DSN')
if SENTRY_DSN:
import raven
RAVEN_CONFIG = {
'dsn': SENTRY_DSN,
'release': raven.fetch_git_sha(REPO_ROOT),
}
import sys
import raven
from raven import Client, os
SENTRY_DSN = os.getenv("SENTRY_DSN", "https://*****:*****@app.getsentry.com/10000")
GIT_SHA = raven.fetch_git_sha(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir)))
client = Client(dsn=SENTRY_DSN, release=GIT_SHA)
def write_stdout(s):
# only eventlistener protocol messages may be sent to stdout
sys.stdout.write(s)
sys.stdout.flush()
def write_stderr(s):
sys.stderr.write(s)
sys.stderr.flush()
def main():
while 1:
# transition from ACKNOWLEDGED to READY
write_stdout("READY\n")
# read header line and print it to stderr
line = sys.stdin.readline()
write_stderr(line)
# read event payload and print it to stderr
'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',
],
},
},
]
##########
# Sentry #
##########
try:
git_sha = fetch_git_sha(BASE_DIR)
except InvalidGitRepository:
git_sha = None
RAVEN_CONFIG = {
'dsn': env.str('SENTRY_DSN', default=None),
'release': git_sha,
}
############################
# Languages & Localization #
############################
LANGUAGE_CODE = 'en'
TIME_ZONE = 'UTC'
ADMIN_TIME_ZONE = 'Europe/Helsinki'
USE_I18N = True
USE_L10N = True
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',
)
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')}
_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')
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
def create_app(test_config=None):
app = Flask(__name__)
# override _get_file_stream() so we avoid spooling to disk
app.request_class = RAMOnlyRequest
try:
GIT_RELEASE = raven.fetch_git_sha('.')
except Exception as e:
print("WARNING: couldn't set sentry git release automatically: " + str(e),
file=sys.stderr)
GIT_RELEASE = None
app.config.from_mapping(
SECRET_KEY='dev',
GIT_REV = GIT_RELEASE,
VERSION = __version__,
SENTRY_CONFIG = {
'enable-threads': True, # for uWSGI
'release': GIT_RELEASE,
},
)
# Grabs sentry config from SENTRY_DSN environment variable
sentry = Sentry(app)
@app.route('/', methods = ['GET'])
def toplevel():
return "okay!"
@app.route('/api/list', methods = ['GET'])
def list_api():
"""
Show the REST api.
"""
# build HTML of the method list
apilist = []
rules = sorted(app.url_map.iter_rules(), key=lambda x: str(x))
for rule in rules:
f = app.view_functions[rule.endpoint]
docs = f.__doc__ or ''
# remove noisy OPTIONS
methods = sorted([x for x in rule.methods if x != "OPTIONS"])
url = html.escape(str(rule))
apilist.append("<div><a href='{}'><b>{}</b></a> {}<br/>{}</div>".format(
url, url, methods, docs))
header = """<body>
<style>
body { width: 80%; margin: 20px auto;
font-family: Courier; }
section { background: #eee; padding: 40px 20px;
border: 1px dashed #aaa; }
</style>
<section>
<h2>REST API (_COUNT_ end-points)</h2>
""".replace('_COUNT_', str(len(apilist)))
footer = "</section></body>"
return header + "<br/>".join(apilist) + footer
from pdf_trio import api_routes
app.register_blueprint(api_routes.bp)
return app
def init_web_settings(app_name, debug, sentry_dsn, early_middleware=(), late_middleware=()):
"""
Appends extra Django settings useful specifically for web apps, such as static files handling, etc.
:param sentry_dsn: a string containing the DSN to configure the raven client. Projects defining
this parameter MUST add `raven` to their pip requirements.
settings: dict
return: dict
"""
# Load settings dict into local scope for concision and coherence
settings = init_settings(app_name, debug)
staticfiles_dirs = (os.path.join(settings["APP_ROOT_DIR"], "static"),)
# Needs its own line to avoid pragma no cover bleeding into other statements
staticfiles_storage = (
"whitenoise.storage.CompressedManifestStaticFilesStorage"
if not settings["TESTING"]
else "django.contrib.staticfiles.storage.StaticFilesStorage"
) # pragma: no cover
template_context_processors = settings.get("TEMPLATE_CONTEXT_PROCESSORS", ()) + (
("django.core.context_processors.debug",) if debug else ()
) # pragma: no cover
settings.update(
{
# Installed apps
"INSTALLED_APPS": ("whitenoise.runserver_nostatic", "django.contrib.staticfiles")
+ settings["INSTALLED_APPS"],
# Routing
"ROOT_URLCONF": app_name + ".urls",
# Static files, templates
"STATIC_ROOT": "staticfiles",
"STATIC_URL": "/static/",
"STATICFILES_DIRS": staticfiles_dirs,
# Don't use Whitenoise's static files storage in testing as it requires running collectstatic
"STATICFILES_STORAGE": staticfiles_storage,
"WHITENOISE_ROOT": staticfiles_dirs[0] + "/files",
"WHITENOISE_ALLOW_ALL_ORIGINS": False,
"TEMPLATE_CONTEXT_PROCESSORS": template_context_processors,
}
)
##########
# SENTRY #
##########
if sentry_dsn: # pragma: no cover
settings["INSTALLED_APPS"] = ("raven.contrib.django.raven_compat",) + settings["INSTALLED_APPS"]
settings["LOGGING"]["handlers"]["sentry"] = {
"level": "ERROR",
"class": "raven.contrib.django.raven_compat.handlers.SentryHandler",
}
settings["LOGGING"]["root"]["handlers"].append("sentry")
# import-error disabled: Raven shall only be a dependency of projects that define sentry_dsn
import raven # pylint: disable=wrong-import-position, wrong-import-order, import-error
settings["RAVEN_CONFIG"] = {"dsn": sentry_dsn}
try:
settings["RAVEN_CONFIG"]["release"] = raven.fetch_git_sha(settings["PROJECT_ROOT_DIR"])
except raven.exceptions.InvalidGitRepository:
# Probably not a git repo (on heroku?)
pass
settings["MIDDLEWARE_CLASSES"] = _compute_middleware_settings(
early_middleware, late_middleware, use_sentry=bool(sentry_dsn)
)
return settings
'backupCount': 5
}
LOGGING['loggers']['wagtail']['handlers'].append('wagtail_file')
# Error log
LOGGING['handlers']['errors_file'] = {
'level': 'ERROR',
'class': 'cloghandler.ConcurrentRotatingFileHandler',
'filename': os.path.join(env['LOG_DIR'], 'error.log'),
'maxBytes': 5242880, # 5MB
'backupCount': 5
}
LOGGING['loggers']['django.request']['handlers'].append('errors_file')
LOGGING['loggers']['django.security']['handlers'].append('errors_file')
try:
from .local import * # noqa
except ImportError:
pass
# Raven (sentry error logging)
# This must be after the .local import as RAVEN_DSN is set in local.py
if 'RAVEN_DSN' in os.environ:
RAVEN_CONFIG = {
'dsn':
os.environ['RAVEN_DSN'],
'release':
raven.fetch_git_sha(os.path.dirname(os.path.abspath(PROJECT_ROOT))),
}
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
STATICFILES_FINDERS = (
'django.contrib.staticfiles.finders.FileSystemFinder',
'django.contrib.staticfiles.finders.AppDirectoriesFinder',
)
STATICFILES_DIRS = [
os.path.join(BASE_DIR, "dist")
]
STATICFILES_STORAGE = "django.contrib.staticfiles.storage.CachedStaticFilesStorage"
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.9/howto/static-files/
STATIC_URL = '/static/'
MEDIA_URL = '/media/'
import raven
if "RAVEN_DNS_WHATIS" in os.environ and not DEBUG:
RAVEN_CONFIG = {
'dsn': os.environ['RAVEN_DNS_WHATIS'],
'release': raven.fetch_git_sha(os.path.join(os.path.dirname(__file__), "../")),
}
PASSWORD_RESET_TIMEOUT_DAYS = 2
ACCOUNT_ACTIVATION_DAYS = 2
REGISTRATION_OPEN = True # set to false to temporarily disable registrations
MESSAGE_STORAGE = "django.contrib.messages.storage.session.SessionStorage"
MESSAGE_TAGS = {messages.ERROR: "danger"}
SENTRY_BACKEND_DSN = os.environ.get("SENTRY_BACKEND_DSN", "")
SENTRY_FRONTEND_DSN = os.environ.get("SENTRY_FRONTEND_DSN", "")
RAVEN_CONFIG = {
"dsn": SENTRY_BACKEND_DSN,
"environment": CONCORDIA_ENVIRONMENT,
"release": raven.fetch_git_sha(SITE_ROOT_DIR),
}
# When the MAINTENANCE_MODE setting is true, this template will be used to
# generate a 503 response:
MAINTENANCE_MODE_TEMPLATE = "maintenance-mode.html"
# Names of special django.auth Groups
COMMUNITY_MANAGER_GROUP_NAME = "Community Managers"
NEWSLETTER_GROUP_NAME = "Newsletter"
# Django sites framework setting
SITE_ID = 1
ROBOTS_USE_SITEMAP = False
ROBOTS_USE_HOST = False
# The mailbox is called 'de rest'.
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'mailtrap.io'
EMAIL_HOST_USER = '******'
EMAIL_HOST_PASSWORD = '******'
EMAIL_PORT = 25
# Make sure to add the correct DSN in production.py
# This project is called 'De rest'
RAVEN_CONFIG = {
'dsn': 'https://*****:*****@sentry.io/111454',
}
try:
import raven
import os
RAVEN_CONFIG['release'] = raven.fetch_git_sha(os.path.dirname(os.pardir))
except ImportError:
pass
# Application definition
INSTALLED_APPS = [
'{{ cookiecutter.repo_name }}.home',
'{{ cookiecutter.repo_name }}.search',
'overextends',
'wagtail.contrib.wagtailsearchpromotions',
'wagtail.wagtailforms',
'wagtail.wagtailredirects',
def create_app(_read_config=True, **config):
app = Flask(
__name__,
static_folder=os.path.join(ROOT, "static"),
template_folder=os.path.join(ROOT, "templates"),
)
# support for kubernetes
# https://kubernetes.io/docs/concepts/services-networking/service/
if os.environ.get("GET_HOSTS_FROM") == "env":
REDIS_URL = "redis://{}:{}/0".format(
os.environ["REDIS_MASTER_SERVICE_HOST"],
os.environ["REDIS_MASTER_SERVICE_PORT"],
)
# Cloud SQL
# https://cloud.google.com/sql/docs/postgres/connect-container-engine
SQLALCHEMY_URI = "postgresql+psycopg2://{}:{}@127.0.0.1:5432/zeus".format(
os.environ["DB_USER"], os.environ["DB_PASSWORD"])
if "CELERY_BROKER_URL" in os.environ:
app.config["CELERY_BROKER_URL"] = os.environ["CELERY_BROKER_URL"]
if "GCS_BUCKET" in os.environ:
app.config["FILE_STORAGE"] = {
"backend": "zeus.storage.gcs.GoogleCloudStorage",
"options": {
"bucket": os.environ["GCS_BUCKET"],
"project": os.environ.get("GC_PROJECT"),
},
}
app.config.setdefault("MAIL_SERVER", os.environ.get("MAIL_SERVER"))
app.config.setdefault("MAIL_PORT", os.environ.get("MAIL_PORT"))
app.config.setdefault("MAIL_USE_TLS",
bool(int(os.environ.get("MAIL_USE_TLS", "1"))))
app.config.setdefault("MAIL_USE_SSL",
bool(int(os.environ.get("MAIL_USE_SSL", "0"))))
app.config.setdefault("MAIL_USERNAME", os.environ.get("MAIL_USERNAME"))
app.config.setdefault("MAIL_PASSWORD", os.environ.get("MAIL_PASSWORD"))
app.config.setdefault("MAIL_DEFAULT_SENDER",
os.environ.get("MAIL_DEFAULT_SENDER"))
app.config.setdefault(
"ALLOWED_ORIGINS",
[
x.strip()
for x in os.environ.get("ALLOWED_ORIGINS", "").split(",")
if x.strip()
],
)
else:
REDIS_URL = os.environ.get("REDIS_URL", "redis://localhost/0")
SQLALCHEMY_URI = os.environ.get("SQLALCHEMY_DATABASE_URI",
"postgresql+psycopg2:///zeus")
app.config["FILE_STORAGE"] = {
"backend": "zeus.storage.base.FileStorage",
"options": {}
}
app.config["CELERY_BROKER_URL"] = REDIS_URL
app.config.setdefault(
"MAIL_DEFAULT_SENDER",
"{}@localhost".format(os.environ.get("USERNAME", "root")))
if os.environ.get("SERVER_NAME"):
app.config["SERVER_NAME"] = os.environ["SERVER_NAME"]
app.config.setdefault(
"DOMAIN",
app.config.get("SERVER_NAME") or os.environ.get("DOMAIN")
or "localhost",
)
app.config["PUBSUB_ENDPOINT"] = os.environ.get("PUBSUB_ENDPOINT",
"http://localhost:8090")
app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY")
app.config["LOG_LEVEL"] = os.environ.get("LOG_LEVEL") or "INFO"
app.config["SSL"] = os.environ.get("SSL") in ("1", "true", "on")
# limit sessions to one day so permissions are revalidated automatically
app.config["PERMANENT_SESSION_LIFETIME"] = timedelta(days=1)
app.config["SQLALCHEMY_DATABASE_URI"] = SQLALCHEMY_URI
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.config["REDIS_URL"] = REDIS_URL
app.config["STREAM_URL"] = "http://localhost:8090/stream"
app.config["SENTRY_DSN"] = os.environ.get("SENTRY_DSN") or None
app.config["SENTRY_DSN_FRONTEND"] = os.environ.get(
"SENTRY_DSN_FRONTEND") or None
app.config["SENTRY_INCLUDE_PATHS"] = ["zeus"]
try:
app.config["SENTRY_RELEASE"] = raven.fetch_git_sha(ROOT)
except Exception:
app.logger.warn("unable to bind sentry.release context", exc_info=True)
app.config["SENTRY_ENVIRONMENT"] = os.environ.get("NODE_ENV",
"development")
app.config["GITHUB_CLIENT_ID"] = os.environ.get("GITHUB_CLIENT_ID") or None
app.config["GITHUB_CLIENT_SECRET"] = os.environ.get(
"GITHUB_CLIENT_SECRET") or None
app.config["WEBPACK_MANIFEST_PATH"] = os.path.join(ROOT, "static",
"asset-manifest.json")
app.config["CELERY_ACCEPT_CONTENT"] = ["zeus_json", "json"]
app.config["CELERY_ACKS_LATE"] = True
app.config.setdefault("CELERY_BROKER_URL", app.config["REDIS_URL"])
app.config["CELERY_DEFAULT_QUEUE"] = "default"
app.config["CELERY_DEFAULT_EXCHANGE"] = "default"
app.config["CELERY_DEFAULT_EXCHANGE_TYPE"] = "direct"
app.config["CELERY_DEFAULT_ROUTING_KEY"] = "default"
app.config["CELERY_DISABLE_RATE_LIMITS"] = True
app.config["CELERY_EVENT_SERIALIZER"] = "zeus_json"
app.config["CELERY_IGNORE_RESULT"] = True
app.config["CELERY_IMPORTS"] = ("zeus.tasks", )
app.config["CELERY_RESULT_BACKEND"] = None
app.config["CELERY_RESULT_SERIALIZER"] = "zeus_json"
# app.config['CELERY_SEND_EVENTS'] = False
app.config["CELERY_TASK_RESULT_EXPIRES"] = 1
app.config["CELERY_TASK_SERIALIZER"] = "zeus_json"
# dont let any task run longer than 5 minutes
app.config["CELERY_TASK_SOFT_TIME_LIMIT"] = 300
# hard kill tasks after 6 minutes
app.config["CELERY_TASK_TIME_LIMIT"] = 360
# app.config['CELERYD_PREFETCH_MULTIPLIER'] = 1
# app.config['CELERYD_MAX_TASKS_PER_CHILD'] = 10000
app.config["CELERYBEAT_SCHEDULE_FILE"] = os.path.join(
tempfile.gettempdir(), "zeus-celerybeat")
app.config["CELERYBEAT_SCHEDULE"] = {
"sync-all-repos": {
"task": "zeus.sync_all_repos",
"schedule": timedelta(minutes=5)
},
"cleanup-builds": {
"task": "zeus.cleanup_builds",
"schedule": timedelta(minutes=5)
},
"cleanup-artifacts": {
"task": "zeus.cleanup_artifacts",
"schedule": timedelta(minutes=60)
},
}
app.config["REDBEAT_REDIS_URL"] = app.config["REDIS_URL"]
app.config["WORKSPACE_ROOT"] = WORKSPACE_ROOT
app.config["REPO_ROOT"] = os.environ.get(
"REPO_ROOT", os.path.join(WORKSPACE_ROOT, "zeus-repos"))
app.config["ARTIFACT_RETENTION"] = timedelta(days=30)
if _read_config:
if os.environ.get("ZEUS_CONF"):
# ZEUS_CONF=/etc/zeus.conf.py
app.config.from_envvar("ZEUS_CONF")
else:
# Look for $WORKSPACE_ROOT/zeus.conf.py
app.config.from_pyfile(os.path.join(WORKSPACE_ROOT,
"zeus.config.py"),
silent=True)
app.wsgi_app = with_health_check(app.wsgi_app)
app.config.update(config)
app.config.setdefault("MAIL_SUPPRESS_SEND", app.debug or app.testing)
# HACK(dcramer): the CLI causes validation to happen on init, which it shouldn't
if "init" not in sys.argv:
req_vars = (
"GITHUB_CLIENT_ID",
"GITHUB_CLIENT_SECRET",
"REDIS_URL",
"SECRET_KEY",
"SQLALCHEMY_DATABASE_URI",
)
for varname in req_vars:
if not app.config.get(varname):
raise SystemExit(
"Required configuration not present for {}".format(
varname))
from zeus.testutils.client import ZeusTestClient
app.test_client_class = ZeusTestClient
if app.config.get("LOG_LEVEL"):
app.logger.setLevel(getattr(logging, app.config["LOG_LEVEL"].upper()))
# oauthlib compat
app.config["GITHUB_CONSUMER_KEY"] = app.config["GITHUB_CLIENT_ID"]
app.config["GITHUB_CONSUMER_SECRET"] = app.config["GITHUB_CLIENT_SECRET"]
# init sentry first
sentry.init_app(app)
# XXX(dcramer): Sentry + Flask + Logging integration is broken
# https://github.com/getsentry/raven-python/issues/1030
from raven.handlers.logging import SentryHandler
app.logger.addHandler(
SentryHandler(client=sentry.client, level=logging.WARN))
if app.config["SSL"]:
ssl.init_app(app)
configure_db(app)
# needs to happen after db
configure_scout(app)
redis.init_app(app)
mail.init_app(app)
celery.init_app(app, sentry)
configure_webpack(app)
configure_api(app)
configure_web(app)
from . import models # NOQA
return app
from .base import *
import raven
import environ
# env settings in env variable or env file
env = environ.Env(DEBUG=(bool, False), ) # set default values and casting
environ.Env.read_env(os.path.join(BASE_DIR, ".env")) # reading .env file
SECRET_KEY = env("SECRET_KEY")
ALLOWED_HOSTS = env("ALLOWED_HOSTS").split(",")
print("Allowed hosts:%s" % ALLOWED_HOSTS)
# get the current git release version
RELEASE = raven.fetch_git_sha(BASE_DIR)[:8]
print ("Aha!book release: %s" % RELEASE)
########## DEBUG
DEBUG = True
print("Debug mode:%s" % DEBUG)
# depreceated - https://docs.djangoproject.com/en/1.8/ref/settings/#template-debug
# set by DEBUG - https://docs.djangoproject.com/en/1.8/topics/templates/#django.template.backends.django.DjangoTemplates
# TEMPLATE_DEBUG = DEBUG
# SERVE_MEDIA = DEBUG
INSTALLED_APPS += [
'debug_toolbar',
]
default='https://www.googleapis.com/oauth2/v1/certs'),
'client_x509_cert_url':
env('GA_CLIENT_X509_CERT_URL', default='')
}
HOTJAR_CONFIG = {
'hjid': env.int('HOTJAR_ID', default=0),
'hjsv': env.int('HOTJAR_SV', default=0),
}
# Sentry
SENTRY_USER = env('SENTRY_USER', default='')
SENTRY_PASSWORD = env('SENTRY_PASSWORD', default='')
SENTRY_ADDRESS = env('SENTRY_ADDRESS', default='')
SENTRY_JS_DSN = env.str('SENTRY_JS_DSN', default='')
SENTRY_PROJECT = env('SENTRY_PROJECT', default='')
RELEASE = raven.fetch_git_sha(os.path.abspath(
os.pardir)) if SENTRY_USER else ''
RAVEN_JS_VERSION = env.str('RAVEN_JS_VERSION', default='3.26.4')
if SENTRY_ADDRESS and SENTRY_PROJECT:
RAVEN_CONFIG = {
'dsn':
f'https://{SENTRY_USER}:{SENTRY_PASSWORD}@{SENTRY_ADDRESS}/{SENTRY_PROJECT}',
'release': RELEASE,
}
# List of github usernames to not count as comments on an issue
IGNORE_COMMENTS_FROM = [
'gitcoinbot',
]
# optional: only needed if you run the activity-report management command
AWS_STORAGE_BUCKET_NAME = env('AWS_STORAGE_BUCKET_NAME', default='')
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
# not needed anymore due to migration to postgres
# 'OPTIONS': {
# 'init_command': "SET sql_mode='STRICT_TRANS_TABLES'",
# }
}
}
RAVEN_CONFIG = {
'dsn': '',
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha(os.path.dirname(__file__)),
}
# Email setting
EMAIL_USE_TLS = True
EMAIL_HOST = 'smtp.'
EMAIL_HOST_USER = '******'
EMAIL_HOST_PASSWORD = ''
EMAIL_PORT = 587
DEFAULT_FROM_EMAIL = '@avaika.me'
SERVER_EMAIL = '@avaika.me'
# Social auth
SOCIAL_AUTH_TWITTER_KEY = ''
SOCIAL_AUTH_TWITTER_SECRET = ''
import raven
INSTALLED_APPS = INSTALLED_APPS + ('raven.contrib.django.raven_compat', )
RAVEN_CONFIG = {
'dsn': os.environ['RAVEN_DSN'],
}
# Set the `server_name` attribute. See https://docs.sentry.io/hosted/clients/python/advanced/
server_name = os.environ.get('RAVEN_SERVER_NAME')
server_name = server_name or '.'.join(
filter(None, (os.environ.get('KOBOFORM_PUBLIC_SUBDOMAIN', None),
os.environ.get('PUBLIC_DOMAIN_NAME', None))))
if server_name:
RAVEN_CONFIG.update({'name': server_name})
try:
RAVEN_CONFIG['release'] = raven.fetch_git_sha(BASE_DIR)
except raven.exceptions.InvalidGitRepository:
pass
# The below is NOT required for Sentry to log unhandled exceptions, but it
# is necessary for capturing messages sent via the `logging` module.
# https://docs.getsentry.com/hosted/clients/python/integrations/django/#integration-with-logging
LOGGING = {
'version': 1,
'disable_existing_loggers':
False, # Was `True` in Sentry documentation
'root': {
'level': 'WARNING',
'handlers': ['sentry'],
},
'formatters': {
'verbose': {
'django': {
'handlers': [
{%- if cookiecutter.use_sentry == 'y' %}
'sentry',
{%- endif %}
'console',
],
'level': 'ERROR',
'propagate': True,
},
},
}
{%- if cookiecutter.use_sentry == 'y' %}
try:
release = raven.fetch_git_sha(root())
except raven.exceptions.InvalidGitRepository:
release = 'unknown'
RAVEN_CONFIG = {
'dsn': env('SENTRY_DSN'),
'release': release,
}
{%- endif %}
# if 'test' in sys.argv:
# DATABASES['default'] = {'ENGINE': 'django.db.backends.sqlite3'}
if DEBUG:
import socket
"user-agent",
"accept-encoding",
"accept-crs",
"content-crs",
)
# Raven
SENTRY_DSN = os.getenv("SENTRY_DSN")
if SENTRY_DSN:
INSTALLED_APPS = INSTALLED_APPS + ["raven.contrib.django.raven_compat"]
if "GIT_SHA" in os.environ:
GIT_SHA = os.getenv("GIT_SHA")
else:
GIT_SHA = raven.fetch_git_sha(BASE_DIR)
RAVEN_CONFIG = {"dsn": SENTRY_DSN, "release": GIT_SHA}
LOGGING["handlers"].update(
{
"sentry": {
"level": "WARNING",
"class": "raven.handlers.logging.SentryHandler",
"dsn": RAVEN_CONFIG["dsn"],
}
}
)
#
# SSL or not?
#
'backupCount': 5
}
LOGGING['loggers']['wagtail']['handlers'].append('wagtail_file')
# Error log
LOGGING['handlers']['errors_file'] = {
'level': 'ERROR',
'class': 'cloghandler.ConcurrentRotatingFileHandler',
'filename': os.path.join(env['LOG_DIR'], 'error.log'),
'maxBytes': 5242880, # 5MB
'backupCount': 5
}
LOGGING['loggers']['django.request']['handlers'].append('errors_file')
LOGGING['loggers']['django.security']['handlers'].append('errors_file')
try:
from .local import * # noqa
except ImportError:
pass
# Raven (sentry error logging)
# This must be after the .local import as RAVEN_DSN is set in local.py
if 'RAVEN_DSN' in os.environ:
RAVEN_CONFIG = {
'dsn': os.environ['RAVEN_DSN'],
'release': raven.fetch_git_sha(os.path.dirname(os.path.abspath(PROJECT_ROOT))),
}
if APM_SECRET_TOKEN:
ELASTIC_APM['SECRET_TOKEN'] = APM_SECRET_TOKEN
if DEBUG and ENV == 'stage':
ELASTIC_APM['DEBUG'] = True
AWS_ACCESS_KEY_ID = env('AWS_ACCESS_KEY_ID', default='')
AWS_SECRET_ACCESS_KEY = env('AWS_SECRET_ACCESS_KEY', default='')
AWS_DEFAULT_REGION = env('AWS_DEFAULT_REGION', default='us-west-2')
AWS_LOG_GROUP = env('AWS_LOG_GROUP', default='Gitcoin')
AWS_LOG_LEVEL = env('AWS_LOG_LEVEL', default='INFO')
AWS_LOG_STREAM = env('AWS_LOG_STREAM', default=f'{ENV}-web')
# Sentry
SENTRY_DSN = env.str('SENTRY_DSN', default='')
SENTRY_JS_DSN = env.str('SENTRY_JS_DSN', default=SENTRY_DSN)
RELEASE = raven.fetch_git_sha(os.path.abspath(
os.pardir)) if ENV == 'prod' else ''
RAVEN_JS_VERSION = env.str('RAVEN_JS_VERSION', default='3.26.4')
if SENTRY_DSN:
sentry_sdk.init(SENTRY_DSN,
integrations=[DjangoIntegration(),
CeleryIntegration()],
traces_sample_rate=0.35)
RAVEN_CONFIG = {
'dsn': SENTRY_DSN,
}
if RELEASE:
RAVEN_CONFIG['release'] = RELEASE
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
DEFAULT_FROM_EMAIL = '*****@*****.**'
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
# As required by debug_toolbar
INTERNAL_IPS = (
'10.0.2.2', # external
'127.0.0.1' # localhost
)
INSTALLED_APPS += (
#'debug_toolbar',
# 'debug_panel',
)
MIDDLEWARE_CLASSES = (
#'debug_toolbar.middleware.DebugToolbarMiddleware',
# 'debug_panel.middleware.DebugPanelMiddleware',
) + MIDDLEWARE_CLASSES
RAVEN_CONFIG.update({
'release': raven.fetch_git_sha(DJANGO_ROOT)
})
try:
from .local import *
except ImportError:
pass
#
# Show active environment in admin.
ENVIRONMENT = "production"
SHOW_ALERT = False
# We will assume we're running under https
SESSION_COOKIE_SECURE = True
SESSION_COOKIE_HTTPONLY = True
CSRF_COOKIE_SECURE = True
X_FRAME_OPTIONS = "DENY"
# Only set this when we're behind Nginx as configured in our example-deployment
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
SECURE_CONTENT_TYPE_NOSNIFF = True # Sets X-Content-Type-Options: nosniff
SECURE_BROWSER_XSS_FILTER = True # Sets X-XSS-Protection: 1; mode=block
#
# Library settings
#
# Raven
INSTALLED_APPS = INSTALLED_APPS + ["raven.contrib.django.raven_compat"]
RAVEN_CONFIG = {"dsn": "https://", "release": raven.fetch_git_sha(BASE_DIR)}
LOGGING["handlers"].update({
"sentry": {
"level": "WARNING",
"class": "raven.handlers.logging.SentryHandler",
"dsn": RAVEN_CONFIG["dsn"],
}
})
# Not used with sqlite3.
"USER": "******",
# Not used with sqlite3.
"PASSWORD": "******",
# Set to empty string for localhost. Not used with sqlite3.
"HOST": "127.0.0.1",
# Set to empty string for default. Not used with sqlite3.
"PORT": "",
}
}
RAVEN_CONFIG = {
'dsn': "%(sentry_dsn)s",
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha(dirname(dirname(dirname(dirname(__file__))))),
}
EMAIL_HOST = "%(email_host)s"
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTOCOL", "https")
CACHE_MIDDLEWARE_SECONDS = 60
TIMEOUT = 300
CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.memcached.MemcachedCache",
"LOCATION": "127.0.0.1:11211",
"KEY_PREFIX": "%(proj_name)s",
},
},
'loggers': {
'django': {
'handlers': ['console'],
'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'),
},
'importer': {
'handlers': ['console'],
'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'),
}
},
}
try:
GIT_VERSION = raven.fetch_git_sha(
os.path.abspath(os.path.join(BASE_DIR, "..")))
except raven.exceptions.InvalidGitRepository:
GIT_VERSION = "undef"
pass
RAVEN_CONFIG = {
'dsn': get_env_str('SENTRY_DSN', None),
'release': get_env_str('VERSION', GIT_VERSION),
}
MONGODB_HOST = get_env_str("MONGODB_HOST", "localhost")
MONGODB_PORT = get_env_int("MONGODB_PORT", 27017)
MONGODB_USERNAME = get_env_str("MONGODB_USERNAME", "")
MONGODB_PASSWORD = get_env_str("MONGODB_PASSWORD", "")
MONGODB_AUTH_DB = get_env_str("MONGODB_AUTH_DB", "admin")
MONGODB_DB = get_env_str("MONGODB_DB", "ragoogle_spiders")
AWS_SES_REGION_NAME = os.environ.get('AWS_SES_REGION_NAME')
AWS_SES_REGION_ENDPOINT = os.environ.get('AWS_SES_REGION_ENDPOINT')
''' Sentry configuration '''
# Optional Sentry configuration: if desired, be sure to install Raven and set
# RAVEN_DSN in the environment
if 'RAVEN_DSN' in os.environ:
try:
import raven
except ImportError:
print 'Please install Raven to enable Sentry logging.'
else:
INSTALLED_APPS = INSTALLED_APPS + (
'raven.contrib.django.raven_compat',
)
RAVEN_CONFIG = {
'dsn': os.environ['RAVEN_DSN'],
}
# Set the `server_name` attribute. See https://docs.sentry.io/hosted/clients/python/advanced/
server_name = os.environ.get('RAVEN_SERVER_NAME')
server_name = server_name or os.environ.get('KOBOCAT_PUBLIC_SUBDOMAIN', '') + \
os.environ.get('PUBLIC_DOMAIN_NAME', '')
if server_name:
RAVEN_CONFIG.update({'name': server_name})
try:
RAVEN_CONFIG['release'] = raven.fetch_git_sha(BASE_DIR)
except raven.exceptions.InvalidGitRepository:
pass
USE_I18N = True
USE_L10N = True
USE_TZ = False
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/
STATIC_URL = '/static/'
LISTNER_URL = listner_url
LISTNER_PORT = listner_port
PRINTER_URL = printer_url
LOGIN_REDIRECT_URL = '/queue/'
STATIC_ROOT = '/home/admintrud/shawarma/shawarma_rep/static_content/static/'
RAVEN_CONFIG = {
'dsn': raven_dsn,
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha(os.path.abspath(os.pardir)),
}
# }
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'postgres',
'USER': '******',
'HOST': 'db',
'PORT': 5432,
}
}
RAVEN_CONFIG = {
'dsn': 'http://*****:*****@sentry:9000/1',
# If you are using git, you can also automatically configure the
# release based on the git info.
'release': raven.fetch_git_sha(os.path.abspath(os.pardir)),
}
LOGGING = {
'version': 1,
'disable_existing_loggers': True,
'root': {
'level': 'WARNING',
'handlers': ['sentry'],
},
'formatters': {
'verbose': {
'format': '%(levelname)s %(asctime)s %(module)s '
'%(process)d %(thread)d %(message)s'
},
},
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')
REST_FRAMEWORK = {
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.IsAdminUser',
],
'DEFAULT_RENDERER_CLASSES': ('rest_framework.renderers.JSONRenderer', )
}
import raven
RAVEN_CONFIG = {
'environment': 'production',
'dsn': os.getenv("SENTRY_DSN"),
'release': raven.fetch_git_sha(os.path.dirname(os.pardir)),
}
LOGGING = {
'version': 1,
'disable_existing_loggers': True,
'root': {
'level': 'INFO',
'handlers': ['sentry'],
},
'formatters': {
'simple': {
'format': '%(asctime)s SENDER_NAME PROGRAM_NAME: %(message)s',
'datefmt': '%Y-%m-%dT%H:%M:%S',
},
'verbose': {
# more details on how to customize your logging configuration.
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"filters": {"require_debug_false": {"()": "django.utils.log.RequireDebugFalse"}},
"handlers": {
"mail_admins": {
"level": "ERROR",
"filters": ["require_debug_false"],
"class": "django.utils.log.AdminEmailHandler",
}
},
"loggers": {"django.request": {"handlers": ["mail_admins"], "level": "ERROR", "propagate": True}},
}
ADMINS = (
("Ian Dees", "*****@*****.**"),
("Joe Germuska", "*****@*****.**"),
("Ryan Pitts", "*****@*****.**"),
)
MANAGERS = ADMINS
API_URL = "https://api.censusreporter.org"
import raven
RAVEN_CONFIG = {
"dsn": os.environ.get("SENTRY_DSN"),
"release": raven.fetch_git_sha(os.path.dirname(__file__) + "/../../.."),
}
# Visually differentiate the environments from prod:
# with a colored breadcrumb...
CRUDLFAP_TEMPLATE_BACKEND['OPTIONS']['constants'].update(
dict(BACKGROUND_COLOR=COLORS.get(INSTANCE.upper(), ''), ))
# and the page's title.
TITLE_SUFFIX = ""
if INSTANCE.upper() != 'PRODUCTION':
TITLE_SUFFIX = " ({})".format(INSTANCE.upper())
RELEASE = os.getenv('GIT_COMMIT', '')
if not RELEASE:
repo = os.path.join(os.path.dirname(__file__), '..', '..')
if os.path.exists(os.path.join(repo, '.git')):
RELEASE = raven.fetch_git_sha(repo)
RAVEN_CONFIG = dict(
dsn=os.getenv('SENTRY_DSN', ''),
transport=RequestsHTTPTransport,
)
RAVEN_PUBLIC_CONFIG = dict(
environment=INSTANCE,
release=RELEASE,
)
RAVEN_CONFIG.update(RAVEN_PUBLIC_CONFIG)
SENTRY_PUBLIC_DSN = strip_password(RAVEN_CONFIG['dsn'])
CRUDLFAP_TEMPLATE_BACKEND['OPTIONS']['constants'].update(
dict(
SENTRY_DSN=SENTRY_PUBLIC_DSN,
