Coverage for portality/bll/services/concurrency_prevention.py: 75%

44 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-20 13:43 +0000

1from portality.core import app 

2from portality.lib import dates 

3import redis 

4import json 

5import hashlib 

6 

7class ConcurrencyPreventionService: 

8 def __init__(self): 

9 self.rs = redis.Redis(host=app.config.get("REDIS_HOST"), port=app.config.get("REDIS_PORT")) 

10 

11 def check_concurrency(self, key, _id): 

12 """ 

13 Checks whether concurrent request has been submitted 

14 Returns true if clash is detected 

15 """ 

16 value = self.rs.get(key) 

17 return value is not None and value != _id 

18 

19 def store_concurrency(self, key, _id, timeout=None): 

20 if timeout is None: 

21 timeout = app.config.get("UR_CONCURRENCY_TIMEOUT", 10) 

22 if timeout > 0: 

23 self.rs.set(key, _id, ex=timeout) 

24 

25 # Passwordless login resend backoff tracking 

26 def record_pwless_resend(self, email: str, now: int | None = None): 

27 """ 

28 Check and record a passwordless login code resend for the given email with exponential backoff. 

29 

30 Returns a tuple: (allowed: bool, wait_remaining: int, current_interval: int) 

31 - allowed: whether a resend is permitted right now 

32 - wait_remaining: seconds to wait until next allowed resend (0 if allowed) 

33 - current_interval: the interval applied/returned for UI cooldown 

34 """ 

35 if not email: 

36 return False, 60, 60 

37 

38 email_key = hashlib.sha1(email.lower().encode("utf-8")).hexdigest() 

39 key = f"pwless_resend:{email_key}" 

40 now = now or dates.now_in_sec() 

41 

42 min_interval = int(app.config.get("PWLESS_RESEND_MIN_INTERVAL", 60)) 

43 max_interval = int(app.config.get("PWLESS_RESEND_MAX_INTERVAL", 86400)) # 24 hours 

44 factor = float(app.config.get("PWLESS_RESEND_BACKOFF_FACTOR", 2.0)) 

45 ttl = int(app.config.get("PWLESS_RESEND_RECORD_TTL", max_interval * 2)) 

46 

47 raw = self.rs.get(key) 

48 record = json.loads(raw.decode('utf-8')) if raw else None 

49 

50 if record: 

51 next_allowed_at = int(record.get("next_allowed_at", 0)) 

52 count = int(record.get("count", 0)) 

53 if count > 2: # allow resend code for 3 times 

54 current_interval = int(record.get("current_interval", min_interval)) 

55 if now < next_allowed_at: 

56 return False, next_allowed_at - now, current_interval 

57 # allowed: back off interval for next time 

58 new_interval = int(min(max_interval, max(min_interval, current_interval * factor))) 

59 else: 

60 # set a minimum interval for 3 times 

61 new_interval = min_interval 

62 

63 new_count = count + 1 

64 else: 

65 new_interval = min_interval 

66 new_count = 1 

67 

68 next_allowed_at = now + new_interval 

69 new_record = { 

70 "last_request": now, 

71 "count": new_count, 

72 "current_interval": new_interval, 

73 "next_allowed_at": next_allowed_at, 

74 } 

75 self.rs.set(key, json.dumps(new_record), ex=ttl) 

76 return True, 0, new_interval