A TPS-összetevők ismertetése

A Kernel Transaction Managert (KTM) és a Common Log File Systemet (CLFS) használó tranzakciófeldolgozó rendszereknek (TPS) a következő fontos összetevőket kell tartalmazniuk:

  • Tranzakciókezelő (KTM)

    A KTM nyomon követi az egyes tranzakciók állapotát, és koordinálja a helyreállítási műveleteket egy rendszer összeomlása után.

  • Egy vagy több erőforrás-kezelő

    Az Ön által megadott erőforrás-kezelők kezelik az egyes tranzakciókhoz társított adatokat.

  • Egy vagy több CLFS-naplóstream

    A tranzakciókezelő és az erőforrás-kezelők CLFS-naplóstreamekkel rögzítik a tranzakciók véglegesítéséhez, visszaállításához vagy helyreállításához használható információkat.

  • Egy vagy több tranzakciós ügyfél

    A TPS minden tranzakciós ügyfele általában létrehozhat egy tranzakciót, műveleteket hajthat végre az adatokon a tranzakció kontextusában, majd kezdeményezhet véglegesítési vagy visszaállítási műveletet a tranzakcióhoz.

Ez a cikk egy egyszerű TPS-t mutat be egy erőforrás-kezelővel, egy összetettebb TPS-vel, amely több erőforrás-kezelőt és néhány más TPS-forgatókönyvet tartalmaz.

A KTM használata szakasz részletes információkat tartalmaz arról, hogyan hozhat létre TPS-összetevőket a KTM használatával.

Egyszerű TPS

Az egyszerű TPS KTM-ből, egy erőforrás-kezelőből és CLFS-ből állhat. A tranzakciós ügyfelek az erőforrás-kezelő által biztosított felületen keresztül kommunikálhatnak az erőforrás-kezelővel.

Tegyük fel például, hogy adatbázis-kezelő rendszert szeretne létrehozni. Azt szeretné, hogy a rendszer ügyfelei hozzáférjenek az adatbázishoz úgy, hogy megnyitnak egy leírót egy adatbázis-objektumon, olvasási és írási műveleteket hajtanak végre az objektumon, majd bezárják az objektumfogópontot.

Tegyük fel, hogy azt szeretné, hogy az olvasási és írási műveletek atomi módon történjenek, hogy a rendszer többi felhasználója csak a végeredményt lássa. Ezt a célt úgy érheti el, hogy olyan TPS-t tervez, amely lehetővé teszi az ügyfelek számára, hogy adatbázisműveleteket kössenek egy tranzakcióhoz.

A rendszernek tartalmaznia kell egy erőforrás-kezelőt, amely kezeli az adatbázisban lévő adatokat az ügyfelektől érkező olvasási és írási kérelmekre válaszul. Ez az erőforrás-kezelő exportálhat egy alkalmazásprogramozási felületet (API), amely lehetővé teszi az ügyfelek számára, hogy egy tranzakciót olvasási és írási műveletek készletéhez rendeljenek.

Az erőforrás-kezelőnek a KTM-ben kell regisztrálnia magát azzal, hogy a ZwCreateTransactionManager és a ZwCreateResourceManager függvényeket meghívja. Ezután az erőforrás-kezelő részt vehet a tranzakciókban.

Előfordulhat, hogy az erőforrás-kezelő olyan függvényeket támogat, amelyek lehetővé teszik az ügyfelek számára adatobjektumok létrehozását, az adatobjektumokhoz társított adatok olvasását és írását, valamint az adatobjektumok bezárását. Az alábbi pszeudokód egy ügyfél kódütemezését mutatja be.

CreateDataObject (IN TransactionID, OUT DataHandle);
ReadData (IN DataHandle, OUT Data);
WriteData (IN DataHandle, IN Data);
WriteData (IN DataHandle, IN Data);
WriteData (IN DataHandle, IN Data);
CloseDataObject (IN DataHandle);

Mielőtt egy ügyfél meghívhatja az erőforrás-kezelő CreateDataObject rutinját, az ügyfélnek létre kell hoznia egy tranzakcióobjektumot a KTM ZwCreateTransaction rutinjának meghívásával, és a tranzakcióobjektum azonosítójának lekérésével a ZwQueryInformationTransaction meghívásával.

Amikor az ügyfél meghívja az erőforrás-kezelő CreateDataObject rutinját, az ügyfél átadja a tranzakcióobjektum azonosítóját az erőforrás-kezelőnek. Az erőforrás-kezelő meghívhatja a ZwOpenTransactiont , hogy lekérte a tranzakcióobjektum leíróját, majd meghívhatja a ZwCreateEnlistmentet a tranzakcióban való részvétel regisztrálásához.

Ezen a ponton az ügyfél megkezdheti a műveletek végrehajtását az adatobjektumon. Mivel az ügyfél tranzakcióazonosítót adott meg az adatobjektum létrehozásakor, az erőforrás-kezelő az összes olvasási és írási műveletet hozzárendelheti a tranzakcióhoz.

Az erőforrás-kezelőnek az ügyfél által megadott összes adatművelet eredményét rögzítenie kell az eredmények véglegessé tétele nélkül. Az erőforrás-kezelő általában CLFS használatával rögzíti a művelet eredményeit egy tranzakciónapló-adatfolyamban.

Amikor az ügyfél befejezi a resource manager meghívását tranzakciós műveletek végrehajtására, meghívja a KTM ZwCommitTransaction rutinját. Ezen a ponton a KTM értesíti az erőforrás-kezelőt, hogy a műveleteket véglegessé kell tennie. Az erőforrás-kezelő ezután áthelyezi a művelet eredményeit a naplóstreamből az adatok állandó tárolóeszközére. Végül az erőforrás-kezelő meghívja a ZwCommitComplete-t , hogy tájékoztassa a KTM-et a véglegesítési művelet befejezéséről.

Mi történik, ha a Resource Manager hibát jelez az ügyfél ReadData vagy WriteData felé irányuló hívásai során? Az ügyfél meghívhatja a ZwRollbackTransactiont a tranzakció visszaállításához. A hívás eredményeként a KTM értesíti az erőforrás-kezelőt, hogy vissza kell állítania az adatokat az eredeti állapotára. Ezután az ügyfél létrehozhat egy új tranzakciót ugyanahhoz a művelethez, vagy dönthet úgy, hogy nem folytatja.

Az alábbi pszeudokód egy ügyfél tranzakciós műveleteinek részletesebb sorozatára mutat példát.

    ZwCreateTransaction (&TransactionHandle, ...);
    ZwQueryInformationTransaction (TransactionHandle, ...);
    CreateDataObject (TransactionID, &DataHandle);
    Status = ReadData (DataHandle, &Data1);
    if (Status == Error) goto ErrorRollback;
    Status = WriteData (DataHandle, Data2);
    if (Status == Error) goto ErrorRollback;
    Status = WriteData (DataHandle, Data3);
    if (Status == Error) goto ErrorRollback;
    Status = WriteData (DataHandle, Data4);
    if (Status == Error) goto ErrorRollback;
    ZwCommitTransaction (TransactionHandle, ...);
    goto Leave;
ErrorRollback:
    ZwRollbackTransaction (TransactionHandle, ...);
Leave:
    ZwClose (TransactionHandle);
    return;

Mi történik, ha a rendszer összeomlik a tranzakció létrehozása után, de a véglegesítése vagy visszaállítása előtt? Minden alkalommal, amikor az erőforrás-kezelő betöltődik, meg kell hívnia a ZwRecoverTransactionManager és a ZwRecoverResourceManager függvényeket. A ZwRecoverTransactionManager hívásával a KTM megnyitja a naplóstreamet, és felolvassa a tranzakciós előzményeket. A ZwRecoverResourceManager hívása miatt a KTM értesíti az erőforrás-kezelőt azokról a tranzakciókról, amelyek az összeomlás előtt folyamatban voltak és amelyeket az erőforrás-kezelőnek helyre kell állítania.

Ha egy tranzakciós ügyfél az összeomlás előtt hívott meg egy ZwCommitTransaction függvényt és megkezdte a tranzakció véglegesítési műveleteinek kezelését, az erőforrás-kezelőnek képesnek kell lennie a tranzakció állapotát közvetlenül az összeomlás előtti pontra visszaállítani. Ha az ügyfél nem állt készen a tranzakció véglegesítésére az összeomlás előtt, az erőforrás-kezelő elvetheti az adatokat, és visszaállíthatja a tranzakciót.

A tranzakciós ügyfelek írásáról további információt a Tranzakciós ügyfél létrehozása című témakörben talál.

Az erőforrás-kezelők írásáról további információt a Resource Manager létrehozása című témakörben talál.

Több erőforrás-kezelő egy TPS-ben

Tegyük fel, hogy a TPS lehetővé teszi az ügyfelek számára, hogy egyetlen tranzakción belül két különálló adatbázisban módosítsák az adatokat, hogy a tranzakció csak akkor legyen sikeres, ha mindkét adatbázis módosítása sikeres.

Ebben az esetben a TPS két erőforrás-kezelővel rendelkezhet, egy-egy adatbázishoz. Minden erőforrás-kezelő exportálhat egy API-t, amellyel az ügyfelek hozzáférhetnek az erőforrás-kezelő adatbázisához.

Az alábbi pszeudokód bemutatja, hogyan hozhat létre egy ügyfél egyetlen tranzakciót, amely két olyan adatbázis műveleteit tartalmazza, amelyeket két erőforrás-kezelő támogat.

Ebben a példában az ügyfél beolvassa az adatokat az első adatbázisból, és a második adatbázisba írja. Ezután az ügyfél beolvassa az adatokat a második adatbázisból, és az első adatbázisba írja. (Az első erőforrás-kezelő rm1-sel kezdődő függvényeket exportál, a második erőforrás-kezelő pedig az Rm2-vel kezdődő függvényeket exportálja.)

    ZwCreateTransaction (&TransactionHandle, ...);
    ZwQueryInformationTransaction (TransactionHandle, ...);
    Rm1CreateDataObject (TransactionID, &Rm1DataHandle);
    Rm2CreateDataObject (TransactionID, &Rm2DataHandle);
    Status = Rm1ReadData (Rm1DataHandle, &Rm1Data);
    if (Status == Error) goto ErrorRollback;
    Status = Rm2WriteData (Rm2DataHandle, Rm1Data);
    if (Status == Error) goto ErrorRollback;
    Status = Rm2ReadData (Rm2DataHandle, &Rm2Data);
    if (Status == Error) goto ErrorRollback;
    Status = Rm1WriteData (Rm1DataHandle, Rm2Data);
    if (Status == Error) goto ErrorRollback;
    ZwCommitTransaction (TransactionHandle, ...);
    goto Leave;
ErrorRollback:
    ZwRollbackTransaction (TransactionHandle, ...);
Leave:
    ZwClose (TransactionHandle);
    return;

Mivel az ügyfél ugyanazt a tranzakcióazonosítót adja át mindkét erőforrás-kezelőnek, mindkét erőforrás-kezelő meghívhatja a ZwOpenTransactiont és a ZwCreateEnlistmentet a tranzakcióba való regisztrációhoz. Amikor az ügyfél végül meghívja a ZwCommitTransactiont, a KTM értesíti az egyes erőforrás-kezelőket, hogy a kezelőnek véglegessé kell tennie a műveleteket, és minden erőforrás-kezelő a ZwCommitComplete-t hívja meg, amikor befejeződik.

Egyéb TPS-forgatókönyvek

A KTM más TPS-forgatókönyveket is támogat. A következő forgatókönyvek például olyan összetevőket írnak le, amelyeket egy TPS tartalmazhat:

  • Egy erőforrás-kezelő, amely több adatbázist kezel.

    A Resource Manager API-ja lehetővé teheti az ügyfelek számára, hogy egyszerre több adatbázist nyissanak meg és férjenek hozzá, és az ügyfél egyetlen tranzakcióban több adatbázishoz is hozzáférhet.

  • Egy erőforrás-kezelő egy API-val, amelyet az ügyfelek meghívnak, és más erőforrás-kezelők api-kkal, amelyeket az első erőforrás-kezelő hív meg.

    Az ügyfél csak az első erőforrás-kezelővel kommunikál. Amikor az erőforrás-kezelő feldolgozza az ügyféltől érkező kéréseket, szükség szerint hozzáférhet a további erőforrás-kezelőkhöz az ügyfél kéréseinek feldolgozásához. Egy erőforrás-kezelő például egy ügyfél által elérhető adatbázist kezel, amely biztonsági mentési vagy adatellenőrzési műveleteket igényel egy második erőforrás-kezelőtől, amelyhez az ügyfelek nem férnek hozzá.

  • Egy meglévő ügyfél és erőforrás-kezelő, amely nem használ KTM-et, és integrálva van a KTM-et használó további erőforrás-kezelőkkel.

    Ebben az esetben általában módosítania kell a meglévő erőforrás-kezelőt, hogy az egy kiváló tranzakciókezelő legyen, amely kommunikál a KTM-sel.

  • Last updated on