def parse_redis_url(redis_url):
params = dj_redis_url.parse(redis_url)
conn_kwargs = {}
conn_kwargs['host'] = params['HOST']
conn_kwargs['password'] = params['PASSWORD']
conn_kwargs['dbid'] = params['DB']
conn_kwargs['port'] = params['PORT']
# Remove items with empty values
conn_kwargs = dict((k, v) for k, v in conn_kwargs.items() if v)
return conn_kwargs
def redis(self):
logging.info("configuring template environment...")
if self.redis_url is None:
logging.info("connect to localhost")
client = tornadoredis.Client()
else:
logging.info("connect to {0}".format(self.redis_url))
redis_config = dj_redis_url.parse(self.redis_url)
client = tornadoredis.Client(host=redis_config['HOST'],
password=redis_config['PASSWORD'],
port=redis_config['PORT'],
selected_db=redis_config['DB'])
client.connect()
logging.info("redis connected.")
return client
def patch_cacheops(g):
REDIS_URL = g.get('REDIS_URL')
if not REDIS_URL:
return
log_setting('CACHEOPS', 'is enabled')
g['CACHEOPS_REDIS'] = keymap(str.lower, dj_redis_url.parse(REDIS_URL))
g['INSTALLED_APPS'].append('cacheops')
g['CACHEOPS_DEGRADE_ON_FAILURE'] = True
g['CACHEOPS_DEFAULTS'] = {'timeout': IN_SECONDS.FIFTEEN_MINUTES}
g['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': 'get'},
'core.user': {'ops': 'get'},
# Automatically cache all gets and queryset fetches
# to other django.contrib.auth models for an hour
'auth.*': {'ops': ('fetch', 'get'), 'timeout': IN_SECONDS.ONE_HOUR},
# Cache gets, fetches, counts and exists to Permission
# 'all' is just an alias for ('get', 'fetch', 'count', 'exists')
'auth.permission': {'ops': 'all', 'timeout': IN_SECONDS.ONE_HOUR},
# Basically Never changing objects. Allow local_get (in memory)
'event.event': {'ops': 'all', 'local_get': True},
'ticket.tickettype': {'ops': 'all', 'local_get': True},
'ticket.tickettier': {'ops': 'all', 'local_get': True},
'ticket.ticketaddontype': {'ops': 'all', 'local_get': False},
# Enable manual caching on all other models with default timeout of an hour
# Use Post.objects.cache().get(...)
# or Tags.objects.filter(...).order_by(...).cache()
# to cache particular ORM request.
# Invalidation is still automatic
'*.*': {'ops': (), 'timeout': IN_SECONDS.ONE_HOUR},
# And since ops is empty by default you can rewrite last line as:
'*.*': {'timeout': IN_SECONDS.ONE_HOUR},
}
def parse_redis_url(redis_url):
"""
Parses redis url and prepares arguments for
txredisapi.lazyConnectionPool()
"""
params = dj_redis_url.parse(redis_url)
conn_kwargs = {}
conn_kwargs['host'] = params['HOST']
conn_kwargs['password'] = params['PASSWORD']
conn_kwargs['dbid'] = params['DB']
conn_kwargs['port'] = params['PORT']
# Remove items with empty values
conn_kwargs = dict((k, v) for k, v in conn_kwargs.iteritems() if v)
return conn_kwargs
def parse_redis_url(redis_url):
"""
Parses redis url and prepares arguments for
txredisapi.lazyConnectionPool()
"""
params = dj_redis_url.parse(redis_url)
conn_kwargs = {}
conn_kwargs['host'] = params['HOST']
conn_kwargs['password'] = params['PASSWORD']
conn_kwargs['dbid'] = params['DB']
conn_kwargs['port'] = params['PORT']
# Remove items with empty values
conn_kwargs = dict((k, v) for k, v in conn_kwargs.iteritems() if v)
return conn_kwargs
# Use only to restrict to specific servers/domains
CORS_ORIGIN_WHITELIST = (
'stanford-qa.com',
)
CORS_URLS_REGEX = r'^/api/done/*$'
CORS_ALLOW_METHODS = (
'GET',
'POST',
'OPTIONS'
)
SITE_HOST = os.environ.get('SITE_HOST', 'https://daemo.herokuapp.com')
REDIS_URL = os.environ.get('REDIS_URL', 'redis://localhost:6379')
REDIS_CONNECTION = dj_redis_url.parse(REDIS_URL)
# MTurk
MTURK_CLIENT_ID = os.environ.get('MTURK_CLIENT_ID', 'INVALID')
MTURK_CLIENT_SECRET = os.environ.get('MTURK_CLIENT_SECRET', 'INVALID')
MTURK_HOST = os.environ.get('MTURK_HOST', 'mechanicalturk.sandbox.amazonaws.com')
MTURK_WORKER_HOST = os.environ.get('MTURK_WORKER_HOST', 'https://workersandbox.mturk.com/mturk/externalSubmit')
ID_HASH_MIN_LENGTH = 8
MTURK_WORKER_USERNAME = '******'
MTURK_QUALIFICATIONS = os.environ.get('MTURK_QUALIFICATIONS', True)
MTURK_BEAT = os.environ.get('MTURK_BEAT', 1)
# Celery
BROKER_URL = REDIS_URL
CELERY_RESULT_BACKEND = REDIS_URL
CELERY_ACCEPT_CONTENT = ['application/json']
MEDIA_URL = ''
STATIC_ROOT = os.path.join(PROJECT_DIR, 'staticfiles')
# URL that handles the static files served from STATIC_ROOT.
# Example: "http://media.lawrence.com/static/"
STATIC_URL = '/static/'
SESSION_ENGINE = 'redis_sessions_fork.session'
SESSION_REDIS_PREFIX = 'session'
try:
REDIS_URL = os.environ['REDIS_URL']
CAPITAL_WS4REDIS_CONNECTION = dj_redis_url.parse(REDIS_URL)
WS4REDIS_CONNECTION = {
'host': CAPITAL_WS4REDIS_CONNECTION['HOST'],
'port': CAPITAL_WS4REDIS_CONNECTION['PORT'],
'db': CAPITAL_WS4REDIS_CONNECTION['DB'],
'password': CAPITAL_WS4REDIS_CONNECTION['PASSWORD'],
}
SESSION_REDIS_URL=REDIS_URL
except:
print "REDIS_URL was not found in env"
TEMPLATE_CONTEXT_PROCESSORS = (
'django.contrib.auth.context_processors.auth',
'django.core.context_processors.static',
'django.core.context_processors.request',
},
},
]
location = lambda x: os.path.join(
os.path.dirname(os.path.realpath(__file__)), x)
########## END TEMPLATE CONFIGURATION
########## SESSION CONFIGURATION
SESSION_ENGINE = 'redis_sessions_fork.session'
try:
SESSION_REDIS_URL = os.environ.get('REDISCLOUD_URL')
CAPITAL_WS4REDIS_CONNECTION = dj_redis_url.parse(SESSION_REDIS_URL)
SESSION_REDIS_HOST = CAPITAL_WS4REDIS_CONNECTION['HOST']
SESSION_REDIS_PORT = CAPITAL_WS4REDIS_CONNECTION['PORT']
SESSION_REDIS_DB = CAPITAL_WS4REDIS_CONNECTION['DB']
SESSION_REDIS_PASSWORD = CAPITAL_WS4REDIS_CONNECTION['PASSWORD']
except:
print "REDISCLOUD_URL was not found in env"
SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'
SESSION_SAVE_EVERY_REQUEST = True
SESSION_IDLE_TIMEOUT = 30000
WS4REDIS_EXPIRE=0
's3',
aws_access_key_id=os.environ.get('AWS_ACCESS_KEY', None),
aws_secret_access_key=os.environ.get('AWS_SECRECT_ACCESS_KEY', None),
)
image_bucket = s3_conn.Bucket(BUCKET_NAME) if BUCKET_NAME else None
else:
image_bucket = BUCKET_NAME = None
IMGUR_CLIENT_ID = os.environ.get('IMGUR_CLIENT_ID', None)
RQ_SHOW_ADMIN_LINK = False
if PRODUCTION == True:
REDIS_URL = os.environ['REDIS_URL']
REDIS_CONN = dj_redis_url.parse(REDIS_URL)
RQ_QUEUES = {
'default': {
'HOST': REDIS_CONN['HOST'],
'PORT': REDIS_CONN['PORT'],
'DB': 0,
'PASSWORD': REDIS_CONN['PASSWORD'],
'DEFAULT_TIMEOUT': 36000,
},
}
else:
RQ_QUEUES = {
'default': {
'HOST': 'redis',
'PORT': 6379,
'DB': 0,
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
# SECURITY WARNING: don't run with debug turned on in production!
if os.environ.get('PRODUCTION'):
DEBUG = False
SECRET_KEY = os.environ.get("DJANGO_SECRET_KEY")
DBCONF = dj_database_url.parse(os.environ.get("DATABASE_URL"))
# Redis Cache
cache_vars = dj_redis_url.parse(os.environ.get("REDISCLOUD_URL"))
CACHES = {
'default': {
'BACKEND': 'redis_cache.RedisCache',
'LOCATION': '{0}:{1}'.format(cache_vars['HOST'],
cache_vars['PORT']),
'OPTIONS': {
'DB': cache_vars['DB'],
'PASSWORD': cache_vars['PASSWORD'],
'PARSER_CLASS': 'redis.connection.HiredisParser',
'CONNECTION_POOL_CLASS': 'redis.BlockingConnectionPool',
'CONNECTION_POOL_CLASS_KWARGS': {
'max_connections': 19,
'timeout': 20,
}
},
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
# SECURITY WARNING: don't run with debug turned on in production!
if os.environ.get("PRODUCTION"):
DEBUG = False
SECRET_KEY = os.environ.get("DJANGO_SECRET_KEY")
DBCONF = dj_database_url.parse(os.environ.get("DATABASE_URL"))
# Redis Cache
cache_vars = dj_redis_url.parse(os.environ.get("REDISCLOUD_URL"))
CACHES = {
"default": {
"BACKEND": "redis_cache.RedisCache",
"LOCATION": "{0}:{1}".format(cache_vars["HOST"], cache_vars["PORT"]),
"OPTIONS": {
"DB": cache_vars["DB"],
"PASSWORD": cache_vars["PASSWORD"],
"PARSER_CLASS": "redis.connection.HiredisParser",
"CONNECTION_POOL_CLASS": "redis.BlockingConnectionPool",
"CONNECTION_POOL_CLASS_KWARGS": {"max_connections": 19, "timeout": 20},
},
}
}
# CacheOps
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
'base_auth.site.context_processors.site_url',
],
},
},
]
WSGI_APPLICATION = 'base_auth.wsgi.application'
DATABASES = {'default': dj_database_url.config()}
REDIS = {
'default': {
k.lower(): v
for k, v in dj_redis_url.parse(os.environ['REDIS_URL']).items()
},
}
AUTH_PASSWORD_VALIDATORS = [
{
'NAME':
'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.CommonPasswordValidator',
],
}
boilerplate_name = locals().get('ALDRYN_BOILERPLATE_NAME', 'legacy')
if boilerplate_name == 'bootstrap3':
CKEDITOR_SETTINGS['stylesSet'] = 'default:/static/js/addons/ckeditor.wysiwyg.js'
CKEDITOR_SETTINGS['contentsCss'] = ['/static/css/base.css']
else:
CKEDITOR_SETTINGS['stylesSet'] = 'default:/static/js/modules/ckeditor.wysiwyg.js'
CKEDITOR_SETTINGS['contentsCss'] = ['/static/css/base.css']
# OPTIONAL REDIS
REDIS_URL = locals().get('REDIS_URL', '')
if REDIS_URL:
import dj_redis_url
redis = dj_redis_url.parse(REDIS_URL)
CACHES = {
'default': {
'BACKEND': 'redis_cache.RedisCache',
'LOCATION': str(redis['HOST']) + ':' + str(redis['PORT']), # '{HOST}:{PORT}'.format(redis),
'OPTIONS': {
'DB': 10,
'PASSWORD': redis['PASSWORD'],
'PARSER_CLASS': 'redis.connection.HiredisParser',
'CONNECTION_POOL_CLASS': 'redis.BlockingConnectionPool',
'CONNECTION_POOL_CLASS_KWARGS': {
'max_connections': 50,
'timeout': 20,
},
'MAX_CONNECTIONS': 1000,
},
