Series: Axios Lesson 81

Concurrent Refresh Requests — Bir nechta 401 kelganda yagona refresh request boshqaruvi

Parallel so'rovlar bir vaqtda 401 qaytarganda yagona refresh request yuborish mexanizmi: Mutex lock (isRefreshing), failedQueue va Refresh Token Rotation (RTR) ziddiyatlarini bartaraf etish.

81-dars

Concurrent Refresh Requests — Bir nechta 401 kelganda yagona refresh request boshqaruvi

Oldingi darslarda biz 401 Unauthorized xatosi kelganda tokenni avtomatik yangilash mexanizmini ko'rib chiqdik. Biroq real hayotda foydalanuvchi interfeyslari deyarli hech qachon bittalab so'rov yubormaydi.

Tasavvur qiling:

  1. Foydalanuvchi sahifani yangiladi (F5). Sahifa yuklanayotganda bir vaqtning o'zida dashboard ma'lumotlari, foydalanuvchi profili va bildirishnomalarni olish uchun 3 ta parallel so'rov ketdi.
  2. Bu paytda Access Tokenning muddati tugagan edi. Natijada bu 3 ta so'rovning barchasi bir vaqtning o'zida serverdan 401 Unauthorized xatosi bilan qaytdi.
  3. Agar sizda parallel so'rovlarni nazorat qiluvchi maxsus arxitektura bo'lmasa, har bir interceptor o'zicha mustaqil harakat qilib, serverga deyarli bir xil millisekundda 3 ta alohida /auth/refresh so'rovini yuboradi.

1. Muammoning tub mohiyati: Token Revocation Conflict

Nega bir vaqtning o'zida bir nechta refresh so'rov yuborish halokatli oqibatlarga olib keladi?

Zamonaviy xavfsizlik standartlariga ko'ra, backend serverlarda Refresh Token Rotation (RTR) mexanizmi yoqilgan bo'ladi. Uning qoidasi oddiy: har bir Refresh Token faqat bir marta ishlatilishi mumkin.

sequenceDiagram
    autonumber
    actor Client as Frontend (3 ta parallel 401)
    participant Server as Backend Server (RTR yoqilgan)

    Client->>Server: Refresh so'rov 1 (Token A bilan)
    Server-->>Client: 200 OK (Yangi Token B berildi, Token A o'chirildi!)
    
    Client->>Server: Refresh so'rov 2 (Eski Token A bilan)
    Note over Server: XAVF! Token A allaqachon ishlatilgan!
    Server-->>Client: 403 Forbidden (Token o'g'irlangan deb gumon qilindi!)
    Note over Client: Barcha sessiyalar bekor qilinadi, foydalanuvchi tizimdan haydaladi!

[!CAUTION] Token Reuse Detection: Agar server bir xil Refresh Token bilan takroriy so'rov kelsa, uni "xaker tokenni o'g'irlab ishlatmoqda" deb baholaydi va xavfsizlik chorasi sifatida foydalanuvchining barcha faol sessiyalarini darhol bekor qiladi (force logout).


2. Yechim: Mutex Lock (isRefreshing) va Navbat (failedQueue)

Ushbu poyga holatini (Race Condition) bartaraf etish uchun ikkita asosiy arxitekturaviy mexanizm qo'llaniladi:

  1. isRefreshing bayrog'i (Mutex Lock): Birinchi kelgan 401 xatosi darhol bu bayroqni true qilib qulflaydi va yakka o'zi serverga yagona /auth/refresh so'rovini yuboradi.
  2. failedQueue (Request Queue / Navbat): Birinchi so'rov tokenni yangilaguncha kelgan boshqa barcha parallel 401 so'rovlari ushbu navbatga vaqtinchalik Promise sifatida yig'iladi.
  3. Yangi token olinishi bilan navbatdagi barcha so'rovlarga yangi token tarqatiladi va ular bir vaqtda muvaffaqiyatli qayta yuboriladi.
flowchart TD
    A["Parallel So'rovlar (401 xatosi)"] --> B{"isRefreshing === true?"}
    B -->|Ha (Jarayon band)| C["failedQueue ga qo'shish\n(Promise ichida kutib turish)"]
    B -->|Yo'q (Birinchi so'rov)| D["isRefreshing = true\n(Jarayonni qulflash)"]
    D --> E["Yagona POST /auth/refresh so'rovi"]
    E -->|Muvaffaqiyatli| F["Yangi Access Token olindi"]
    F --> G["processQueue(null, newAccessToken)\n(Navbatdagi barcha so'rovlarni bo'shatish)"]
    G --> H["Barcha so'rovlarni yangi token bilan qayta yuborish"]
    E -->|Xatolik| I["processQueue(error, null)\n(Navbatdagilarni rad etish)"]
    I --> J["TokenManager.clearToken() & /login ga yo'naltirish"]

3. Amaliyot: Mukammal TypeScript Arxitekturasi

Keling, ushbu murakkab navbat va qulflash mexanizmini to'liq o'z ichiga olgan, xavfsiz va toza kodni yozamiz:

// src/api/client.ts
import axios, { AxiosError, InternalAxiosRequestConfig } from 'axios';
import { TokenManager } from './tokenManager';

export const apiClient = axios.create({
  baseURL: 'https://api.mysite.com/v1',
  timeout: 10000,
  withCredentials: true, // HttpOnly Cookie yuborilishi shart
});

// --- CONCURRENCY BOSHQARUVI UCHUN TIP VA O'ZGARUVCHILAR ---
interface QueueItem {
  resolve: (token: string) => void;
  reject: (error: unknown) => void;
}

// Qulflash bayrog'i
let isRefreshing = false;

// 401 olib, yangi tokenni kutib turgan so'rovlar navbati
let failedQueue: QueueItem[] = [];

/**
 * Navbatdagi barcha so'rovlarga natijani tarqatish yoki barchasini rad etish funksiyasi
 */
const processQueue = (error: unknown, token: string | null = null): void => {
  failedQueue.forEach((promise) => {
    if (error) {
      promise.reject(error);
    } else if (token) {
      promise.resolve(token);
    }
  });

  // Navbatni bo'shatamiz
  failedQueue = [];
};

// --- RESPONSE INTERCEPTOR ---
apiClient.interceptors.response.use(
  (response) => response,
  async (error: AxiosError) => {
    const originalRequest = error.config as (InternalAxiosRequestConfig & { _retry?: boolean }) | undefined;

    // Agar so'rov konfiguratsiyasi mavjud bo'lmasa, rad etamiz
    if (!originalRequest) {
      return Promise.reject(error);
    }

    // Faqat 401 xatosi va hali qayta urinilmagan so'rovlar uchun
    if (error.response?.status === 401 && !originalRequest._retry) {
      
      // Cheksiz siklning oldini olamiz (Refresh so'rovining o'zi 401 bersa)
      if (originalRequest.url?.includes('/auth/refresh')) {
        TokenManager.clearToken();
        window.location.href = '/login';
        return Promise.reject(error);
      }

      // 1. Agar hozirda boshqa so'rov tokenni yangilayotgan bo'lsa (Mutex qulflangan)
      if (isRefreshing) {
        return new Promise<string>((resolve, reject) => {
          // Bu so'rovni navbatga (queue) joylaymiz va yangi token kelishini kutamiz
          failedQueue.push({ resolve, reject });
        })
          .then((token) => {
            // Yangi token kelgach, sarlavhani yangilab, so'rovni qayta yuboramiz
            originalRequest.headers.Authorization = `Bearer ${token}`;
            return apiClient(originalRequest);
          })
          .catch((err) => Promise.reject(err));
      }

      // 2. Navbatdagi birinchi so'rov bo'lsak, jarayonni o'zimiz qulflaymiz
      originalRequest._retry = true;
      isRefreshing = true;

      try {
        // Yashirin refresh so'rovini yuboramiz (barcha parallel so'rovlar uchun FAQAT 1 TA so'rov!)
        const response = await axios.post<{ accessToken: string }>(
          'https://api.mysite.com/v1/auth/refresh',
          {},
          { withCredentials: true }
        );

        const newAccessToken = response.data.accessToken;

        // Xotiradagi tokenni yangilaymiz
        TokenManager.setToken(newAccessToken);

        // Qulflangan holatni bo'shatamiz
        isRefreshing = false;

        // Navbatda kutib turgan barcha parallel so'rovlarga yangi tokenni tarqatamiz
        processQueue(null, newAccessToken);

        // Birinchi so'rovning o'zini ham yangi token bilan takrorlaymiz
        originalRequest.headers.Authorization = `Bearer ${newAccessToken}`;
        return apiClient(originalRequest);

      } catch (refreshError) {
        // Agar refresh muvaffaqiyatsiz bo'lsa, navbatdagi barcha so'rovlarni rad etamiz
        isRefreshing = false;
        processQueue(refreshError, null);

        TokenManager.clearToken();
        window.location.href = '/login';

        return Promise.reject(refreshError);
      }
    }

    return Promise.reject(error);
  }
);

4. Ushbu yondashuvning 3 ta ustun afzalligi

  1. Serverni himoya qilish va Thundering Herd muammosini yo'qotish: Sahifada 10 ta parallel komponent bo'lsa ham, backendga baribir faqat va faqat bitta /auth/refresh so'rovi boradi. Bu serverga bo'lgan bosimni va tarmoq trafigini keskin kamaytiradi.

  2. Adolatli va xavfsiz navbat (Queue Management): Qolgan 9 ta so'rov rad etilmaydi yoki yo'qolib ketmaydi. Ular Promise orqali to'xtatilib turiladi va yangi token olinishi bilan birin-ketin emas, balki bir paytda muvaffaqiyatli yakunlanadi.

  3. Refresh Token Rotation (RTR) ziddiyatlarini bartaraf etish: Tokenning bir vaqtning o'zida qayta-qayta yangilanishiga yo'l qo'yilmaydi. Natijada serverdagi xavfsizlik filtrlari hech qachon qonuniy foydalanuvchini bot yoki o'g'ri deb adashmaydi.


5. Oddiy Refresh vs Concurrency Queue Taqqoslovi

Mezon Oddiy Refresh (Qulflarsiz) Concurrency Queue bilan (Mutex)
3 ta parallel 401 kelsa 3 ta refresh so'rovi ketadi Faqat 1 ta yagona refresh so'rovi ketadi
RTR mosligi ❌ Ziddiyat yuz beradi (403 xatosi) ✅ 100% mos va xavfsiz
Tarmoq yuklamasi Yuqori (takroriy so'rovlar) Minimal (yagona so'rov)
Foydalanuvchi seansi Kutilmaganda bekor bo'lish xavfi yuqori Foydalanuvchiga hech qanday uzilishsiz davom etadi

Xulosa

Yirik, real ishlab chiqarish darajasidagi frontend loyihalarida bir vaqtning o'zida bir nechta so'rov 401 Unauthorized olishi juda tabiiy holatdir. Mutex Lock (isRefreshing) va Promise Queue (failedQueue) mexanizmi nafaqat tarmoq samaradorligini ta'minlaydi, balki autentifikatsiya tizimini kutilmagan poyga holatlaridan (race conditions) to'liq himoya qiladi.