fix(timezone): enhance timezone offset handling during DST transitions with improved caching mechanism

Author: Tony2h

source/common/src/ttime.c

@@ -881,8 +881,9 @@ int64_t taosTimeGetIntervalEnd(int64_t intervalStart, const SInterval* pInterval
   in effect at the given timestamp.
  
   Unlike taosGetTZOffsetSeconds() which queries the offset for "now", this
-  function converts `ticks` to local time via taosLocalTime() and reads
-  tm_gmtoff, so it correctly resolves DST for the *target* instant.
+  function converts `ticks` to local time via taosLocalTime() and then
+  derives the offset as (taosTimeGm(local) - t_sec), so it correctly
+  resolves DST for the *target* instant.
  
   On conversion failure 0 is returned (UTC fallback).
  */

source/dnode/mnode/impl/src/mndDnode.c

@@ -477,43 +477,122 @@ int32_t mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) {
  * Keep both the previous and current cached offsets so
  * that during a DST transition window dnodes reporting
  * either the old or the new offset are both accepted.
- * Refresh at most once per 60 s.
+ * Refresh at most once per 60 s; the previous offset
+ * is only accepted for a short grace period (3 min)
+ * to avoid permanently weakening the check.
  */
-static int64_t tsCachedTzOffset    = 0;
+static int64_t tsCachedTzOffset     = 0;
 static int64_t tsCachedTzOffsetPrev = 0;
-static int64_t tsCachedTzOffsetMs  = 0;
-static bool    tsCachedHasPrev     = false;
-#define TZ_CACHE_REFRESH_MS 60000
+static int64_t tsCachedTzOffsetMs   = 0;
+static int64_t tsCachedPrevSetMs    = 0;
+static int8_t  tsCachedHasPrev      = 0;
+/*
+ * Seqlock sequence: even = stable, odd = write in
+ * progress.  CAS from even→odd grants single-writer
+ * access; store even+2 publishes the new snapshot.
+ */
+static int64_t tsTzSeq              = 0;
+#define TZ_CACHE_REFRESH_MS  60000
+#define TZ_PREV_GRACE_MS    180000
+
+typedef struct {
+  int64_t offset;
+  int64_t offsetPrev;
+  int64_t refreshMs;
+  int64_t prevSetMs;
+  int8_t  hasPrev;
+} STzSnapshot;
 
-static bool mndCheckTimezoneOffset(int64_t dnodeOffset) {
-  int64_t nowMs = taosGetTimestampMs();
-
-  if (tsCachedTzOffsetMs == 0 ||
-      nowMs - tsCachedTzOffsetMs >= TZ_CACHE_REFRESH_MS) {
-    int32_t ret = taosGetLocalTimezoneOffset();
-    if (ret == TSDB_CODE_TIME_ERROR) {
-      mError("failed to get local timezone offset since %s",
-             tstrerror(ret));
-      terrno = ret;
-      return false;
-    }
-    int64_t offset = (int64_t)ret;
+/*
+ * Read a consistent snapshot of the tz cache.
+ * Spins while a writer is active (odd seq) or
+ * if the snapshot was torn (seq changed).
+ */
+static void mndReadTzSnapshot(STzSnapshot *s) {
+  int64_t seq;
+  do {
+    seq = atomic_load_64(&tsTzSeq);
+    if (seq & 1) continue;
+    s->offset     = atomic_load_64(&tsCachedTzOffset);
+    s->offsetPrev = atomic_load_64(&tsCachedTzOffsetPrev);
+    s->refreshMs  = atomic_load_64(&tsCachedTzOffsetMs);
+    s->prevSetMs  = atomic_load_64(&tsCachedPrevSetMs);
+    s->hasPrev    = atomic_load_8(&tsCachedHasPrev);
+  } while (atomic_load_64(&tsTzSeq) != seq);
+}
 
-    if (tsCachedTzOffsetMs != 0 && offset != tsCachedTzOffset) {
-      /* offset changed (DST edge) — keep the old one */
-      tsCachedTzOffsetPrev = tsCachedTzOffset;
-      tsCachedHasPrev      = true;
-    }
-    tsCachedTzOffset   = offset;
-    tsCachedTzOffsetMs = nowMs;
+/*
+ * Try to refresh the tz cache.  Uses CAS on tsTzSeq
+ * to ensure single-writer; if another thread is
+ * already refreshing, this is a harmless no-op.
+ */
+static void mndRefreshTzCache(int64_t nowMs) {
+  int64_t seq = atomic_load_64(&tsTzSeq);
+  if (seq & 1) return;
+  if (atomic_val_compare_exchange_64(&tsTzSeq, seq, seq + 1) != seq) {
+    return;
   }
 
-  if (dnodeOffset == tsCachedTzOffset) return true;
-  if (tsCachedHasPrev && dnodeOffset == tsCachedTzOffsetPrev) return true;
+  /* seq is now odd — we are the sole writer */
+  int32_t code = TSDB_CODE_SUCCESS;
+  int64_t offset = (int64_t)taosGetLocalTimezoneOffset(&code);
+  if (code != TSDB_CODE_SUCCESS) {
+    mError("failed to get local timezone offset since %s", tstrerror(code));
+    /* rollback: restore even seq */
+    atomic_store_64(&tsTzSeq, seq);
+    return;
+  }
 
+  int64_t oldMs = atomic_load_64(&tsCachedTzOffsetMs);
+  int64_t oldOff = atomic_load_64(&tsCachedTzOffset);
+  if (oldMs != 0 && offset != oldOff) {
+    /* offset changed (DST edge) — keep old one */
+    atomic_store_64(&tsCachedTzOffsetPrev, oldOff);
+    atomic_store_64(&tsCachedPrevSetMs, nowMs);
+    atomic_store_8(&tsCachedHasPrev, 1);
+  }
+  atomic_store_64(&tsCachedTzOffset, offset);
+  atomic_store_64(&tsCachedTzOffsetMs, nowMs);
+
+  /* publish: even seq+2 => readers see new state */
+  atomic_store_64(&tsTzSeq, seq + 2);
+}
+
+static bool mndMatchTzSnapshot(const STzSnapshot *s, int64_t dnodeOff,
+                               int64_t nowMs) {
+  if (dnodeOff == s->offset) return true;
+  if (s->hasPrev && nowMs - s->prevSetMs < TZ_PREV_GRACE_MS &&
+      dnodeOff == s->offsetPrev) {
+    return true;
+  }
   return false;
 }
 
+static bool mndCheckTimezoneOffset(int64_t dnodeOffset) {
+  STzSnapshot snap;
+  int64_t     nowMs = taosGetTimestampMs();
+
+  mndReadTzSnapshot(&snap);
+
+  if (snap.refreshMs == 0 || nowMs - snap.refreshMs >= TZ_CACHE_REFRESH_MS) {
+    mndRefreshTzCache(nowMs);
+    mndReadTzSnapshot(&snap);
+  }
+
+  if (mndMatchTzSnapshot(&snap, dnodeOffset, nowMs))
+    return true;
+
+  /*
+   * dnodeOffset doesn't match — force an immediate
+   * refresh in case we are stale after a DST switch,
+   * then re-check.
+   */
+  mndRefreshTzCache(nowMs);
+  mndReadTzSnapshot(&snap);
+
+  return mndMatchTzSnapshot(&snap, dnodeOffset, nowMs);
+}
+
 static int32_t mndCheckClusterCfgPara(SMnode *pMnode, SDnodeObj *pDnode, const SClusterCfg *pCfg) {
   CHECK_MONITOR_PARA(tsEnableMonitor, DND_REASON_STATUS_MONITOR_SWITCH_NOT_MATCH);
   CHECK_MONITOR_PARA(tsMonitorInterval, DND_REASON_STATUS_MONITOR_INTERVAL_NOT_MATCH);