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 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 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 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(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: 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 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