সরাসরি পর্বে যান
পর্ব ৫৭ · ৮২-এর মধ্যে · মডিউল ৯

Compatibility আর reliability — browser, OS, recovery আর failover

Compatibility and Reliability Testing — Networks, Recovery, Failover, Backup and Upgrade

Taught in Bangla, this lesson separates compatibility (does it run in other environments and versions?) from reliability (does it last and recover?). A real Playwright run throttles the network through CDP to show when a checkout test fails for the wrong reason, and an offline case leaves a stale total. It computes MTBF, MTTR, availability and nines, kills the server mid-payment and checks recovery with an Idempotency-Key, and shows a live SQLite file copy losing orders while the backup API keeps them.

এই পর্বে যা শিখবেন

  • Compatibility-র ধরন চেনা: browser ও device থেকে API, data, database আর network পর্যন্ত, আর backward বনাম forward compatibility আলাদা করা
  • Playwright আর CDP দিয়ে ধীর ও বিচ্ছিন্ন network-এ একটি checkout test চালানো, আর ফল পড়ে app-এর দোষ আর test-এর দোষ আলাদা করা
  • MTBF, MTTR, availability আর nines হিসাব করা, আর ছোট test থেকে reliability প্রমাণের সীমা বোঝা
  • একটি recovery test নিজে চালানো: কাজের মাঝে process বন্ধ, আবার চালু, তারপর API আর database দিয়ে অবস্থা যাচাই
  • Graceful degradation, failover, backup-restore আর upgrade-এর test পরিকল্পনা করা, RPO আর RTO-সহ

১ · দুটি প্রশ্ন — “সবখানে চলে কি?” আর “ভাঙলে ফেরে কি?”

একটি মোবাইল রিচার্জের দোকানের কথা ভাবুন। দোকানদারের যন্ত্রটি সব অপারেটরের নম্বরে রিচার্জ করতে পারে কি না, পুরোনো বাটন ফোনের SMS-ও বোঝে কি না, এগুলো এক ধরনের প্রশ্ন। আরেক ধরনের প্রশ্ন হলো, load-shedding-এ যন্ত্র হঠাৎ বন্ধ হলে মাঝপথের রিচার্জের কী হয়: টাকা কাটা গেল কিন্তু রিচার্জ হলো না, নাকি দুবার হলো? প্রথম দলের প্রশ্নের নাম compatibility (সামঞ্জস্য), দ্বিতীয় দলের নাম reliability (নির্ভরযোগ্যতা)।

দুটিই non-functional গুণ, যার পরিচয় পর্ব ০৫-এ (Test-এর স্তর আর ধরন) পেয়েছেন। মানদণ্ড ISO/IEC 25010 compatibility-কে মূলত দুই ভাগে দেখে: একই পরিবেশে অন্য software-এর সাথে ঝামেলা ছাড়া থাকা (co-existence) আর তথ্য আদান-প্রদান করে কাজে লাগানো (interoperability). Reliability-র ভাগগুলো হলো চালু থাকা (availability), দোষ সয়ে চলা (fault tolerance), ফিরে আসা (recoverability), আর ব্যর্থতা কম হওয়া (২০১১-র সংস্করণে maturity, ২০২৩-এর সংস্করণে নাম বদলে faultlessness বলে জানা যায়)। মানদণ্ডটির পুরো ছবি সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ০৩-এ আছে; এখানে প্রশ্নটি tester-এর: প্রতিটি ভাগকে কোন test-এ বদলাবেন?

প্রশ্নবাজারঘরের উদাহরণTest
অন্য browser, OS, device-এ চলে?৩২০ px-এ cart পাশে সরেBrowser matrix, viewport (পর্ব ৪২)
পুরোনো client নতুন API-তে চলে?পুরোনো Android app নতুন server-এContract, response তুলনা
পুরোনো data নতুন version-এ টেকে?v1-এর order v2-এর schema-য়Upgrade test (§৮)
ধীর বা বিচ্ছিন্ন network-এ চলে?গ্রামের দুর্বল সংযোগে checkoutNetwork emulation (§৩)
ভাঙলে ঠিক অবস্থায় ফেরে?Payment-এর মাঝে server বন্ধRecovery test (§৬)
একটি অংশ পড়ে গেলে বাকিটা চলে?Wallet বন্ধ, ক্যাশ চলেDegradation, failover (§৭)
Data হারালে ফেরানো যায়?Database ফাইল নষ্টBackup-restore (§৮)

২ · Compatibility-র ধরন — browser থেকে API আর data

Browser, OS আর device: এর বিস্তারিত পর্ব ৪২-এ (Cross-browser আর responsive testing): browser matrix ঝুঁকি দেখে বাছাই, তিন engine-এ একই smoke test, বাংলা font, আর ৩২০ px-এ cart পাতার ৪৬ px পাশে সরে যাওয়ার সেই জানা defect. মনে রাখুন, প্রশ্নটি শুধু “দেখতে কেমন” নয়; কোনো নতুন JavaScript API (যেমন crypto.randomUUID) পুরোনো browser-এ না থাকলে কাজটাই বন্ধ হয়।

API-র compatibility: বাজারঘরের একটি Android app আছে ধরুন, যার পুরোনো version অনেকে আপডেট করেন না। Server-এ নতুন version গেলে সেই পুরোনো app কি চলবে? এটি backward compatibility: নতুন system পুরোনো client-কে সেবা দেয়। উল্টো দিকটি forward compatibility: পুরোনো কোড নতুন ধরনের data পেয়েও ভাঙে না, যেমন অচেনা নতুন field চুপচাপ উপেক্ষা করে। নিয়ম মোটামুটি এরকম:

  • সাধারণত নিরাপদ: response-এ নতুন ঐচ্ছিক field যোগ, নতুন endpoint যোগ, request-এ নতুন ঐচ্ছিক parameter.
  • ভাঙে: field-এর নাম বদল বা মোছা, ধরন বদল (সংখ্যা থেকে লেখা), আগে ঐচ্ছিক এমন কিছু বাধ্যতামূলক করা, error-এর আকার বদল, enum-এ নতুন মান যা পুরোনো client চেনে না।

Test-এর দিক থেকে এর সবচেয়ে কাজের হাতিয়ার consumer-driven contract, যা পর্ব ৩২-এ (Contract testing) Pact দিয়ে দেখেছেন: পুরোনো client যা যা ব্যবহার করে, তার একটি চুক্তি, আর নতুন server প্রতিবার সেই চুক্তির বিরুদ্ধে যাচাই হয়। সহজ বিকল্প: পুরোনো আর নতুন version-এর একই request-এর উত্তর পাশাপাশি তুলনা, যা §৮-এ করব। Schema evolution-এর তত্ত্ব (Avro, Protobuf-এর নিয়ম) আছে সিস্টেম ডিজাইন কোর্সের পর্ব ১২-এ।

Data আর database-এর compatibility: নতুন version-এর কোড পুরোনো data পড়তে পারে কি? আর উল্টোটা: নতুন schema-য় পুরোনো কোড চলে কি? দ্বিতীয় প্রশ্নটিই নির্ধারণ করে, release খারাপ হলে আগের version-এ ফেরা (rollback) যাবে কি না। Migration-এর up, down আর backfill-এর test পর্ব ৩৩-এ (Database testing) দেখেছেন; §৮-এ আমরা পুরো version বদলের দিক থেকে দেখব।

Network-এর compatibility: বাজারঘরের ক্রেতারা সবাই অফিসের fiber-এ নেই। কেউ গ্রামে দুর্বল সংকেতে, কেউ লিফটে ঢুকে সংযোগ হারান। ধীর আর হঠাৎ বিচ্ছিন্ন network-ও একটি “পরিবেশ”, তাই সেটিও compatibility-র প্রশ্ন।

৩ · ধীর আর বিচ্ছিন্ন network — সত্যিকারের run

এই পর্বের সব সত্যিকারের run একটি আলাদা scratch ফোল্ডারে: বাজারঘরের app (MIT) নিজের কপি থেকে 127.0.0.1:8836-এ, test mode-এ, নিজের database ফাইলে, Python 3.12.13 আর Uvicorn 0.54.0-এ; database SQLite 3.53.1. Browser automation-এ Playwright for Python 1.65.2 (Apache-2.0 লাইসেন্স) আর কম্পিউটারে আগে থেকে থাকা Microsoft Edge (headless); API-র কাজে httpx 0.28.1 (BSD-3-Clause). কোনো browser নামানো হয়নি, DO_NOT_TRACK=1 রাখা ছিল, আর সব অনুরোধ শুধু নিজের localhost-এ।

Network ধীর করা হয়েছে browser-এর ভেতর থেকে, CDP (Chrome DevTools Protocol) দিয়ে, যা Chromium-গোত্রের browser-এ (Chrome, Edge) চলে। Throttling-এর সাধারণ ধারণা আর Lighthouse-এর পদ্ধতি পর্ব ৫১-এ (Frontend performance) পেয়েছেন; সেখানে প্রশ্ন ছিল “কত দ্রুত দেখায়”, এখানে প্রশ্ন “ঠিকমতো কাজ করে কি না”। মূল অংশ (পুরো ফাইল আরও লম্বা):

SLOW = {"offline": False, "latency": 2000,           # ms, minimum per request
        "downloadThroughput": 50_000, "uploadThroughput": 50_000}  # bytes/s
expect.set_options(timeout=5_000)                     # Playwright's default

ctx = browser.new_context(base_url=BASE, viewport={"width": 360, "height": 740})
page = ctx.new_page()
cdp = ctx.new_cdp_session(page)
cdp.send("Network.enable")
cdp.send("Network.emulateNetworkConditions", SLOW)

page.goto("/products/3")
page.get_by_test_id("add-to-cart").click()
expect(page.get_by_test_id("cart-count")).to_have_text("1")   # auto-wait

একই checkout (login, cart-এ সয়াবিন তেল, checkout-এ district বদলে মোট টাকার হিসাব, ক্যাশে order) দুইবার চালানো হলো: একবার network স্বাভাবিক রেখে, একবার প্রতি request-এ কমপক্ষে ২০০০ ms দেরি আর প্রায় ৪০০ kbit/s গতিতে। এরপর দুটি আলাদা পরীক্ষা: offline অবস্থায় district বদলানো, আর ধীর network-এ “অর্ডার করুন” বোতামে অধৈর্য দুইবার চাপ। সত্যিকারের আউটপুট:

-- fast (no emulation), mitu
login          0.2 s  ok
  (badge wait 0.8 s of 5.0)
add-to-cart    0.9 s  ok
  (quote wait 0.8 s of 5.0)
quote          0.9 s  ok
place-order    0.1 s  ok
-- slow, joy
login          8.5 s  ok
  (badge wait 2.9 s of 5.0)
add-to-cart    5.1 s  ok
  (quote wait 2.9 s of 5.0)
quote          5.0 s  ok
place-order    4.2 s  ok
-- offline, sumi; quote-delivery before: 120
district now Dhaka, quote-delivery: 120 | toast: ''
-- double submit on slow net, rafi; page: /checkout | h1: চেকআউট
  cart-empty: কার্ট খালি, তাই অর্ডার করা যাবে না। পণ্য বেছে নিন
rafi's new orders: [10]

একই script শুধু দেরি বদলে আবার চালানো হলো। ৪০০০ ms-এ badge-এর অপেক্ষা হলো ৪.৯ সেকেন্ড, অল্পের জন্য পাস। ৫০০০ ms-এ:

-- slow, joy
login         20.5 s  ok
add-to-cart   10.2 s  FAIL Locator expected to have text '1'
quote         10.2 s  FAIL Locator expected to have text '120'
place-order   10.3 s  ok

ফলগুলো ধাপে ধাপে পড়ুন। প্রতিটি ধাপে প্রশ্নটি একই: এটি app-এর দোষ, নাকি test-এর?

  1. স্বাভাবিকbaselineতুলনার ভিত্তি
  2. ধীর2000 msCDP দিয়ে
  3. আরও ধীর5000 mstest লাল
  4. Offlineofflineবার্তা নেই
  5. দুইবার চাপdoubleএকটি order
স্বাভাবিক networkmitu
login 0.2 s · add 0.9 s · quote 0.9 s
badge-এর অপেক্ষা 0.8 s (সীমা 5.0)
# 0.8 s = 400 ms UI delay + polling
CDP-র শর্তbrowser-এর ভেতরে
latency 2000 ms (প্রতি request-এ ন্যূনতম)
download / upload 50,000 byte/s
# server জানেই না network ধীর
ধীর network-এর ফলjoy
login 8.5 s · add 5.1 s · place 4.2 s
badge-এর অপেক্ষা 2.9 s, সীমা 5.0
সব ok, কিন্তু হাতে মাত্র 2.1 s
5000 msলাল কে?
add-to-cart FAIL: expected text '1'
place-order ok → cart-এ তেল ছিলই
# app ঠিক, test-এর সীমা ছোট
Offline-এ district বদলsumi
আগে: Chattogram, delivery 120
পরে: Dhaka নির্বাচিত, delivery 120
toast: ''  # কোনো বার্তা নেই
দুইবার “অর্ডার করুন”rafi
নতুন order: [10]  # মাত্র একটি
পাতা: “কার্ট খালি, তাই অর্ডার করা যাবে না”
  1. ভিত্তি। স্বাভাবিক network-এ প্রতিটি ধাপ এক সেকেন্ডের কাছাকাছি। Badge-এর ০.৮ সেকেন্ডের বেশিরভাগই app-এর ইচ্ছাকৃত ৪০০ ms UI দেরি।
  2. শর্ত বসানো। CDP-র Network.emulateNetworkConditions browser-কে বলে প্রতিটি request-এ কমপক্ষে ২০০০ ms দেরি করতে আর গতি ৫০,০০০ byte/s-এ বাঁধতে। Server নিজে দ্রুতই থাকে; শুধু পথটি ধীর।
  3. ধীর network-এ পাস, কিন্তু সরু ব্যবধানে। সব ধাপ ok, তবে badge-এর অপেক্ষা ২.৯ সেকেন্ড, সীমা ৫.০. হাতে মাত্র ২.১ সেকেন্ড; এই সংখ্যাটিই সতর্কবার্তা।
  4. ৫০০০ ms-এ লাল, কিন্তু দোষ test-এর। Badge আর মোট টাকা ৫ সেকেন্ডের মধ্যে বদলায়নি, তাই দুটি FAIL. অথচ পরের ধাপে order হয়ে গেল, মানে তেল cart-এ ঠিকই ঢুকেছিল। App শেষ পর্যন্ত সঠিক; test-এর অপেক্ষার সীমা network-এর ধরনের সাথে মেলেনি। এমন test-ই পরে “flaky” হয় (পর্ব ৪০)।
  5. Offline-এ নীরব ভুল, দোষ app-এর। Sumi-র district Chattogram থেকে Dhaka করা হলো, কিন্তু delivery ১২০ রয়ে গেল, ঢাকার ৬০ নয়, আর কোনো বার্তা নেই। Quote-এর fetch ব্যর্থ হলে কোড শুধু ফিরে যায়। ক্রেতা ভুল মোট টাকা দেখছেন। এটি সত্যিকারের defect; cart-এ যোগের কোড offline-এ “সার্ভারে পৌঁছানো যায়নি” দেখায়, এই কোড দেখায় না।
  6. দুইবার চাপ: data ঠিক, অভিজ্ঞতা ভুল। Server-এ একটিই order (১০), কারণ প্রথম order-এর পরে cart খালি, তাই দ্বিতীয় অনুরোধ আটকে গেছে। কিন্তু browser দ্বিতীয় অনুরোধের উত্তর দেখাল: “কার্ট খালি, তাই অর্ডার করা যাবে না”। ক্রেতা ভাববেন অর্ডার হয়নি, আর আবার order দেবেন। Finding: বোতামটি প্রথম চাপেই নিষ্ক্রিয় হওয়া উচিত।

Emulation-এর সীমা: CDP দেরি আর গতি নকল করে, কিন্তু আসল মোবাইল network-এর packet হারানো বা ওঠানামা নয়, আর এটি শুধু Chromium-গোত্রের browser-এ চলে। বড় release-এর আগে আসল ফোনে দুর্বল সংযোগে অন্তত একবার হাতে চালান। অপেক্ষার সীমাও requirement থেকে নিন, অনুমান করে নয়।

Offline থাকলে অনুরোধ জমিয়ে রাখা — আর দুবার charge-এর ফাঁদ

অনেক app offline-first নকশা নেয়: সংযোগ না থাকলে অনুরোধ একটি সারিতে (queue) জমে, সংযোগ ফিরলে পাঠানো হয়। Tester-এর প্রশ্ন: উত্তরটা পথে হারালে আবার পাঠালে কী হয়? নিচের ব্লক আপনার browser-এ চলে। প্রথম লাইনটি আপনার browser-এর আসল navigator.onLine দেখায়; বাকিটা একটি নকল দোকান, যেখানে ক্রেতা সংকেত ছাড়া “পে” চাপলেন, সংকেত ফিরল, কিন্তু প্রথম উত্তরটি হারাল। একবার Idempotency-Key-সহ, একবার ছাড়া।

console.log("navigator.onLine in this browser:", navigator.onLine);

function makeShop(useKey) {
  const charges = [], seen = new Set(), queue = [];
  let online = false, loseNextAnswer = false, n = 0;
  function gateway(req) {                         // server side, fake
    if (!online) throw new Error("offline");
    if (!useKey || !seen.has(req.key)) { charges.push(req.order); seen.add(req.key); }
    if (loseNextAnswer) { loseNextAnswer = false; throw new Error("answer lost"); }
    return "paid";
  }
  return {
    charges, queue,
    pay(order) { queue.push({ order, key: useKey ? "k-" + ++n : null }); },
    goOnline() { online = true; },
    loseNext() { loseNextAnswer = true; },
    flush(label) {                                // send everything waiting
      for (const req of [...queue]) {
        try { gateway(req); queue.splice(queue.indexOf(req), 1); }
        catch (e) { console.log(`  ${label}: order ${req.order} -> ${e.message}, still queued`); }
      }
    },
  };
}

for (const useKey of [true, false]) {
  console.log(useKey ? "-- with Idempotency-Key" : "-- without a key");
  const shop = makeShop(useKey);
  shop.pay(11);                    // customer tapped "pay" with no signal
  shop.flush("try 1");
  shop.goOnline(); shop.loseNext(); // signal back, but the first answer is lost
  shop.flush("try 2");
  shop.flush("try 3");
  console.log(`  queued=${shop.queue.length}  charges for order 11: ${shop.charges.length}`);
}

আসল আউটপুট (ব্রাউজারের JavaScript; প্রথম লাইনটি আপনার browser-এর অবস্থা অনুযায়ী বদলাতে পারে):

navigator.onLine in this browser: true
-- with Idempotency-Key
  try 1: order 11 -> offline, still queued
  try 2: order 11 -> answer lost, still queued
  queued=0  charges for order 11: 1
-- without a key
  try 1: order 11 -> offline, still queued
  try 2: order 11 -> answer lost, still queued
  queued=0  charges for order 11: 2

ক্রেতার চোখে দুই গল্পই এক, কিন্তু key ছাড়া ledger-এ দুটি charge. দ্বিতীয় চেষ্টায় টাকা আসলে কাটা হয়েছিল, শুধু উত্তরটি হারিয়েছিল; key ছাড়া server তৃতীয় অনুরোধকে নতুন payment ভেবেছে। সারিতে প্রতিটি অনুরোধের key তৈরি হয় একবার, জমা রাখার মুহূর্তে, আর যতবার পাঠানো হোক একই key যায়। navigator.onLine-এর ওপর পুরো ভরসাও করবেন না: এটি শুধু বলে যন্ত্রটি কোনো network-এ যুক্ত কি না, server পর্যন্ত পৌঁছানো যায় কি না নয়। Key-র ধারণা পর্ব ২৯-এ (HTTP আর REST) আর virtual wallet-এ timeout পর্ব ৩৪-এ (Service virtualization) দেখেছেন।

৪ · Reliability-র মাপ — MTBF, MTTR, availability আর nines

Reliability মাপার তিনটি পরিচিত সংখ্যা। MTBF (Mean Time Between Failures): দুটি ব্যর্থতার মাঝে গড়ে কতক্ষণ ঠিকমতো চলে। MTTR (Mean Time To Repair বা Recover): ভাঙার পরে আবার চালু হতে গড়ে কতক্ষণ। MTTF (Mean Time To Failure) ব্যবহার হয় এমন জিনিসে, যা মেরামত হয় না, বদলানো হয়, যেমন একটি disk. এদের থেকে availability:

Availability = MTBF ÷ (MTBF + MTTR)
= চালু সময় ÷ মোট সময়

সূত্রটির ধারণা সিস্টেম ডিজাইন কোর্সের পর্ব ০৫-এ redundancy আর single point of failure-সহ বিস্তারে আছে। Tester-এর কাজ দুটি: নিজের log থেকে এই সংখ্যা ঠিকভাবে বের করা, আর লক্ষ্যের সাথে মেলানো। নিচে একটি কাল্পনিক মাসের বাজারঘর: ৩০ দিনে তিনবার checkout বন্ধ ছিল, ২৫, ১০ আর ৪৫ মিনিট।

1T    = 30 * 24 * 60      # min2down = [25, 10, 45]     # 3 outages3D  = sum(down); U = T - D4MTTR = D / 35MTBF = U / 36A = MTBF / (MTBF + MTTR)7budget(99.9%) = T * 0.001
মান
T
D
U
MTTR
MTBF
A
  1. মোট সময় আর ঘটনা। ৩০ দিন = ৪৩,২০০ মিনিট। Incident log-এ তিনটি বন্ধ থাকা: ২৫, ১০, ৪৫ মিনিট। আগে ঠিক করুন “বন্ধ” মানে কী: পুরো সাইট, নাকি শুধু checkout? এখানে checkout.
  2. মোট বন্ধ আর চালু সময়। D = ২৫ + ১০ + ৪৫ = ৮০ মিনিট, U = ৪৩,২০০ − ৮০ = ৪৩,১২০ মিনিট।
  3. MTTR = ৮০ ÷ ৩ ≈ ২৬.৭ মিনিট। গড়টি ১০ থেকে ৪৫-এর বিস্তার লুকায়; রিপোর্টে সবচেয়ে লম্বা ঘটনাটিও লিখুন।
  4. MTBF = ৪৩,১২০ ÷ ৩ ≈ ১৪,৩৭৩ মিনিট, প্রায় ২৩৯.৬ ঘণ্টা। মাত্র তিনটি ঘটনা থেকে এই সংখ্যা খুব অনিশ্চিত, যা §৫-এ দেখবেন।
  5. Availability = ১৪,৩৭৩ ÷ (১৪,৩৭৩ + ২৬.৭) ≈ ৯৯.৮১৫%, যা ৪৩,১২০ ÷ ৪৩,২০০-এর সমান। দুই পথে একই ফল আসা নিজের হিসাব যাচাইয়ের সহজ উপায়।
  6. লক্ষ্যের সাথে তুলনা। ৯৯.৯% লক্ষ্যে ৩০ দিনে বন্ধ থাকার সীমা ৪৩,২০০ × ০.০০১ = ৪৩.২ মিনিট; খরচ হয়েছে ৮০, লক্ষ্য ভাঙা। ৯৯.৫% লক্ষ্য হলে সীমা ২১৬ মিনিট, ঠিক আছে। একই মাস, লক্ষ্যভেদে ভিন্ন রায়।

এবার nines-এর পুরো ছক আর দুটি গুরুত্বপূর্ণ তুলনা নিজে চালিয়ে দেখুন। “চালান” চাপুন; প্রথমবার ব্রাউজারে Pyodide নামতে কয়েক সেকেন্ড লাগে।

HOURS_YEAR = 365 * 24

print("availability   down per year    per 30 days")
for a in (0.99, 0.999, 0.9995, 0.9999, 0.99999):
    year_h = (1 - a) * HOURS_YEAR
    month_min = (1 - a) * 30 * 24 * 60
    print(f"{a:>10.3%}   {year_h * 60:7.1f} min   {month_min:7.1f} min")


def avail(mtbf, mttr):
    return mtbf / (mtbf + mttr)


print()
for mtbf, mttr in ((720, 4), (720, 1), (720, 0.25), (2880, 4)):
    print(f"MTBF {mtbf:>4} h  MTTR {mttr:>4} h  ->  A = {avail(mtbf, mttr):.4%}")

app, db, wallet = 0.999, 0.9995, 0.995        # invented targets
print()
print(f"checkout needs app, db, wallet : {app * db * wallet:.4%}")
print(f"cash fallback, wallet optional : {app * db:.4%}")
two_apps = 1 - (1 - app) ** 2                 # two copies, one is enough
print(f"two app copies + db            : {two_apps * db:.4%}")

আসল আউটপুট:

availability   down per year    per 30 days
   99.000%    5256.0 min     432.0 min
   99.900%     525.6 min      43.2 min
   99.950%     262.8 min      21.6 min
   99.990%      52.6 min       4.3 min
   99.999%       5.3 min       0.4 min

MTBF  720 h  MTTR    4 h  ->  A = 99.4475%
MTBF  720 h  MTTR    1 h  ->  A = 99.8613%
MTBF  720 h  MTTR 0.25 h  ->  A = 99.9653%
MTBF 2880 h  MTTR    4 h  ->  A = 99.8613%

checkout needs app, db, wallet : 99.3508%
cash fallback, wallet optional : 99.8500%
two app copies + db            : 99.9499%

প্রথম ছক: প্রতিটি বাড়তি ৯ বন্ধ সময়কে দশ ভাগের এক ভাগে নামায়। দ্বিতীয় অংশ: মাসে একবার ভেঙে চার ঘণ্টায় ফেরা (৭২০ h, ৪ h) থেকে availability-তে সবচেয়ে বড় লাফ এসেছে MTTR ১৫ মিনিটে নামিয়ে, ৯৯.৪৫% থেকে ৯৯.৯৭%. আর লক্ষ করুন, (৭২০ h, ১ h) আর (২৮৮০ h, ৪ h) হুবহু একই availability দেয়, অথচ ব্যবহারকারীর অভিজ্ঞতা আলাদা: মাসে একবার এক ঘণ্টা, নাকি চার মাসে একবার চার ঘণ্টা। তাই availability-র সাথে MTBF আর MTTR আলাদা করে রিপোর্ট করুন। শেষ অংশ: checkout-এ app, database আর wallet তিনটিই লাগলে availability তাদের গুণফল, সবচেয়ে দুর্বলটির চেয়েও কম (৯৯.৩৫%). ক্যাশের বিকল্প থাকলে wallet আর checkout-এর single point of failure নয়, তাই ৯৯.৮৫%. হিসাবটি ধরে নেয় ব্যর্থতাগুলো স্বাধীন, যা বাস্তবে প্রায়ই সত্য নয়।

৫ · Reliability কি test করে প্রমাণ করা যায়?

“আমাদের app-এর MTBF ২০০ ঘণ্টা”, এই দাবি যাচাই করতে কত ঘণ্টা test লাগবে? নিচের simulation-এ সত্যিকারের MTBF ২০০ ঘণ্টা আর MTTR আধা ঘণ্টা ধরা হয়েছে (দুটিই কাল্পনিক), আর crash ও মেরামত আসে এলোমেলো, কিন্তু seed দেওয়া, তাই প্রতিবার একই ফল। তিন দৈর্ঘ্যের পর্যবেক্ষণ, প্রতিটি তিনটি আলাদা seed-এ:

import random


def observe(hours, mtbf, mttr, seed):
    """Simulate `hours` of running; crashes and repairs are random."""
    rng = random.Random(seed)
    t = up = 0.0
    repairs = []
    while t < hours:
        run = rng.expovariate(1 / mtbf)       # time until the next crash
        if t + run >= hours:
            up += hours - t
            break
        up += run
        fix = rng.expovariate(1 / mttr)       # time to restart and recover
        repairs.append(fix)
        t += run + fix
    return up, repairs


MTBF, MTTR = 200.0, 0.5                       # the truth (invented), hours
print(f"truth: MTBF={MTBF:.0f} h  MTTR={MTTR} h  A={MTBF / (MTBF + MTTR):.3%}")
print("hours  seed  crashes  est_MTBF  est_MTTR  est_A")
for hours in (300, 2000, 20000):
    for seed in (1, 2, 3):
        up, rep = observe(hours, MTBF, MTTR, seed)
        n = len(rep)
        if n == 0:
            print(f"{hours:>5}  {seed:>4}  {n:>7}  no crash: MTBF unknown")
            continue
        est_mtbf, est_mttr = up / n, sum(rep) / n
        est_a = est_mtbf / (est_mtbf + est_mttr)
        print(f"{hours:>5}  {seed:>4}  {n:>7}  {est_mtbf:7.0f} h  {est_mttr:6.2f} h  {est_a:.3%}")

আসল আউটপুট:

truth: MTBF=200 h  MTTR=0.5 h  A=99.751%
hours  seed  crashes  est_MTBF  est_MTTR  est_A
  300     1        1      299 h    0.94 h  99.687%
  300     2        0  no crash: MTBF unknown
  300     3        2      150 h    0.43 h  99.715%
 2000     1       11      181 h    0.45 h  99.752%
 2000     2        8      249 h    0.73 h  99.710%
 2000     3        7      285 h    0.37 h  99.871%
20000     1      104      192 h    0.47 h  99.755%
20000     2       99      202 h    0.51 h  99.745%
20000     3       93      215 h    0.50 h  99.768%

৩০০ ঘণ্টায় (প্রায় ১২ দিন) একটি run-এ একটিও crash নেই, অর্থাৎ “কোনো ব্যর্থতা দেখিনি” মানে “MTBF অসীম” নয়; অন্য দুটিতে অনুমান ১৫০ থেকে ২৯৯ ঘণ্টা। ২০০০ ঘণ্টাতেও (প্রায় তিন মাস) অনুমান ১৮১ থেকে ২৮৫. মোটামুটি স্থির অনুমান এসেছে ২০,০০০ ঘণ্টায়, যা দুই বছরের বেশি। শিক্ষা: উঁচু reliability-র দাবি release-এর আগের ছোট test-এ প্রমাণ হয় না। Test যা পারে তা হলো নির্দিষ্ট দুর্বলতা খোঁজা (crash-এর পরে data ঠিক থাকে কি, ফিরতে কত সময়), আর production-এর পর্যবেক্ষণ থেকে সংখ্যাটি ধীরে ধীরে মাপা। বড় সংখ্যার দাবি দেখলে জিজ্ঞেস করুন: কত ঘণ্টার পর্যবেক্ষণ, কয়টি ঘটনা?

এজন্য reliability test সাধারণত দুই ধরনের। প্রথমটি দীর্ঘ সময়ের ভার, যেমন পর্ব ৫০-এর (SLO-ভিত্তিক test) soak run, যেখানে ভার সাজানো হয় বাস্তবের operational profile অনুযায়ী: ক্রেতারা কোন কাজ কত ঘনঘন করেন, সেই অনুপাতে। দ্বিতীয়টি ইচ্ছাকৃত ব্যর্থতা: crash, বিচ্ছিন্নতা, পূর্ণ disk. দ্বিতীয়টিই পরের অংশের বিষয়।

৬ · Recovery testing — payment-এর মাঝে server বন্ধ

Recovery testing মানে ইচ্ছা করে একটি ব্যর্থতা ঘটানো, তারপর দুটি জিনিস মাপা: ফিরতে কত সময় লাগল, আর ফেরার পরে অবস্থা সঠিক কি না। দ্বিতীয়টিই বেশি গুরুত্বপূর্ণ। সবচেয়ে ঝুঁকির জায়গা টাকার পথ, কারণ সেখানে “অর্ধেক হওয়া” মানে ক্রেতার টাকা কাটা কিন্তু order অপরিশোধিত, বা দুবার কাটা। নিচের ছবিতে wallet payment-এর পথে তিনটি সম্ভাব্য crash-এর জায়গা:

Payment-এর পথে কোথায় crash হলে কী থাকে

Crash points on the wallet payment path

Wallet payment-এর পাঁচ ধাপ আর তিনটি crash বিন্দু A, B, C ১ · Order placed, স্টক কমল, commit A · এখানে crash: টাকা কাটা হয়নি একই key-তে আবার pay নিরাপদ (§৬-এর run) ২ · App → gateway: charge, key-সহ ৩ · Gateway টাকা কাটে B · টাকা কাটা, order এখনো placed reconciliation ছাড়া কেউ জানে না ৪ · App: order → paid, commit C · paid, কিন্তু উত্তর client-এ যায়নি একই key → replay, দ্বিতীয় charge নয় ৫ · Client উত্তর পায়: paid
ছবি ৫৭.১ — A আর C-তে একই Idempotency-Key দিয়ে আবার চেষ্টাই সমাধান। B সবচেয়ে বিপজ্জনক: টাকা অন্য system-এ সরে গেছে, অথচ নিজের database জানে না। এটি ধরার একমাত্র পথ দুই পক্ষের হিসাব মেলানো।

সত্যিকারের kill-and-recover run

Test-এর পরিকল্পনা: app চালু করা হলো এমনভাবে যে নকল wallet gateway প্রতিটি charge-এর আগে ৩ সেকেন্ড ঘুমায় (BAZARGHAR_WALLET_DELAY_MS=3000). mitu cart-এ তেল আর আলু (১০০১ টাকা) রেখে mobile-wallet-এ order দিলেন, তারপর একটি thread থেকে pay পাঠানো হলো, key pay-8-a1. এক সেকেন্ড পরে, gateway যখন ঘুমিয়ে, নিজের server process-টিকে তার নিজের PID ধরে জোর করে বন্ধ করা হলো (Windows-এ taskkill /PID … /F; অন্য কোনো process-এ হাত দেওয়া হয়নি)। তারপর আবার চালু, আর API আর SQLite দুই দিক থেকে যাচাই। মূল অংশ:

t = threading.Thread(target=pay)        # POST /api/orders/8/pay, key pay-8-a1
t.start()
time.sleep(1.0)
kill_server()                            # taskkill /PID <our server> /F
t.join()

_, up = start(DB)                        # same DB file, no gateway delay
o = c.get(f"/api/orders/{oid}", headers=h).json()
db1("SELECT COUNT(*) FROM wallet_charges WHERE order_id=?", oid)
db1("PRAGMA integrity_check")
for i in (1, 2):                         # retry with the SAME key, twice
    c.post(f"/api/orders/{oid}/pay", headers={**h, "Idempotency-Key": KEY})

সত্যিকারের আউটপুট (অপ্রাসঙ্গিক দুটি লাইন বাদ):

order 8: placed total=961
oil stock after order: 29
client saw: ReadError
files: ['kr.db', 'kr.db-shm', 'kr.db-wal']
restart -> /api/health ok in 0.57 s
old token after restart: 200
order 8: status=placed paid=False history=['placed']
ledger rows for order: 0
integrity_check: ok
oil stock after restart: 29
retry 1: 200 status=paid replayed=no
retry 2: 200 status=paid replayed=true
ledger: [(8, 961, 'charged')]
1place order (oil+potato)2pay(key="pay-8-a1")3kill server by its PID4start server, same DB5check API + SQLite6pay(key="pay-8-a1")7pay(key="pay-8-a1")
Order ৮-এর অবস্থা
server
status
charges
oil stock
  1. পরিচিত শুরু। Order ৮ “placed”, মোট ৯৬১ টাকা (১০০১ − ১০০ ছাড় + ঢাকার ৬০), তেলের স্টক ৩০ থেকে ২৯. এই commit হওয়া অবস্থাই পরে মেলানো হবে।
  2. Payment শুরু। অনুরোধ server-এ পৌঁছেছে; নকল gateway ৩ সেকেন্ড ঘুমাচ্ছে, তখনো কিছু লেখা হয়নি। এটি ছবির A বিন্দু।
  3. Crash. Server-এর process জোর করে বন্ধ। Client পেল ReadError: সংযোগ ভেঙেছে, উত্তর নেই। এই মুহূর্তে client জানে না টাকা কাটা হয়েছে কি না; তাই অবস্থার ঘরে “?”. বাস্তবের ক্রেতাও ঠিক এই অনিশ্চয়তায় থাকেন।
  4. আবার চালু। একই database ফাইল, ০.৫৭ সেকেন্ডে /api/health ঠিক। এটি MTTR-এর ছোট অংশ; বাস্তবে টের পাওয়া আর সিদ্ধান্তের সময়ও যোগ হয়। পুরোনো login token-ও চলছে, কারণ session database-এ থাকে।
  5. যাচাই। Order ৮ এখনো placed, ইতিহাসে শুধু placed, ledger-এ এর কোনো charge নেই, স্টক ২৯, integrity_check ok. অর্ধেক কাজ নেই: অনুরোধটি কিছু লেখার আগেই মরেছে। Crash-এর মুহূর্তে -wal আর -shm ফাইল পড়ে ছিল; চালু হওয়ার সময় SQLite নিজেই সেগুলো দেখে ঠিক অবস্থায় ফেরে (crash recovery).
  6. একই key দিয়ে আবার চেষ্টা। 200, status paid, একটি charge ৯৬১ টাকার। যেহেতু আগে কিছু কাটা হয়নি, এটিই প্রথম আসল charge, তাই replayed=no.
  7. আবারও একই key. এবার Idempotent-Replayed: true: server আগের উত্তরটিই ফেরত দিল, ledger-এ এখনো একটিই charge.

একটি সৎ সতর্কতা: বাজারঘরের নকল gateway একই database-এ, একই transaction-এ ledger লেখে, তাই crash হলে “টাকা কাটা” অংশও বাতিল হয়। আসল wallet আলাদা প্রতিষ্ঠানের আলাদা system; সেখানে ছবির B বিন্দু সত্যিই সম্ভব। আর ব্রাউজারের pay form প্রতিটি পাতা দেখার সময় নতুন key বানায় (পর্ব ৩৭-এ, Playwright গভীরে, এই কারণেই timeout-এর পরে দুবার charge পাওয়া গিয়েছিল); B-এর পরে ক্রেতা পাতা খুলে আবার পে করলে নতুন key যাবে, আর টাকা আবার কাটবে। দুটি প্রতিরক্ষা লাগে: এক, key ব্রাউজারের পাতায় নয়, order-এর সাথে বাঁধা থাকুক; দুই, নিয়মিত reconciliation: gateway-র ledger আর নিজের order মিলিয়ে দেখা।

Reconciliation-এর কোডও test চায়। নিচে একটি ছোট reconcile function আর তার তিনটি test; একটি test ইচ্ছা করে B বিন্দুর ঘটনাটি দেয়:

import sys, unittest


def reconcile(orders, ledger):
    """orders: {id: (status, method)}  ledger: [(order_id, amount), ...]"""
    charges = {}
    for oid, _amount in ledger:
        charges[oid] = charges.get(oid, 0) + 1
    problems = []
    for oid, (status, method) in orders.items():
        if status != "paid":                  # only paid orders are checked
            continue
        n = charges.get(oid, 0)
        if method != "cash" and n == 0:
            problems.append((oid, "paid_without_charge"))
        if n > 1:
            problems.append((oid, "double_charge"))
    return problems


class Reconcile(unittest.TestCase):
    def test_clean_day(self):
        self.assertEqual(reconcile({7: ("paid", "card"), 8: ("paid", "cash")}, [(7, 1800)]), [])

    def test_double_charge(self):
        self.assertEqual(reconcile({9: ("paid", "mobile-wallet")}, [(9, 961), (9, 961)]),
                         [(9, "double_charge")])

    def test_crash_after_charge(self):        # money moved, order still "placed"
        self.assertEqual(reconcile({10: ("placed", "mobile-wallet")}, [(10, 961)]),
                         [(10, "charge_without_paid_order")])


suite = unittest.defaultTestLoader.loadTestsFromTestCase(Reconcile)
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)

আসল আউটপুট (মাঝের traceback-এর অংশ ছোট করা):

test_clean_day (__main__.Reconcile.test_clean_day) ... ok
test_crash_after_charge (__main__.Reconcile.test_crash_after_charge) ... FAIL
test_double_charge (__main__.Reconcile.test_double_charge) ... ok

======================================================================
FAIL: test_crash_after_charge (__main__.Reconcile.test_crash_after_charge)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 30, in test_crash_after_charge
    self.assertEqual(reconcile({10: ("placed", "mobile-wallet")}, [(10, 961)]),
    …
AssertionError: Lists differ: [] != [(10, 'charge_without_paid_order')]
…
- []
+ [(10, 'charge_without_paid_order')]

----------------------------------------------------------------------
Ran 3 tests in 0.002s

FAILED (failures=1)

দুটি test সবুজ: পরিষ্কার দিন আর দুবার charge, দুটিই ঠিক ধরা পড়ে। তৃতীয়টি লাল: function খালি তালিকা দিল, অথচ ৯৬১ টাকা কাটা হয়েছে এমন একটি order-এর জন্য, যা এখনো placed. কারণ কোডের প্রথম শর্ত: শুধু paid order দেখা হয়, তাই ঠিক যে ঘটনাটি crash-এর পরে সবচেয়ে বিপজ্জনক, সেটিই চোখের আড়ালে। Database-এ নেই এমন order-এর charge-ও (§৮-এর restore-এর পরে সম্ভব) এই কোড ধরবে না। সমাধান অনুশীলন ২-এ।

৭ · Graceful degradation আর failover

সব অংশ সবসময় চলবে না, এটি ধরে নিয়েই নকশা করতে হয়। Graceful degradation মানে একটি অংশ পড়ে গেলে বাকি system কম সুবিধায় হলেও কাজ চালায়। বাজারঘরে প্রশ্নটি: wallet gateway বন্ধ থাকলে কি ক্রেতা ক্যাশে কিনতে পারেন? একই kill-and-recover script-এর শেষ অংশে নকল gateway-কে timeout অবস্থায় রেখে দুটি নতুন order (ডাল, ১৩৫ টাকা) দেওয়া হলো:

gateway down, mobile-wallet: 504 gateway_timeout
gateway down, cash: 200 paid

প্রত্যাশিত আচরণ: wallet-এর অনুরোধ দ্রুত একটি পরিষ্কার 504 পেল (ঝুলে থাকেনি), আর ক্যাশের পথ wallet-এর ওপর নির্ভর করে না, তাই সফল। কিন্তু test করতে গিয়ে একটি নকশার প্রশ্নও বেরোল: wallet-এ order দেওয়া ক্রেতা চাইলে সেই order ক্যাশে বদলাতে পারেন না; API-তে payment পদ্ধতি বদলানোর কোনো পথ নেই, শুধু বাতিল করে আবার order. আর §৬-এর crash-এর পরে order ৮ placed অবস্থায় স্টক ধরে রেখেছিল; অপরিশোধিত order কতক্ষণ পরে নিজে থেকে বাতিল হয়ে স্টক ফেরত দেবে, তার কোনো নিয়ম নেই। দুটিই requirement-এর ফাঁক, product owner-এর কাছে প্রশ্ন হিসেবে তুলুন, bug হিসেবে নয়।

Failover হলো মূল অংশ ব্যর্থ হলে কাজটি অতিরিক্ত একটি অংশের হাতে যাওয়া। এর জন্য লাগে redundancy (একাধিক কপি), আর কোনটি জীবিত তা জানার health check. Tester-এর দিক থেকে failover test-এর প্রশ্নগুলো:

  • সত্যিই সরে কি? মূল অংশ বন্ধ করুন; কত সেকেন্ডে অনুরোধ অন্যটিতে যায়, আর সেই সময়ে কতগুলো অনুরোধ ব্যর্থ হয়।
  • Health check সৎ কি? বাজারঘরের /api/health শুধু “ok” বলে, database পড়তে পারে কি না দেখে না। Database-এর ফাইল নষ্ট থাকলেও health ok দেখালে failover কখনো ঘটবে না।
  • Data কোথায়? Standby-তে data কত পিছিয়ে (replication lag)? Failover-এর মুহূর্তে commit হওয়া কিন্তু না-পৌঁছানো order হারায় কি?
  • একই দোষে দুটিই? দুই কপিতে একই software থাকলে একই bug দুটিকেই একসাথে ফেলে দিতে পারে (common-mode failure); ভাবনার প্রশ্ন ২-এ এর বিখ্যাত উদাহরণ।

Cloud ছাড়া এই কোর্সে failover-এর পূর্ণ পরিবেশ বানানো হয়নি; replication, active-passive আর multi-region-এর নকশা পড়ুন সিস্টেম ডিজাইন কোর্সের পর্ব ৫১-এ, আর timeout, retry ও circuit breaker-এর মতো resilience pattern একই কোর্সের পর্ব ৪৮-এ। ইচ্ছাকৃতভাবে উৎপাদন-সদৃশ পরিবেশে গোলমাল ঢুকিয়ে এসব প্রশ্নের নিয়মিত উত্তর খোঁজার চর্চা পর্ব ৬৩-এর (Chaos আর resilience testing) বিষয়।

৮ · Backup, restore আর upgrade — data কি টিকে থাকে?

পরীক্ষার খাতার ফটোকপিতে সব পাতা এসেছে কি না, মিলিয়ে দেখতে হয়। Backup-এর test মানে তাই restore-এর test: সত্যিই ফিরিয়ে এনে গোনা আর মেলানো। দুটি লক্ষ্য সংখ্যা ঠিক করে দেয় কী মেলাতে হবে: RPO (সর্বোচ্চ কত সময়ের data হারানো চলে) আর RTO (সর্বোচ্চ কত সময়ে আবার চালু)। এদের নীতি আর কৌশল ক্লাউড ও DevOps কোর্সের পর্ব ২৪-এ; এখানে একটি সত্যিকারের restore drill.

পরিকল্পনা: নতুন database-এ app চালু, পাশে একটি দীর্ঘ সময় খোলা থাকা পাঠক connection (যেমন একটি রিপোর্টের কাজ), joy দুটি ক্যাশ order দিলেন (৮, ৯)। তারপর দুই রকম backup: (ক) চলমান অবস্থায় শুধু shop.db ফাইলটি কপি, (খ) SQLite-এর online backup API (sqlite3.Connection.backup). এরপর আরও একটি order (১০), তারপর “দুর্ঘটনা”: server বন্ধ, database-এর সব ফাইল মোছা, backup থেকে ফেরানো, আবার চালু। সত্যিকারের আউটপুট:

orders placed: 8 9
wal bytes: 115392
naive copy : orders=7 max_id=7 sum_total=6861 integrity=ok
backup API : orders=9 max_id=9 sum_total=7821 integrity=ok
order after backup: 10
restored, health ok in 0.55 s; orders=9 max_id=9 sum_total=7821 integrity=ok
GET /api/orders/10 -> 404
new order after restore gets id: 10

তিনটি শিক্ষা এখানে। এক, সাধারণ কপিতে order ৮ আর ৯ নেই, অথচ integrity_check “ok”. কারণ SQLite-এর write-ahead log (WAL) মোডে নতুন commit প্রথমে আলাদা -wal ফাইলে জমে (এখানে ১,১৫,৩৯২ byte), আর একটি খোলা connection থাকায় তখনো মূল ফাইলে বসেনি। Integrity check বলে ফাইলের গঠন ঠিক, data সম্পূর্ণ কি না নয়; তাই গোনা আর যোগফল মেলান: ৭ বনাম ৯টি order, ৬৮৬১ বনাম ৭৮২১ টাকা। Backup API সব এনেছে; WAL-এর ভেতরের কাজ DBMS ও SQL কোর্সের পর্ব ৪৮-এ, file system-এর দিক অপারেটিং সিস্টেম কোর্সের পর্ব ৪৪-এ। দুই, order ১০ backup-এর পরে এসেছিল, তাই হারাল; এটিই RPO-র বাস্তব চেহারা। তিন, সবচেয়ে সূক্ষ্ম: ফেরানোর পরে নতুন order আবার ১০ নম্বর পেল। হারানো order ১০-এর SMS আগের ক্রেতা পেয়ে থাকলে এখন একই নম্বরে আরেকজনের order, আর ledger-এর পুরোনো charge নতুন order-এর সাথে ভুলভাবে মিলতে পারে। Restore-এর পরে reconciliation বাধ্যতামূলক।

Upgrade test — নতুন schema-য় পুরোনো কোড চলে কি?

Upgrade testing জিজ্ঞেস করে: পুরোনো version-এর আসল data রেখে নতুন version বসালে data অক্ষত থাকে কি, আর খারাপ হলে পুরোনো version-এ ফেরা যায় কি? দ্বিতীয় প্রশ্নের উত্তর নির্ভর করে নতুন schema-য় পুরোনো কোড চলে কি না, অর্থাৎ schema পরিবর্তনটি backward compatible কি না। দুটি migration একই v1 data-র দুটি কপিতে চালানো হলো, প্রতিটি দুইবার (দ্বিতীয়বার কিছুই করার কথা নয়, PRAGMA user_version দিয়ে চেনা):

GOOD = """ALTER TABLE orders ADD COLUMN delivery_note TEXT;
CREATE INDEX IF NOT EXISTS idx_history_order ON order_history(order_id);"""
BAD = "ALTER TABLE orders RENAME COLUMN delivery_slot TO slot;"
# for each: copy v1 data, migrate twice, count rows + foreign_key_check,
# then start the OLD v1 code on the new schema and GET /api/orders/7

সত্যিকারের আউটপুট (traceback-এর ফাইলের পথ আর একই সংখ্যার একটি লাইন ছোট করা):

[good] before : {'users': 5, 'orders': 7, 'order_items': 13, 'order_history': 27, 'wallet_charges': 4, 'fk_errors': 0}
[good] run 1  : applied
[good] run 2  : skipped (already applied)
[good] after  : {'users': 5, 'orders': 7, 'order_items': 13, 'order_history': 27, 'wallet_charges': 4, 'fk_errors': 0}
[good] v1 code GET /api/orders/7 -> 200 same JSON as before
[bad] before : {... same counts ...}
[bad] run 1  : applied
[bad] run 2  : skipped (already applied)
[bad] after  : {'users': 5, 'orders': 7, 'order_items': 13, 'order_history': 27, 'wallet_charges': 4, 'fk_errors': 0}
[bad] v1 code GET /api/orders/7 -> 500
  File ".../bazarghar/services.py", line 270, in _order
    "payment_method": o["payment_method"], "delivery_slot": o["delivery_slot"],
IndexError: No item with that key

দুটি migration-ই data-র হিসাবে নিখুঁত, শুধু গোনার test দুটিকেই পাস করাত। পার্থক্য ধরা পড়ল পুরোনো কোড নতুন schema-য় চালাতেই: নতুন ঐচ্ছিক column আর index (যা পর্ব ৪৯-এর N+1 আর index-এর সমস্যার সমাধানের অংশও) পুরোনো কোড টেরই পায়নি, উত্তর হুবহু আগের মতো। কিন্তু column-এর নাম বদলের পরে পুরোনো কোড 500 দিল। অর্থাৎ rollback-এর পথ বন্ধ, আর deploy-এর সময় পুরোনো আর নতুন কোড পাশাপাশি চললে তখনও ভুল হবে। সমাধানের পদ্ধতি expand-contract, যা পর্ব ৩৩-এ দেখেছেন। Upgrade test-এর চেকলিস্ট তাই: আসল আকারের data-র কপি, migration দুইবার, গোনা ও যোগফল, নতুন কোডে smoke test, পুরোনো কোডে smoke test, আর migration-এর সময় মাপা (বড় table-এ লম্বা lock মানে সেই সময় checkout বন্ধ)। Deploy-এর কৌশল (blue-green, canary) ক্লাউড ও DevOps কোর্সের পর্ব ৫৯-এ।

আরও গভীরে: Software reliability-কে গাণিতিক মডেলে ধরার চেষ্টা ১৯৭০-এর দশক থেকে, যেমন Goel ও Okumoto-র reliability growth মডেল (১৯৭৯), যা test-এর সময় ধরা পড়া bug-এর হার থেকে ভবিষ্যতের ব্যর্থতার হার অনুমান করে; John Musa operational profile-এর ধারণাকে জনপ্রিয় করেন বলে ধরা হয়। এসব মডেলের অনুমান (স্বাধীন ব্যর্থতা, সারানোয় নতুন bug না ঢোকা) বাস্তবে প্রায়ই ভাঙে, তাই বড় দলগুলো এখন production-এর পর্যবেক্ষণ আর SLO-কে বেশি ভরসা করে। অন্যদিকে distributed database-এ crash আর network বিচ্ছিন্নতার পরে data-র সঠিকতা যাচাইয়ে Jepsen নামের স্বাধীন প্রকল্প পরিচিত, যার রিপোর্টে বারবার দেখা গেছে নথিতে দাবি করা নিশ্চয়তা আর বাস্তব আচরণ সবসময় মেলে না।

পরীক্ষা ও ইন্টারভিউতে (বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এমন প্রশ্ন সাধারণ):

  • Availability কীভাবে হিসাব করবেন? — MTBF ÷ (MTBF + MTTR), বা চালু সময় ÷ মোট সময়; ৯৯.৯% মানে ৩০ দিনে ৪৩.২ মিনিট বন্ধ থাকার সুযোগ।
  • MTBF আর MTTF-এর পার্থক্য? — MTBF মেরামতযোগ্য system-এ দুটি ব্যর্থতার মাঝের গড় সময়; MTTF বদলে ফেলা হয় এমন জিনিসের প্রথম ব্যর্থতা পর্যন্ত গড় সময়।
  • Recovery testing কী? — ইচ্ছা করে ব্যর্থতা ঘটিয়ে ফেরার সময় আর ফেরার পরের data-র সঠিকতা যাচাই; শুধু “আবার চালু হলো” যথেষ্ট নয়।
  • RPO আর RTO? — RPO: কত সময়ের data হারানো চলে; RTO: কত সময়ে আবার চালু হতে হবে।
  • Backward আর forward compatibility? — Backward: নতুন version পুরোনো client বা data মেনে চলে; forward: পুরোনো কোড নতুন data পেয়েও ভাঙে না।

৯ · AI-এর যুগে compatibility আর reliability testing

AI সহকারীকে “checkout-এর recovery test লিখে দাও” বললে চেনা ভুলগুলো আসে। Crash-এর পরে শুধু /api/health 200 দেখে পাস দেয়, database-এর অবস্থা দেখে না। প্রত্যাশা লেখে কোডের বর্তমান আচরণ থেকে, যেমন “crash-এর পরে order paid হবে”, যেখানে requirement চায় “ঠিক একবার charge”. Process বন্ধ করতে taskkill /IM python.exe বা pkill python দেয়, যা কম্পিউটারের সব Python process মেরে ফেলে। Server ফেরার অপেক্ষায় sleep(10) বসায়। Wallet-কে এত mock করে যে আসল crash-এর পথ থাকে না, আর CDP-র এমন option বানায়, যা protocol-এ নেই। Backup test-এ ফাইল কপি করে integrity check দেখেই “restore যাচাই হয়েছে” লেখে। আর প্রায়ই না চালিয়েই বলে “সব test পাস”।

AI-কে কাজ দেওয়ার সময় requirement, crash-এর জায়গা আর কী মেলাতে হবে তা স্পষ্ট দিন:

তুমি একজন QA engineer. বাজারঘর নামের একটি localhost app-এর জন্য pytest-এ একটি recovery test লেখো। Requirement: "payment চলার সময় server বন্ধ হলে, আবার চালুর পরে একই Idempotency-Key দিয়ে চেষ্টা করলে order ঠিক একবার paid হবে, wallet ledger-এ ঠিক একটি charge থাকবে, স্টক একবারই কমবে।" শর্ত: ১. Server শুধু নিজের শুরু করা process, তার PID দিয়ে বন্ধ করবে; নাম ধরে সব process মারবে না। ২. Server ফেরার অপেক্ষা health endpoint-এ সীমিত সংখ্যক চেষ্টায়, sleep-এর আন্দাজে নয়। ৩. যাচাই API আর SQLite দুই দিক থেকে: order-এর status, ইতিহাস, ledger-এর সারির সংখ্যা, স্টক, PRAGMA integrity_check. ৪. প্রতিটি assert-এর পাশে মন্তব্যে requirement-এর কোন অংশ যাচাই করছে লেখো। ৫. যেসব API field বা option নিশ্চিত নও, বানিয়ে না লিখে আলাদা করে তালিকা দাও। ৬. Test চালানোর আগে "পাস করেছে" দাবি করবে না।

AI-এর লেখা compatibility বা reliability test হাতে পেলে — চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১একটি দলের পাঁচ রকম backup ব্যবস্থা ছিল, তবু দুর্ঘটনার দিন কোনোটিই কাজে আসেনি। এমন কীভাবে হয়, আর tester কী করতে পারতেন?

এমন একটি ঘটনা বহুল আলোচিত: ২০১৭ সালের জানুয়ারির শেষে GitLab-এর একজন প্রকৌশলী রাতের ক্লান্ত অবস্থায় replication-এর সমস্যা সারাতে গিয়ে ভুল server-এ production database-এর data মুছে ফেলেন। তারপর দল খুঁজতে গিয়ে দেখে, তাদের কয়েক ধরনের backup ও replication ব্যবস্থার প্রায় কোনোটিই কাজের অবস্থায় নেই: নিয়মিত dump-এর কাজটি version-এর অমিলে নিঃশব্দে ব্যর্থ হচ্ছিল, আর ব্যর্থতার ইমেল পৌঁছাচ্ছিল না। শেষে প্রায় ছয় ঘণ্টা পুরোনো একটি snapshot থেকে ফেরানো হয়, আর সেই সময়ের কিছু data স্থায়ীভাবে হারায়। প্রতিষ্ঠানটি পুরো ঘটনা প্রকাশ্যে লিখে ও সরাসরি সম্প্রচার করে, যা নিজেই শিক্ষণীয় ছিল (বিস্তারিত সংখ্যা তাদের প্রকাশিত postmortem-এ)।

মূল শিক্ষা হলো, backup-এর অস্তিত্ব আর restore-এর ক্ষমতা আলাদা জিনিস। এই পর্বের run-এও তা দেখেছেন: সাধারণ কপি “ok” integrity দিয়েছিল, অথচ দুটি order ছিল না। Backup-এর কাজ সবুজ দেখালেও ভেতরে কী আছে, কেউ না দেখলে জানা যায় না।

Tester এখানে কয়েকটি স্পষ্ট কাজ করতে পারেন। এক, নিয়মিত restore drill: নির্দিষ্ট সময় পরপর সর্বশেষ backup আলাদা পরিবেশে ফিরিয়ে আনা, app চালানো, আর গোনা ও যোগফল মেলানো (order-এর সংখ্যা, মোট টাকা, সর্বশেষ order-এর সময়)। দুই, RPO আর RTO-কে test-এর pass/fail বানানো: সর্বশেষ order-এর সময় আর দুর্ঘটনার সময়ের ব্যবধান RPO-র মধ্যে কি? পুরো ফেরানো RTO-র মধ্যে হলো কি? তিন, backup-এর কাজের ব্যর্থতা কেউ টের পায় কি না, তারও test: ইচ্ছা করে কাজটি ভাঙিয়ে দেখা alert আসে কি না। চার, restore-এর নির্দেশনা লিখিত আছে কি, আর এমন একজন কি তা অনুসরণ করে সফল হন, যিনি backup বানাননি?

মূল উপলব্ধি: যে backup কখনো ফিরিয়ে দেখা হয়নি, তা একটি আশা মাত্র; restore drill-কে নিয়মিত test হিসেবে চালান, আর সফলতার মাপ ঠিক করুন গোনা, যোগফল, RPO আর RTO দিয়ে।

প্র ০২দুটি একই রকম কপি রাখলে কি নির্ভরযোগ্যতা দ্বিগুণ হয়? পুরোনো, পরীক্ষিত software নতুন system-এ বসানো কি নিরাপদ?

১৯৯৬ সালের জুনে Ariane 5 রকেটের প্রথম উড্ডয়ন প্রায় ৪০ সেকেন্ডের মাথায় ব্যর্থ হয়, আর রকেটটি ধ্বংস করা হয়। তদন্ত কমিটির প্রকাশিত রিপোর্ট অনুযায়ী মূল কারণ ছিল inertial reference system-এর software, যা Ariane 4 থেকে প্রায় অপরিবর্তিত নেওয়া হয়েছিল। সেখানে একটি ৬৪-bit দশমিক সংখ্যাকে ১৬-bit পূর্ণসংখ্যায় রূপান্তরের সময় সীমা ছাড়িয়ে যায়, কারণ Ariane 5-এর গতিপথে একটি মান Ariane 4-এর চেয়ে অনেক বড় হতো। Ariane 4-এ সেই মান কখনো এত বড় হয়নি, তাই পুরোনো test আর অভিজ্ঞতা সমস্যাটি দেখায়নি। আর অংশটি আসলে উড্ডয়নের পরে কোনো কাজেই লাগত না।

এটি compatibility-র একটি নিখুঁত উদাহরণ: পরীক্ষিত software নতুন পরিবেশে নতুন input পেলে পুরোনো প্রমাণ আর খাটে না। Tester-এর প্রশ্ন হওয়া উচিত: পুরোনো system-এর কোন অনুমান (মানের সীমা, গতি, ফরম্যাট) নতুন system-এ বদলেছে? বাজারঘরে ছোট রূপে একই জিনিস: পুরোনো app-এর একটি field যদি ধরে নেয় order-এর মোট টাকা কখনো ৯৯,৯৯৯ ছাড়াবে না, পাইকারি ক্রেতা আসার পরে সেটি ভাঙবে।

দ্বিতীয় শিক্ষা redundancy নিয়ে। রকেটে দুটি inertial reference system ছিল, একটি সক্রিয়, একটি অতিরিক্ত। কিন্তু দুটিতে একই software, তাই একই input-এ দুটিই একই মুহূর্তের কাছাকাছি একই কারণে ব্যর্থ হয়, অতিরিক্তটি আগে। এর নাম common-mode failure. স্বাধীন ব্যর্থতা ধরে নিলে দুটি কপির availability-র গুণের হিসাব দারুণ দেখায় (দুটি স্বাধীন ৯৯.৯% কপি মিলে হিসাবে ৯৯.৯৯৯৯%), কিন্তু একই bug দুটিতে থাকলে আসলে একটির সমান।

তাই failover-এর test-এ শুধু “একটি বন্ধ করলে অন্যটি চলে কি” দেখলে যথেষ্ট নয়; জিজ্ঞেস করুন, কোন ধরনের ব্যর্থতা দুটিকেই একসাথে ফেলতে পারে: একই software, একই config-এর ভুল, একই database, একই সার্টিফিকেটের মেয়াদ, একই বিদ্যুৎ লাইন।

মূল উপলব্ধি: পরিবেশ বদলালে পুরোনো test-এর প্রমাণ বদলায়; আর redundancy তখনই কাজের, যখন কপিগুলো একই কারণে একসাথে ভাঙে না।

প্র ০৩একটি disk-এর নথিতে লেখা MTTF ১০ লাখ ঘণ্টা, অর্থাৎ শতাধিক বছর। তাহলে কি একটি disk শতাব্দী টিকবে?

না, আর এই ভুল বোঝাটি খুব প্রচলিত। ১০ লাখ ঘণ্টা প্রায় ১১৪ বছর, কিন্তু এর অর্থ একটি disk-এর আয়ু নয়। সংখ্যাটি সাধারণত আসে অনেকগুলো disk-কে তুলনামূলক অল্প সময় চালিয়ে মোট চালু ঘণ্টাকে ব্যর্থতার সংখ্যা দিয়ে ভাগ করে, disk-এর “কার্যকর জীবনকাল”-এর ভেতরে, যেখানে ব্যর্থতার হার মোটামুটি স্থির ধরা হয়। এটি একটি হার: বছরে ৮,৭৬০ ঘণ্টা ÷ ১০ লাখ ≈ ০.৮৮%, অর্থাৎ হাজারটি disk-এর একটি বড় সংগ্রহে বছরে প্রায় ৯টি ব্যর্থ হওয়ার কথা। বয়স বাড়লে ক্ষয়জনিত ব্যর্থতা এই হিসাবের বাইরে।

বাস্তবের মাপ এমনকি এই হারকেও প্রশ্ন করেছে। ২০০৭ সালে Bianca Schroeder আর Garth Gibson-এর গবেষণা (“Disk failures in the real world”, FAST সম্মেলন) বড় কয়েকটি data center-এর লাখখানেক disk-এর রেকর্ড দেখে জানায়, বাস্তবে disk বদলানোর বার্ষিক হার নথির হিসাবের চেয়ে কয়েক গুণ বেশি ছিল, আর হার বয়সের সাথে স্থির থাকে না। একই বছর Google-এর একটি গবেষণাও বড় সংগ্রহে অনুরূপ ধরনের পর্যবেক্ষণ প্রকাশ করে।

Tester-এর জন্য শিক্ষা তিনটি। প্রথম, MTBF বা MTTF-এর সাথে সবসময় জিজ্ঞেস করুন কীভাবে মাপা: কত একক, কত ঘণ্টা, কোন অবস্থায়, “ব্যর্থতা”-র সংজ্ঞা কী। দ্বিতীয়, এই পর্বের simulation-এ দেখেছেন অল্প ঘটনায় অনুমান কত দোলে; বড় দাবির পেছনে বড় পর্যবেক্ষণ লাগে। তৃতীয়, গড় একটি সংখ্যা ব্যক্তিগত ভাগ্য বলে না: হাজার disk-এর সংগ্রহে প্রতি মাসেই কোনো না কোনোটি ব্যর্থ হবে, তাই নকশাকে ধরে নিতে হবে যে ব্যর্থতা ঘটবেই, আর recovery-র test লাগবে।

Software-এর ক্ষেত্রেও একই সতর্কতা: “৯৯.৯৯% uptime” দাবি কোন জানালায়, কোন মাপে (শুধু health check, নাকি আসল ব্যবহারকারীর সফল অনুরোধ), আর পরিকল্পিত রক্ষণাবেক্ষণ বাদ দিয়ে কি না, তা না জেনে সংখ্যাটি তুলনা করা যায় না।

মূল উপলব্ধি: MTBF আর MTTF হলো অনেক এককের গড় হার, একটি এককের আয়ু নয়; সংখ্যার সাথে মাপার পদ্ধতি না জানলে তা অর্থহীন।

প্র ০৪একটি deploy-এ আটটি server-এর সাতটিতে নতুন কোড গেল, একটিতে গেল না। এতে কী ভয়ংকর হতে পারে, আর upgrade test কীভাবে সাহায্য করে?

২০১২ সালের আগস্টে যুক্তরাষ্ট্রের শেয়ারবাজারের একটি বড় লেনদেন প্রতিষ্ঠান Knight Capital-এর ঘটনা এর বহুল উদ্ধৃত উদাহরণ। নিয়ন্ত্রক সংস্থার প্রকাশিত বিবরণ অনুযায়ী নতুন কোড আটটি server-এর একটিতে হাতে বসানো বাদ পড়ে যায়। নতুন কোড একটি পুরোনো flag-কে নতুন অর্থে ব্যবহার করছিল; বাদ পড়া server-এ সেই flag পুরোনো, বহু বছর অব্যবহৃত একটি কাজকে জাগিয়ে তোলে। প্রায় ৪৫ মিনিট ধরে সেটি অসংখ্য অনাকাঙ্ক্ষিত লেনদেন করে, আর প্রতিষ্ঠানটি এত বড় ক্ষতির মুখে পড়ে যে স্বাধীনভাবে টিকে থাকতে পারেনি।

এখানে compatibility আর reliability দুটিই মিশে আছে। প্রথমত, পুরোনো আর নতুন কোড একসাথে চলছিল, আর তারা একই message-এর (flag-এর) দুটি ভিন্ন অর্থ ধরছিল: forward compatibility-র ভয়ংকর রূপ। দ্বিতীয়ত, deploy নিজেই অসম্পূর্ণ ছিল, আর তা ধরার কোনো স্বয়ংক্রিয় যাচাই ছিল না। তৃতীয়ত, ফিরে আসার চেষ্টাও (rollback) প্রথমে সমস্যা বাড়িয়েছিল বলে বর্ণনায় আছে, কারণ পরিস্থিতি বোঝা যায়নি।

এই পর্বের upgrade test-এর প্রশ্নগুলো ঠিক এই ঝুঁকি কমায়। “নতুন schema-য় পুরোনো কোড চলে কি” প্রশ্নটি mixed-version অবস্থাকে test-এর বিষয় বানায়; column-এর নাম বদলের run-এ দেখেছেন পুরোনো কোড 500 দেয়। আরও কয়েকটি অভ্যাস: পুরোনো flag বা field-কে নতুন অর্থে পুনর্ব্যবহার না করা (নতুন নাম নিন); deploy-এর পরে প্রতিটি server-এর version একটি endpoint থেকে পড়ে মিলিয়ে দেখা (বাজারঘরের /api/health version দেখায়); অব্যবহৃত কোড মুছে ফেলা; আর rollback-কেও একটি test করা পথ বানানো।

Release-এর কৌশল (canary, blue-green, feature flag) এই ঝুঁকিকে ছোট পরিসরে আটকায়, কিন্তু সেগুলোও শুধু তখনই কাজ করে, যখন কেউ যাচাই করেন যে পুরোনো আর নতুন একসাথে চললে কী হয়।

মূল উপলব্ধি: Deploy-এর মাঝখানে পুরোনো আর নতুন কোড পাশাপাশি চলে; সেই মিশ্র অবস্থা আর rollback-কে সরাসরি test করুন, শুধু “নতুন version চলে কি” নয়।

প্র ০৫“Payment ঠিক একবার হবে” — network আর crash থাকলে কি এটি নিশ্চিত করা সম্ভব? না হলে tester কী যাচাই করবেন?

দুই পক্ষ যখন একটি অনির্ভরযোগ্য পথে বার্তা পাঠায়, তখন কোনো পক্ষই নিশ্চিত হতে পারে না যে অন্যজন শেষ বার্তাটি পেয়েছে; distributed systems-এ এটি “দুই সেনাপতির সমস্যা” নামে পরিচিত একটি পুরোনো চিন্তা-পরীক্ষা। Payment-এ এর মানে: client একটি অনুরোধ পাঠাল আর উত্তর পেল না। হয় অনুরোধ পৌঁছায়নি, নয় পৌঁছে কাজ হয়েছে কিন্তু উত্তর হারিয়েছে। Client বাইরে থেকে দুটিকে আলাদা করতে পারে না, এই পর্বের kill run-এর ReadError-এর মতো।

তাই বাস্তবের system “ঠিক একবার পাঠানো” নয়, “বারবার পাঠানো যায়, কিন্তু ফল একবারই” নীতি নেয়: client উত্তর না পেলে আবার পাঠায় (at-least-once), আর server একই অনুরোধ চিনে দ্বিতীয়বার কাজ করে না (idempotency). দুটি মিলে কার্যত “effectively once”. Idempotency-Key ঠিক এই চেনার উপায়। কিন্তু এটিও একটি সীমার মধ্যে কাজ করে: key কতদিন মনে রাখা হয়, key কোথায় তৈরি হয় (পাতায়, নাকি order-এর সাথে), আর অন্য প্রতিষ্ঠানের gateway একই key মানে কি না।

এর পরেও কিছু ফাঁক থাকে, যেমন ছবির B বিন্দু, তাই শেষ প্রতিরক্ষা reconciliation: দুই পক্ষের হিসাব নিয়মিত মিলিয়ে অমিল খোঁজা আর ফেরত বা সমন্বয়। বাংলাদেশের মোবাইল রিচার্জ বা ব্যাংকের লেনদেনেও “টাকা কেটেছে কিন্তু হয়নি” ধরনের অভিযোগ কিছু সময় পরে ঠিক হয়ে যাওয়া এমন মেলানোর প্রক্রিয়ার ফল বলে ধারণা করা যায়।

Tester-এর যাচাইয়ের তালিকা তাই: প্রতিটি crash-এর জায়গায় (A, B, C) আবার চেষ্টার ফল; একই key একাধিকবার, ভিন্ন key একই order-এ, একই key ভিন্ন order-এ (বাজারঘর 422 দেয়); key মনে রাখার মেয়াদ পার হওয়ার পরে কী হয়; একসাথে দুটি একই অনুরোধ; আর reconciliation-এর কোডের নিজের test, যেমন এই পর্বের unittest, যা B-এর ঘটনা ধরতে ব্যর্থ হয়েছিল।

মূল উপলব্ধি: অনির্ভরযোগ্য পথে “ঠিক একবার পাঠানো” অসম্ভব, কিন্তু “বারবার পাঠানো, একবার ফল” সম্ভব; tester যাচাই করেন idempotency প্রতিটি crash-বিন্দুতে টেকে কি না, আর reconciliation বাকি ফাঁক ধরে কি না।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজের উত্তর লিখুন।

  1. Spec থেকে test case (test design): Requirement R-7: “(ক) payment চলার সময় server বন্ধ হলে, আবার চালুর পরে ক্রেতা একই order-এ আবার পে করতে পারবেন, আর কখনো দুবার টাকা কাটবে না। (খ) Placed কিন্তু অপরিশোধিত order ৩০ মিনিটের বেশি পুরোনো হলে নিজে থেকে বাতিল হবে আর স্টক ফেরত যাবে।” এই দুই অংশ থেকে test case বানান: (ক)-র জন্য crash-এর জায়গা ধরে, (খ)-র জন্য সময়ের সীমানা ধরে। প্রতিটির প্রত্যাশিত ফল লিখুন।

    (ক) crash-এর জায়গা ধরে (ছবি ৫৭.১): TC1 gateway-তে পাঠানোর আগে crash (A): ফেরার পরে order placed, charge ০; একই key-তে আবার পে → paid, charge ১. TC2 gateway টাকা কাটার পরে, order paid লেখার আগে (B): ফেরার পরে charge ১, order placed; একই key-তে আবার পে → paid, charge এখনো ১ (gateway key চেনে); ভিন্ন key-তে (যেমন ব্রাউজারের নতুন পাতা) → charge ১-ই থাকা উচিত, নইলে R-7 ভাঙা, আর reconciliation অমিল দেখাবে। TC3 order paid লেখার পরে, উত্তরের আগে (C): একই key → replay, charge ১. TC4 আবার পে দুইবার, একই key → দ্বিতীয়টি replay. প্রতিটিতে স্টক একবারই কমেছে, ইতিহাসে paid একবার, integrity ok.

    (খ) সময়ের সীমানা: “৩০ মিনিটের বেশি” মানে ঠিক ৩০:০০-এ বাতিল নয়। Test: ২৯:৫৯ → বাতিল নয়; ৩০:০০ → বাতিল নয়; ৩০:০১ → বাতিল, স্টক ফেরত, ইতিহাসে cancelled. সঙ্গে: paid order কখনো বাতিল নয়; আর বাতিলের মুহূর্তে আসা পে-অনুরোধ (race): পে সফল হলে বাতিল নয়, বাতিল হলে পে 409. সময় নিয়ন্ত্রণে fake clock লাগবে, অপেক্ষা নয়; বর্তমান বাজারঘরে (খ) নেই, তাই এগুলো নতুন feature-এর acceptance test.

  2. ব্যর্থতা পড়ুন আর সারান: নিচের দুটি সত্যিকারের ফল পড়ুন। (ক) Reconcile-এর test: AssertionError: Lists differ: [] != [(10, 'charge_without_paid_order')]. দোষ test-এর না কোডের, আর কোন লাইন বদলাবেন? (খ) Upgrade test: [bad] v1 code GET /api/orders/7 -> 500, সাথে IndexError: No item with that key, যদিও সারির সংখ্যা আগে-পরে এক। এতে কি data হারিয়েছে? এই migration release হলে কী ঝুঁকি?

    (ক) বাঁ দিকে function-এর ফল (খালি), ডান দিকে প্রত্যাশা। Test requirement-এর দিক থেকে ঠিক: টাকা কাটা কিন্তু order placed, এটি ধরা বাধ্যতামূলক। দোষ কোডের: if status != "paid": continue প্রথমেই এমন order বাদ দেয়। একটি সমাধান: loop-এর আগে ledger-এর প্রতিটি order দেখে নেওয়া, যেমন for oid in charges: if orders.get(oid, ("missing", ""))[0] != "paid": problems.append((oid, "charge_without_paid_order")), আর paid order-এর পরীক্ষা আগের মতো রাখা। এতে database-এ নেই এমন order-এর charge-ও ধরা পড়ে (restore-এর পরের অবস্থা)। তারপর আবার চালিয়ে তিনটি test সবুজ কি না দেখুন।

    (খ) Data হারায়নি: গোনা এক, foreign key ঠিক, column শুধু নতুন নাম পেয়েছে। কিন্তু পুরোনো কোড delivery_slot নামে column খোঁজে, পায় না, তাই 500. ঝুঁকি: deploy-এর সময় যে কয়েক মিনিট পুরোনো কোড চলে, তখন order-এর পাতা আর API ভাঙবে; আর নতুন version-এ সমস্যা হলে পুরোনো version-এ ফেরা যাবে না, কারণ পুরোনো কোড এই schema-য় চলে না। সমাধান expand-contract: আগে নতুন column যোগ ও দুই জায়গায় লেখা, সব কোড নতুন column পড়লে তবে পুরোনোটি মোছা।

  3. Test আর bug report-এ ভুল খুঁজুন: একজন সহকর্মী লিখলেন:
    def test_crash_recovery(server):
        pay_async(order_id=8)               # no Idempotency-Key
        os.system("taskkill /IM python.exe /F")
        time.sleep(10)
        start_server()
        assert httpx.get(BASE + "/api/health").status_code == 200
        r = httpx.post(BASE + "/api/orders/8/pay")    # retry, new request
        assert r.json()["status"] == "paid"
    সাথে bug report: “Backup যাচাই করা হয়েছে: চলমান server থেকে shop.db কপি করে খুলেছি, integrity_check = ok. Backup ঠিক আছে।” অন্তত ছয়টি সমস্যা খুঁজুন।

    Test-এ: (১) /IM python.exe কম্পিউটারের সব Python process মেরে ফেলে, অন্য কাজ আর test runner-ও; শুধু নিজের server-এর PID দিয়ে বন্ধ করুন। (২) Crash-এর মুহূর্ত নিয়ন্ত্রিত নয়: pay শেষ হয়ে গেছে, না শুরুই হয়নি, জানা নেই; gateway-তে দেরি বা নির্দিষ্ট hook দিয়ে crash-এর জায়গা ঠিক করুন। (৩) প্রথম অনুরোধ আর আবার চেষ্টা দুটিতেই Idempotency-Key নেই, তাই “দুবার charge নয়” যাচাইয়ের ভিত্তিই নেই; একই key দুবার পাঠান। (৪) sleep(10) ধীর আর ভঙ্গুর; health-এ সীমিত চেষ্টায় অপেক্ষা করুন। (৫) Health 200 মানে data ঠিক নয়; order-এর ইতিহাস, ledger-এ ঠিক একটি charge, স্টক আর integrity যাচাই নেই। (৬) Retry-তে login token নেই, তাই আসলে 401 আসবে আর r.json()["status"] KeyError দেবে; test ভুল কারণে লাল হবে।

    Bug report-এ: (৭) WAL মোডে শুধু .db কপি করলে শেষের commit বাদ পড়তে পারে; এই পর্বের run-এ ঠিক এভাবেই দুটি order হারিয়েছিল। (৮) Integrity check গঠন দেখে, সম্পূর্ণতা নয়; গোনা আর যোগফল মেলানো হয়নি। (৯) Restore করে app চালানো হয়নি, তাই “backup ঠিক” দাবি প্রমাণিত নয়; কোন সময়ের backup, RPO-র মধ্যে কি না, তাও নেই।

  4. RPO, RTO আর availability-র হিসাব: বাজারঘরের database-এর backup হয় প্রতিদিন রাত ২টায়। একদিন দুপুর ২:৩০-এ database ফাইল নষ্ট হলো। টের পেতে ২০ মিনিট, সিদ্ধান্তে ১০ মিনিট, restore আর চালুতে ৪০ মিনিট লাগল। (ক) কত ঘণ্টার order হারাল? (খ) এই ঘটনায় checkout কত মিনিট বন্ধ ছিল? (গ) মাসে (৩০ দিন) এটিই একমাত্র ঘটনা হলে সেই মাসের availability কত, আর ৯৯.৯% লক্ষ্য রক্ষা পেল কি? (ঘ) হারানো order-গুলোর জন্য restore-এর পরে কী করবেন?

    (ক) রাত ২:০০ থেকে দুপুর ২:৩০, ১২.৫ ঘণ্টার order (যদি রাতের backup সফল ছিল; restore drill ছাড়া সেটিও অনুমান)। (খ) ২০ + ১০ + ৪০ = ৭০ মিনিট। (গ) ৩০ দিন = ৪৩,২০০ মিনিট; চালু ৪৩,১৩০; availability = ৪৩,১৩০ ÷ ৪৩,২০০ ≈ ৯৯.৮৩৮%. ৯৯.৯%-এর সীমা ৪৩.২ মিনিট, তাই লক্ষ্য ভাঙা। লক্ষ করুন, MTTR-এর বড় অংশ restore নয়, টের পাওয়া আর সিদ্ধান্ত (৩০ মিনিট); ভালো alert আর লিখিত নির্দেশনা এখানেই সময় বাঁচায়। (ঘ) Wallet gateway-র ledger, SMS আর courier-এর তালিকা থেকে ওই ১২.৫ ঘণ্টার order খুঁজে reconciliation; যাঁদের টাকা কাটা হয়েছে কিন্তু order নেই, তাঁদের ফেরত বা order পুনর্গঠন; আর নতুন order-এর নম্বর যাতে হারানো order-এর নম্বরের সাথে না মেলে, সেজন্য restore-এর পরে নম্বরের ধারা এগিয়ে দেওয়া (এই পর্বের run-এ নতুন order আবার ১০ পেয়েছিল)।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমPayment-এর একটি recovery test-এর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. জানা অবস্থা তৈরি: একটি placed order, স্টক আর ledger লিখে রাখা
  2. নির্দিষ্ট key দিয়ে payment শুরু, crash-এর জায়গা নিয়ন্ত্রণে রেখে
  3. নিজের server process-টি তার PID দিয়ে বন্ধ করা
  4. আবার চালু করে ফেরার সময় মাপা
  5. API আর database দিয়ে অবস্থা যাচাই: status, ledger, স্টক, integrity
  6. একই key দিয়ে আবার চেষ্টা, আর ঠিক একটি charge নিশ্চিত করা

একটি service-এর MTBF ৭২০ ঘণ্টা আর MTTR ১ ঘণ্টা। এর availability প্রায় কত?

  • ৯৯.৯৯%
  • ৯৯.৮৬%
  • ৯৯.০%
  • ৭২%

৩০ দিনের একটি মাসে ৯৯.৯% availability লক্ষ্য হলে মোট কত সময় বন্ধ থাকার সুযোগ আছে?

  • প্রায় ৪৩.২ মিনিট
  • প্রায় ৪.৩ মিনিট
  • প্রায় ৮.৭৬ ঘণ্টা
  • প্রায় ৪৩২ মিনিট

WAL মোডে চলা একটি SQLite database-এর app চলার সময় শুধু মূল shop.db ফাইলটি কপি করা হলো। কপি খুলে PRAGMA integrity_check দিল “ok”. সবচেয়ে বড় ঝুঁকি কোনটি?

  • কপিটি খোলাই যাবে না
  • কোনো ঝুঁকি নেই, integrity ok মানে backup সম্পূর্ণ
  • শেষের কিছু commit হওয়া data কপিতে না থাকতে পারে, অথচ check ok দেখাবে
  • মূল database-এর data মুছে যাবে

Wallet payment চলার সময় server crash করল। আবার চালুর পরে দেখা গেল order “placed”, ledger-এ সেই order-এর কোনো charge নেই। পরের সঠিক ধাপ কোনটি?

  • Order বাতিল করে ক্রেতাকে নতুন order দিতে বলা
  • নতুন একটি Idempotency-Key দিয়ে আবার পে করা
  • Database-এ order-কে সরাসরি paid করে দেওয়া
  • একই Idempotency-Key দিয়ে আবার পে করা, তারপর ledger-এ ঠিক একটি charge যাচাই

একটি API-র নতুন version-এ নিচের কোন পরিবর্তনটি পুরোনো client-এর জন্য সাধারণত backward compatible?

  • Response-এর delivery_slot field-এর নাম বদলে slot
  • Response-এ একটি নতুন ঐচ্ছিক field delivery_note যোগ
  • total-এর ধরন সংখ্যা থেকে লেখা ("961")
  • Request-এ একটি নতুন বাধ্যতামূলক field যোগ

একটি UI test স্বাভাবিক network-এ পাস করে। Browser-এ প্রতি request-এ ৫০০০ ms দেরি বসালে cart-এর badge-এর expect (৫ সেকেন্ড সীমা) লাল হয়, যদিও পরের ধাপে দেখা যায় পণ্যটি cart-এ ঠিকই ঢুকেছে। সবচেয়ে সঠিক ব্যাখ্যা কোনটি?

  • App-এর cart-এ যোগ করার কোড ধীর network-এ কাজ করে না
  • Click-এর পরে sleep(10) বসানোই সমাধান
  • Test-এর অপেক্ষার সীমা ওই network-এর ধরনের সাথে মেলেনি; requirement অনুযায়ী প্রতিটি network profile-এর সীমা ঠিক করা দরকার
  • পাস না হওয়া পর্যন্ত test বারবার চালানো

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Compatibility আর reliability আলাদা প্রশ্ন: অন্য পরিবেশ, অন্য version আর অন্য network-এ চলে কি; আর সময়ের সাথে টেকে কি, ভাঙলে ঠিক অবস্থায় ফেরে কি।
  2. ধীর network-এ ফল পড়ুন সাবধানে: ৫০০০ ms-এ লাল হয়েছিল test-এর সীমা, app নয়; offline-এ পুরোনো মোট টাকা নীরবে থাকা আর দুইবার চাপে “কার্ট খালি” পাতা ছিল app-এর finding.
  3. Availability = MTBF ÷ (MTBF + MTTR): ৯৯.৯% মানে ৩০ দিনে ৪৩.২ মিনিট; MTTR কমানো প্রায়ই সবচেয়ে বড় লাভ, আর ছোট test-এ উঁচু MTBF প্রমাণ হয় না।
  4. Recovery test মানে crash-এর পরে data যাচাই: kill run-এ order placed, charge ০, integrity ok; একই key-তে ঠিক একটি charge. আসল gateway-তে B বিন্দুর জন্য reconciliation লাগে।
  5. Backup-এর test হলো restore: শুধু .db কপিতে দুটি order হারাল অথচ check ok; গোনা আর যোগফল মেলান, RPO মাপুন। Upgrade-এ পুরোনো কোড নতুন schema-য় চালিয়ে rollback-এর পথ যাচাই করুন।

পরের পর্বে: মডিউল ১০ শুরু, উন্নত testing technique দিয়ে। পর্ব ৫৮ (Property-based testing — Hypothesis আর shrinking)-এ একটি একটি উদাহরণ নয়, নিয়ম লিখবেন, যেমন “যেকোনো cart-এর মোট টাকা কখনো ঋণাত্মক নয়”, আর tool নিজে হাজারো input বানিয়ে সেই নিয়ম ভাঙার চেষ্টা করবে, ভাঙলে সবচেয়ে ছোট উদাহরণে নামিয়ে দেখাবে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান