def sample_is_active(sample_name, current_site=None, site_is_none=None):
"""If current_site is not given, then use Site.objects.get_current(),
unless site_is_none is True, then look for a sample with no site.
"""
from .models import cache_sample, Sample
from .compat import cache
if current_site is None:
if site_is_none:
current_site = None
else:
current_site = Site.objects.get_current()
sample = cache.get(keyfmt(get_setting('SAMPLE_CACHE_KEY'), sample_name, current_site))
if sample is None:
try:
sample = Sample.objects.get(name=sample_name, site=current_site)
cache_sample(instance=sample)
except Sample.DoesNotExist:
try:
sample = Sample.objects.get(name=sample_name, site__isnull=True)
cache_sample(instance=sample)
except Sample.DoesNotExist:
return get_setting('SAMPLE_DEFAULT')
return Decimal(str(random.uniform(0, 100))) <= sample.percent
def get_flush_keys(self, flush_keys=None):
flush_keys = super(AbstractUserFlag, self).get_flush_keys(flush_keys)
flush_keys.extend([
keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), self.name),
keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), self.name),
])
return flush_keys
def _flag_is_active_for_user(flag, user=None, **kwargs):
if flag.staff and user.is_staff:
return True
if flag.superusers and user.is_superuser:
return True
flag_users = cache.get(keyfmt(get_setting('FLAG_USERS_CACHE_KEY'),
flag.name))
if flag_users is None:
flag_users = flag.users.all()
cache_flag(instance=flag)
if user in flag_users:
return True
flag_groups = cache.get(keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'),
flag.name))
if flag_groups is None:
flag_groups = flag.groups.all()
cache_flag(instance=flag)
user_groups = user.groups.all()
for group in flag_groups:
if group in user_groups:
return True
def get_flush_keys(self, flush_keys=None):
flush_keys = super(AbstractUserFlag, self).get_flush_keys(flush_keys)
flush_keys.extend([
keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), self.name),
keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), self.name),
])
return flush_keys
def uncache_switch(**kwargs):
switch = kwargs.get('instance')
cache.set(keyfmt(get_setting('SWITCH_CACHE_KEY'), switch.name), None, 5)
cache.set(
keyfmt(get_setting('SWITCHES_SITES_CACHE_KEY'), switch.name), None, 5)
cache.set(keyfmt(get_setting('ALL_SWITCHES_CACHE_KEY')), None, 5)
def switch_is_active(switch_name, current_site=None, site_is_none=False):
"""If current_site is not given, then use Site.objects.get_current(),
unless site_is_none is True, then look for a switch with no site.
"""
from .models import cache_switch, Switch
from .compat import cache
if current_site is None:
if site_is_none:
current_site = None
else:
current_site = Site.objects.get_current()
switch = cache.get(keyfmt(get_setting('SWITCH_CACHE_KEY'), switch_name, current_site))
if switch is None:
try:
switch = Switch.objects.get(name=switch_name, site=current_site)
cache_switch(instance=switch)
except Switch.DoesNotExist:
try:
switch = Switch.objects.get(name=switch_name, site__isnull=True)
cache_switch(instance=switch)
except Switch.DoesNotExist:
return get_setting('SWITCH_DEFAULT')
return switch.active
def flush(self):
keys = [
self._cache_key(self.name),
keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), self.name),
keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), self.name),
get_setting('ALL_FLAGS_CACHE_KEY'),
]
cache.delete_many(keys)
def flush(self):
keys = [
self._cache_key(self.name),
keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), self.name),
keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), self.name),
get_setting('ALL_FLAGS_CACHE_KEY'),
]
cache.delete_many(keys)
def cache_flag(**kwargs):
action = kwargs.get("action", None)
# action is included for m2m_changed signal. Only cache on the post_*.
if not action or action in ["post_add", "post_remove", "post_clear"]:
f = kwargs.get("instance")
cache.add(keyfmt(get_setting("FLAG_CACHE_KEY"), f.name), f)
cache.add(keyfmt(get_setting("FLAG_USERS_CACHE_KEY"), f.name), f.users.all())
cache.add(keyfmt(get_setting("FLAG_GROUPS_CACHE_KEY"), f.name), f.groups.all())
def uncache_flag(**kwargs):
flag = kwargs.get("instance")
data = {
keyfmt(get_setting("FLAG_CACHE_KEY"), flag.name): None,
keyfmt(get_setting("FLAG_USERS_CACHE_KEY"), flag.name): None,
keyfmt(get_setting("FLAG_GROUPS_CACHE_KEY"), flag.name): None,
keyfmt(get_setting("ALL_FLAGS_CACHE_KEY")): None,
}
cache.set_many(data, 5)
def uncache_flag(**kwargs):
flag = kwargs.get('instance')
data = {
keyfmt(get_setting('FLAG_CACHE_KEY'), flag.name): None,
keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), flag.name): None,
keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), flag.name): None,
keyfmt(get_setting('ALL_FLAGS_CACHE_KEY')): None
}
cache.set_many(data, 5)
def uncache_flag(**kwargs):
flag = kwargs.get('instance')
data = [
keyfmt(get_setting('FLAG_CACHE_KEY'), flag.name, flag.site),
keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), flag.name, flag.site),
keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), flag.name, flag.site),
keyfmt(get_setting('ALL_FLAGS_CACHE_KEY'))
]
cache.delete_many(data)
def uncache_flag(**kwargs):
flag = kwargs.get('instance')
data = {
keyfmt(get_setting('FLAG_CACHE_KEY'), flag.name): None,
keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), flag.name): None,
keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), flag.name): None,
keyfmt(get_setting('ALL_FLAGS_CACHE_KEY')): None
}
cache.set_many(data, 5)
def flag_is_active(request, flag_name):
from .models import cache_flag, Flag
from .compat import cache
flag = cache.get(keyfmt(get_setting('FLAG_CACHE_KEY'), flag_name))
if flag is None:
try:
flag = Flag.objects.get(name=flag_name)
cache_flag(instance=flag)
except Flag.DoesNotExist:
return get_setting('FLAG_DEFAULT')
if get_setting('OVERRIDE'):
if flag_name in request.GET:
return request.GET[flag_name] == '1'
if flag.everyone:
return True
elif flag.everyone is False:
return False
if flag.testing: # Testing mode is on.
tc = get_setting('TEST_COOKIE') % flag_name
if tc in request.GET:
on = request.GET[tc] == '1'
if not hasattr(request, 'waffle_tests'):
request.waffle_tests = {}
request.waffle_tests[flag_name] = on
return on
if tc in request.COOKIES:
return request.COOKIES[tc] == 'True'
if flag.languages:
languages = flag.languages.split(',')
if (hasattr(request, 'LANGUAGE_CODE') and
request.LANGUAGE_CODE in languages):
return True
if flag.percent and flag.percent > 0:
if not hasattr(request, 'waffles'):
request.waffles = {}
elif flag_name in request.waffles:
return request.waffles[flag_name][0]
cookie = get_setting('COOKIE') % flag_name
if cookie in request.COOKIES:
flag_active = (request.COOKIES[cookie] == 'True')
set_flag(request, flag_name, flag_active, flag.rollout)
return flag_active
if Decimal(str(random.uniform(0, 100))) <= flag.percent:
set_flag(request, flag_name, True, flag.rollout)
return True
set_flag(request, flag_name, False, flag.rollout)
return flag_is_active_for_user(request.user, flag_name)
def is_active(self):
if not self.pk:
if get_setting('CREATE_MISSING_SWITCHES'):
Switch.objects.get_or_create(
name=self.name,
defaults={'active': get_setting('SWITCH_DEFAULT')})
return get_setting('SWITCH_DEFAULT')
return self.active
def cache_flag(**kwargs):
action = kwargs.get('action', None)
# action is included for m2m_changed signal. Only cache on the post_*.
if not action or action in ['post_add', 'post_remove', 'post_clear']:
f = kwargs.get('instance')
cache.add(keyfmt(get_setting('FLAG_CACHE_KEY'), f.name, f.site), f)
cache.add(keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), f.name, f.site),
f.users.all())
cache.add(keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), f.name, f.site),
f.groups.all())
def cache_flag(**kwargs):
action = kwargs.get('action', None)
# action is included for m2m_changed signal. Only cache on the post_*.
if not action or action in ['post_add', 'post_remove', 'post_clear']:
f = kwargs.get('instance')
cache.add(keyfmt(get_setting('FLAG_CACHE_KEY'), f.name), f)
cache.add(keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), f.name),
f.users.all())
cache.add(keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), f.name),
f.groups.all())
def _generate_waffle_js(request):
flags = cache.get(keyfmt(get_setting('ALL_FLAGS_CACHE_KEY')))
if flags is None:
flags = Flag.objects.values_list('name', flat=True)
cache.add(keyfmt(get_setting('ALL_FLAGS_CACHE_KEY')), flags)
flag_values = [(f, flag_is_active(request, f)) for f in flags]
switches = cache.get(keyfmt(get_setting('ALL_SWITCHES_CACHE_KEY')))
if switches is None:
switches = Switch.objects.values_list('name', 'active')
cache.add(keyfmt(get_setting('ALL_SWITCHES_CACHE_KEY')), switches)
samples = cache.get(keyfmt(get_setting('ALL_SAMPLES_CACHE_KEY')))
if samples is None:
samples = Sample.objects.values_list('name', flat=True)
cache.add(keyfmt(get_setting('ALL_SAMPLES_CACHE_KEY')), samples)
sample_values = [(s, sample_is_active(s)) for s in samples]
return loader.render_to_string(
'waffle/waffle.js', {
'flags': flag_values,
'switches': switches,
'samples': sample_values,
'flag_default': get_setting('FLAG_DEFAULT'),
'switch_default': get_setting('SWITCH_DEFAULT'),
'sample_default': get_setting('SAMPLE_DEFAULT'),
})
def _generate_waffle_js(request):
flags = cache.get(keyfmt(get_setting('ALL_FLAGS_CACHE_KEY')))
if flags is None:
flags = Flag.objects.values_list('name', flat=True)
cache.add(keyfmt(get_setting('ALL_FLAGS_CACHE_KEY')), flags)
flag_values = [(f, flag_is_active(request, f)) for f in flags]
switches = cache.get(keyfmt(get_setting('ALL_SWITCHES_CACHE_KEY')))
if switches is None:
switches = Switch.objects.values_list('name', 'active')
cache.add(keyfmt(get_setting('ALL_SWITCHES_CACHE_KEY')), switches)
samples = cache.get(keyfmt(get_setting('ALL_SAMPLES_CACHE_KEY')))
if samples is None:
samples = Sample.objects.values_list('name', flat=True)
cache.add(keyfmt(get_setting('ALL_SAMPLES_CACHE_KEY')), samples)
sample_values = [(s, sample_is_active(s)) for s in samples]
return loader.render_to_string('waffle/waffle.js', {
'flags': flag_values,
'switches': switches,
'samples': sample_values,
'flag_default': get_setting('FLAG_DEFAULT'),
'switch_default': get_setting('SWITCH_DEFAULT'),
'sample_default': get_setting('SAMPLE_DEFAULT'),
})
def is_active(self):
if not self.pk:
if get_setting('CREATE_MISSING_SAMPLES'):
default_percent = 100 if get_setting('SAMPLE_DEFAULT') else 0
Sample.objects.get_or_create(
name=self.name, defaults={'percent': default_percent})
return get_setting('SAMPLE_DEFAULT')
return Decimal(str(random.uniform(0, 100))) <= self.percent
def sample_is_active(sample_name):
from .models import cache_sample, Sample
from .compat import cache
sample = cache.get(keyfmt(get_setting('SAMPLE_CACHE_KEY'), sample_name))
if sample is None:
try:
sample = Sample.objects.get(name=sample_name)
cache_sample(instance=sample)
except Sample.DoesNotExist:
return get_setting('SAMPLE_DEFAULT')
return Decimal(str(random.uniform(0, 100))) <= sample.percent
def is_active(self):
if not self.pk:
if get_setting('LOG_MISSING_SWITCHES'):
logger.log(level=get_setting('LOG_MISSING_SWITCHES'),
msg=("Switch %s not found", self.name))
if get_setting('CREATE_MISSING_SWITCHES'):
Switch.objects.get_or_create(
name=self.name,
defaults={'active': get_setting('SWITCH_DEFAULT')})
return get_setting('SWITCH_DEFAULT')
return self.active
def sample_is_active(sample_name):
from .models import cache_sample, Sample
from .compat import cache
sample = cache.get(keyfmt(get_setting('SAMPLE_CACHE_KEY'), sample_name))
if sample is None:
try:
sample = Sample.objects.get(name=sample_name)
cache_sample(instance=sample)
except Sample.DoesNotExist:
return get_setting('SAMPLE_DEFAULT')
return Decimal(str(random.uniform(0, 100))) <= sample.percent
def sample_is_active(request, sample_name):
from .models import cache_sample, Sample
from .compat import cache
current_site = Site.objects.get_current(request)
sample = cache.get(keyfmt(get_setting("SAMPLE_CACHE_KEY"), sample_name, current_site))
if sample is None:
sample = Sample.objects.filter(name=sample_name).first()
if sample is None:
return get_setting("SAMPLE_DEFAULT")
cache_sample(instance=sample)
return probe_a_sample(sample) and current_site in sample.get_sites()
def switch_is_active(request, switch_name):
from .models import cache_switch, Switch
from .compat import cache
current_site = Site.objects.get_current(request)
switch = cache.get(keyfmt(get_setting("SWITCH_CACHE_KEY"), switch_name, current_site))
if switch is None:
switch = Switch.objects.filter(name=switch_name).first()
if switch is None:
return get_setting("SWITCH_DEFAULT")
cache_switch(instance=switch)
return switch.active and current_site in switch.get_sites()
def is_active(self, request):
if not self.pk:
return get_setting('FLAG_DEFAULT')
if get_setting('OVERRIDE'):
if self.name in request.GET:
return request.GET[self.name] == '1'
if self.everyone:
return True
elif self.everyone is False:
return False
if self.testing: # Testing mode is on.
tc = get_setting('TEST_COOKIE') % self.name
if tc in request.GET:
on = request.GET[tc] == '1'
if not hasattr(request, 'waffle_tests'):
request.waffle_tests = {}
request.waffle_tests[self.name] = on
return on
if tc in request.COOKIES:
return request.COOKIES[tc] == 'True'
active_for_language = self._is_active_for_language(request)
if active_for_language is not None:
return active_for_language
active_for_user = self._is_active_for_user(request)
if active_for_user is not None:
return active_for_user
if self.percent and self.percent > 0:
if not hasattr(request, 'waffles'):
request.waffles = {}
elif self.name in request.waffles:
return request.waffles[self.name][0]
cookie = get_setting('COOKIE') % self.name
if cookie in request.COOKIES:
flag_active = (request.COOKIES[cookie] == 'True')
set_flag(request, self.name, flag_active, self.rollout)
return flag_active
if Decimal(str(random.uniform(0, 100))) <= self.percent:
set_flag(request, self.name, True, self.rollout)
return True
set_flag(request, self.name, False, self.rollout)
return False
def is_active(self, request):
if not self.pk:
return get_setting('FLAG_DEFAULT')
if get_setting('OVERRIDE'):
if self.name in request.GET:
return request.GET[self.name] == '1'
if self.everyone:
return True
elif self.everyone is False:
return False
if self.testing: # Testing mode is on.
tc = get_setting('TEST_COOKIE') % self.name
if tc in request.GET:
on = request.GET[tc] == '1'
if not hasattr(request, 'waffle_tests'):
request.waffle_tests = {}
request.waffle_tests[self.name] = on
return on
if tc in request.COOKIES:
return request.COOKIES[tc] == 'True'
active_for_language = self._is_active_for_language(request)
if active_for_language is not None:
return active_for_language
active_for_user = self._is_active_for_user(request)
if active_for_user is not None:
return active_for_user
if self.percent and self.percent > 0:
if not hasattr(request, 'waffles'):
request.waffles = {}
elif self.name in request.waffles:
return request.waffles[self.name][0]
cookie = get_setting('COOKIE') % self.name
if cookie in request.COOKIES:
flag_active = (request.COOKIES[cookie] == 'True')
set_flag(request, self.name, flag_active, self.rollout)
return flag_active
if Decimal(str(random.uniform(0, 100))) <= self.percent:
set_flag(request, self.name, True, self.rollout)
return True
set_flag(request, self.name, False, self.rollout)
return False
def is_active(self, request):
if not self.pk:
if get_setting('LOG_MISSING_FLAGS'):
logger.log(level=get_setting('LOG_MISSING_FLAGS'), msg=("Flag %s not found", self.name))
if get_setting('CREATE_MISSING_FLAGS'):
get_waffle_flag_model().objects.get_or_create(
name=self.name,
defaults={
'everyone': get_setting('FLAG_DEFAULT')
}
)
return get_setting('FLAG_DEFAULT')
if get_setting('OVERRIDE'):
if self.name in request.GET:
return request.GET[self.name] == '1'
if self.everyone:
return True
elif self.everyone is False:
return False
if self.testing: # Testing mode is on.
tc = get_setting('TEST_COOKIE') % self.name
if tc in request.GET:
on = request.GET[tc] == '1'
if not hasattr(request, 'waffle_tests'):
request.waffle_tests = {}
request.waffle_tests[self.name] = on
return on
if tc in request.COOKIES:
return request.COOKIES[tc] == 'True'
active_for_language = self._is_active_for_language(request)
if active_for_language is not None:
return active_for_language
active_for_user = self._is_active_for_user(request)
if active_for_user is not None:
return active_for_user
if self.percent and self.percent > 0:
if not hasattr(request, 'waffles'):
request.waffles = {}
elif self.name in request.waffles:
return request.waffles[self.name][0]
cookie = get_setting('COOKIE') % self.name
if cookie in request.COOKIES:
flag_active = (request.COOKIES[cookie] == 'True')
set_flag(request, self.name, flag_active, self.rollout)
return flag_active
if Decimal(str(random.uniform(0, 100))) <= self.percent:
set_flag(request, self.name, True, self.rollout)
return True
set_flag(request, self.name, False, self.rollout)
return False
def is_active(self):
if not self.pk:
log_level = get_setting('LOG_MISSING_SAMPLES')
if log_level:
logger.log(log_level, 'Sample %s not found', self.name)
if get_setting('CREATE_MISSING_SAMPLES'):
default_percent = 100 if get_setting('SAMPLE_DEFAULT') else 0
Sample.objects.get_or_create(
name=self.name, defaults={'percent': default_percent})
return get_setting('SAMPLE_DEFAULT')
return Decimal(str(random.uniform(0, 100))) <= self.percent
def is_active(self):
if not self.pk:
if get_setting('LOG_MISSING_SWITCHES'):
logger.log(level=get_setting('LOG_MISSING_SWITCHES'), msg=("Switch %s not found", self.name))
if get_setting('CREATE_MISSING_SWITCHES'):
Switch.objects.get_or_create(
name=self.name,
defaults={
'active': get_setting('SWITCH_DEFAULT')
}
)
return get_setting('SWITCH_DEFAULT')
return self.active
def is_active(self):
if not self.pk:
log_level = get_setting('LOG_MISSING_SWITCHES')
if log_level:
logger.log(log_level, 'Switch %s not found', self.name)
if get_setting('CREATE_MISSING_SWITCHES'):
switch, _created = Switch.objects.get_or_create(
name=self.name,
defaults={'active': get_setting('SWITCH_DEFAULT')})
cache = get_cache()
cache.set(self._cache_key(self.name), switch)
return get_setting('SWITCH_DEFAULT')
return self.active
def is_active(self, request):
if not self.pk:
if get_setting('LOG_MISSING_FLAGS'):
logger.log(level=get_setting('LOG_MISSING_FLAGS'),
msg=("Flag %s not found", self.name))
if get_setting('CREATE_MISSING_FLAGS'):
get_waffle_flag_model().objects.get_or_create(
name=self.name,
defaults={'everyone': get_setting('FLAG_DEFAULT')})
return get_setting('FLAG_DEFAULT')
if get_setting('OVERRIDE'):
if self.name in request.GET:
return request.GET[self.name] == '1'
if self.everyone:
return True
elif self.everyone is False:
return False
if self.testing: # Testing mode is on.
tc = get_setting('TEST_COOKIE') % self.name
if tc in request.GET:
on = request.GET[tc] == '1'
if not hasattr(request, 'waffle_tests'):
request.waffle_tests = {}
request.waffle_tests[self.name] = on
return on
if tc in request.COOKIES:
return request.COOKIES[tc] == 'True'
active_for_language = self._is_active_for_language(request)
if active_for_language is not None:
return active_for_language
active_for_user = self._is_active_for_user(request)
if active_for_user is not None:
return active_for_user
if self.percent and self.percent > 0:
if not hasattr(request, 'waffles'):
request.waffles = {}
elif self.name in request.waffles:
return request.waffles[self.name][0]
cookie = get_setting('COOKIE') % self.name
if cookie in request.COOKIES:
flag_active = (request.COOKIES[cookie] == 'True')
set_flag(request, self.name, flag_active, self.rollout)
return flag_active
if Decimal(str(random.uniform(0, 100))) <= self.percent:
set_flag(request, self.name, True, self.rollout)
return True
set_flag(request, self.name, False, self.rollout)
return False
def get_flush_keys(self, flush_keys=None):
flush_keys = flush_keys or []
flush_keys.extend([
self._cache_key(self.name),
get_setting('ALL_FLAGS_CACHE_KEY'),
])
return flush_keys
def get_waffle_model(setting_name):
"""
Returns the waffle Flag model that is active in this project.
"""
default_model = {
'FLAG_MODEL': 'waffle.Flag',
'SWITCH_MODEL': 'waffle.Switch',
'SAMPLE_MODEL': 'waffle.Sample',
}
# Add backwards compatibility by not requiring adding of model setting
# for everyone who upgrades. At some point it would be helpful to
# require this to be defined explicitly, but no for now, to remove
# pain from upgrading.
default = default_model[setting_name]
flag_model_name = get_setting(setting_name, default)
try:
return django_apps.get_model(flag_model_name)
except ValueError:
raise ImproperlyConfigured(
"WAFFLE_{} must be of the form 'app_label.model_name'".format(
setting_name))
except LookupError:
raise ImproperlyConfigured(
"WAFFLE_{} refers to model '{}' that has not been installed".
format(setting_name, flag_model_name))
def get_flush_keys(self, flush_keys=None):
flush_keys = super(CompanyAwareFlag, self).get_flush_keys(flush_keys)
companies_cache_key = get_setting(
CompanyAwareFlag.FLAG_COMPANIES_CACHE_KEY,
CompanyAwareFlag.FLAG_COMPANIES_CACHE_KEY_DEFAULT)
flush_keys.append(keyfmt(companies_cache_key, self.name))
return flush_keys
def get_flush_keys(self, flush_keys=None):
flush_keys = flush_keys or []
flush_keys.extend([
self._cache_key(self.name),
get_setting('ALL_FLAGS_CACHE_KEY'),
])
return flush_keys
def flush(self):
cache = get_cache()
keys = [
self._cache_key(self.name),
get_setting(self.ALL_CACHE_KEY),
]
cache.delete_many(keys)
def flush(self):
cache = get_cache()
keys = [
self._cache_key(self.name),
get_setting(self.ALL_CACHE_KEY),
]
cache.delete_many(keys)
def switch_is_active(switch_name):
from .models import Switch
try:
return Switch.objects.get(name=switch_name).active
except Switch.DoesNotExist:
return get_setting('SWITCH_DEFAULT')
def switch_is_active(request, switch_name):
from .models import cache_switch, Switch
from .compat import cache
current_site = Site.objects.get_current(request)
switch = cache.get(keyfmt(get_setting('SWITCH_CACHE_KEY'), switch_name, current_site))
if switch is None:
try:
switch = Switch.objects.get(name=switch_name, site=current_site)
cache_switch(instance=switch)
except Switch.DoesNotExist:
try:
switch = Switch.objects.get(name=switch_name, site__isnull=True)
cache_switch(instance=switch)
except Switch.DoesNotExist:
return get_setting('SWITCH_DEFAULT')
return switch.active
def is_active(self):
if not self.pk:
if get_setting('LOG_MISSING_SAMPLES'):
logger.log(level=get_setting('LOG_MISSING_SAMPLES'), msg=("Sample %s not found", self.name))
if get_setting('CREATE_MISSING_SAMPLES'):
default_percent = 100 if get_setting('SAMPLE_DEFAULT') else 0
Sample.objects.get_or_create(
name=self.name,
defaults={
'percent': default_percent
}
)
return get_setting('SAMPLE_DEFAULT')
return Decimal(str(random.uniform(0, 100))) <= self.percent
def sample_is_active(sample_name):
from .models import Sample
try:
sample = Sample.objects.get(name=sample_name)
except Sample.DoesNotExist:
return get_setting('SAMPLE_DEFAULT')
return Decimal(str(random.uniform(0, 100))) <= sample.percent
def flag_is_active_for_user(user, flag_name):
"""
Returns True if the given flag_name is active for the given user, False otherwise
"""
from .models import cache_flag, Flag
from .compat import cache
flag = cache.get(keyfmt(get_setting('FLAG_CACHE_KEY'), flag_name))
if flag is None:
try:
flag = Flag.objects.get(name=flag_name)
cache_flag(instance=flag)
except Flag.DoesNotExist:
return get_setting('FLAG_DEFAULT')
if flag.authenticated and user.is_authenticated():
return True
if flag.staff and user.is_staff:
return True
if flag.superusers and user.is_superuser:
return True
flag_users = cache.get(keyfmt(get_setting('FLAG_USERS_CACHE_KEY'),
flag.name))
if flag_users is None:
flag_users = flag.users.all()
cache_flag(instance=flag)
if user in flag_users:
return True
flag_groups = cache.get(keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'),
flag.name))
if flag_groups is None:
flag_groups = flag.groups.all()
cache_flag(instance=flag)
user_groups = user.groups.all()
for group in flag_groups:
if group in user_groups:
return True
return False
def sample_is_active(sample_name):
from .models import cache_sample, Sample
from .compat import cache
sample = cache.get(keyfmt(get_setting('SAMPLE_CACHE_KEY'), sample_name))
if sample is None:
if get_setting('SAMPLE_AUTOCREATE', False):
defaults = get_setting('SAMPLE_DEFAULTS', {})
sample, created = Sample.objects.get_or_create(
name=sample_name, defaults=defaults.get(sample_name, {}))
else:
try:
sample = Sample.objects.get(name=sample_name)
except Sample.DoesNotExist:
return get_setting('SAMPLE_DEFAULT', False)
cache_sample(instance=sample)
return Decimal(str(random.uniform(0, 100))) <= sample.percent
def sample_is_active(sample_name):
from .models import cache_sample, Sample
from .compat import cache
sample = cache.get(keyfmt(get_setting('SAMPLE_CACHE_KEY'), sample_name))
if sample is None:
if get_setting('SAMPLE_AUTOCREATE', False):
defaults = get_setting('SAMPLE_DEFAULTS', {})
sample, created = Sample.objects.get_or_create(name=sample_name,
defaults=defaults.get(sample_name, {}))
else:
try:
sample = Sample.objects.get(name=sample_name)
except Sample.DoesNotExist:
return get_setting('SAMPLE_DEFAULT', False)
cache_sample(instance=sample)
return Decimal(str(random.uniform(0, 100))) <= sample.percent
def _get_flag(flag_name):
flag = cache.get(keyfmt(get_setting('FLAG_CACHE_KEY'), flag_name))
if flag is None:
try:
flag = Flag.objects.get(name=flag_name)
cache_flag(instance=flag)
except Flag.DoesNotExist:
flag = None
return flag
def switch_is_active(switch_name):
from .models import cache_switch, Switch
from .compat import cache
switch = cache.get(keyfmt(get_setting('SWITCH_CACHE_KEY'), switch_name))
if switch is None:
if get_setting('SWITCH_AUTOCREATE', False):
defaults = get_setting('SWITCH_DEFAULTS', {})
switch, created = Switch.objects.get_or_create(
name=switch_name, defaults=defaults.get(switch_name, {}))
else:
try:
switch = Switch.objects.get(name=switch_name)
except Switch.DoesNotExist:
switch = DoesNotExist()
switch.name = switch_name
cache_switch(instance=switch)
return switch.active
def _generate_waffle_js(request):
flags = get_waffle_flag_model().get_all()
flag_values = [(f.name, f.is_active(request)) for f in flags]
switches = Switch.get_all()
switch_values = [(s.name, s.is_active()) for s in switches]
samples = Sample.get_all()
sample_values = [(s.name, s.is_active()) for s in samples]
return loader.render_to_string('waffle/waffle.js', {
'flags': flag_values,
'switches': switch_values,
'samples': sample_values,
'flag_default': get_setting('FLAG_DEFAULT'),
'switch_default': get_setting('SWITCH_DEFAULT'),
'sample_default': get_setting('SAMPLE_DEFAULT'),
})
def switch_is_active(switch_name):
from .models import cache_switch, Switch
from .compat import cache
switch = cache.get(keyfmt(get_setting('SWITCH_CACHE_KEY'), switch_name))
if switch is None:
if get_setting('SWITCH_AUTOCREATE', False):
defaults = get_setting('SWITCH_DEFAULTS', {})
switch, created = Switch.objects.get_or_create(name=switch_name,
defaults=defaults.get(switch_name, {}))
else:
try:
switch = Switch.objects.get(name=switch_name)
except Switch.DoesNotExist:
switch = DoesNotExist()
switch.name = switch_name
cache_switch(instance=switch)
return switch.active
def switch_is_active(switch_name):
from .models import cache_switch, Switch
from .compat import cache
switch = cache.get(keyfmt(get_setting('SWITCH_CACHE_KEY'), switch_name))
if switch is None:
try:
switch = Switch.objects.get(name=switch_name)
cache_switch(instance=switch)
except Switch.DoesNotExist:
switch = DoesNotExist()
switch.name = switch_name
cache_switch(instance=switch)
return switch.active
def get_all(cls):
cache_key = get_setting(cls.ALL_CACHE_KEY)
cached = cache.get(cache_key)
if cached == CACHE_EMPTY:
return []
if cached:
return cached
objs = cls.get_all_from_db()
if not objs:
cache.add(cache_key, CACHE_EMPTY)
return []
cache.add(cache_key, objs)
return objs
def get_all(cls):
cache_key = get_setting(cls.ALL_CACHE_KEY)
cached = cache.get(cache_key)
if cached == CACHE_EMPTY:
return []
if cached:
return cached
objs = list(cls.objects.all())
if not objs:
cache.add(cache_key, CACHE_EMPTY)
return []
cache.add(cache_key, objs)
return objs
def _get_group_ids(self):
cache_key = keyfmt(get_setting('FLAG_GROUPS_CACHE_KEY'), self.name)
cached = cache.get(cache_key)
if cached == CACHE_EMPTY:
return set()
if cached:
return cached
group_ids = set(self.groups.all().values_list('pk', flat=True))
if not group_ids:
cache.add(cache_key, CACHE_EMPTY)
return set()
cache.add(cache_key, group_ids)
return group_ids
def process_response(self, request, response):
secure = get_setting('SECURE')
max_age = get_setting('MAX_AGE')
if hasattr(request, 'waffles'):
for k in request.waffles:
name = smart_str(get_setting('COOKIE') % k)
active, rollout = request.waffles[k]
if rollout and not active:
# "Inactive" is a session cookie during rollout mode.
age = None
else:
age = max_age
response.set_cookie(name,
value=active,
max_age=age,
secure=secure)
if hasattr(request, 'waffle_tests'):
for k in request.waffle_tests:
name = smart_str(get_setting('TEST_COOKIE') % k)
value = request.waffle_tests[k]
response.set_cookie(name, value=value)
return response
def _get_user_ids(self):
cache_key = keyfmt(get_setting('FLAG_USERS_CACHE_KEY'), self.name)
cached = cache.get(cache_key)
if cached == CACHE_EMPTY:
return set()
if cached:
return cached
user_ids = set(self.users.all().values_list('pk', flat=True))
if not user_ids:
cache.add(cache_key, CACHE_EMPTY)
return set()
cache.add(cache_key, user_ids)
return user_ids
def _get_company_ids(self):
cache_key = keyfmt(
get_setting(CompanyAwareFlag.FLAG_COMPANIES_CACHE_KEY,
CompanyAwareFlag.FLAG_COMPANIES_CACHE_KEY_DEFAULT),
self.name)
cached = cache.get(cache_key)
if cached == CACHE_EMPTY:
return set()
if cached:
return cached
company_ids = set(self.companies.all().values_list('pk', flat=True))
if not company_ids:
cache.add(cache_key, CACHE_EMPTY)
return set()
cache.add(cache_key, company_ids)
return company_ids
def _get_pricing_ids(self):
cache_key = keyfmt(
get_setting(Flag.FLAG_PRICINGS_CACHE_KEY,
Flag.FLAG_PRICINGS_CACHE_KEY_DEFAULT), self.name)
cached = cache.get(cache_key)
if cached == CACHE_EMPTY:
return set()
if cached:
return cached
pricing_ids = set(self.pricings.all().values_list('pk', flat=True))
if not pricing_ids:
cache.add(cache_key, CACHE_EMPTY)
logger.warning('Feature flag does not have assigned subscriptions')
return set()
cache.add(cache_key, pricing_ids)
return pricing_ids
def get_waffle_flag_model():
"""
Returns the waffle Flag model that is active in this project.
"""
# Add backwards compatibility by not requiring adding of WAFFLE_FLAG_MODEL
# for everyone who upgrades.
# At some point it would be helpful to require this to be defined explicitly,
# but no for now, to remove pain form upgrading.
flag_model_name = get_setting('FLAG_MODEL', 'waffle.Flag')
try:
return django_apps.get_model(flag_model_name)
except ValueError:
raise ImproperlyConfigured(
"WAFFLE_FLAG_MODEL must be of the form 'app_label.model_name'")
except LookupError:
raise ImproperlyConfigured(
"WAFFLE_FLAG_MODEL refers to model '{}' that has not been installed"
.format(flag_model_name))
def is_active(self):
if not self.pk:
return get_setting('SAMPLE_DEFAULT')
return Decimal(str(random.uniform(0, 100))) <= self.percent
