JavaScript-Bibliothek common/transaction

Diese Bibliothek bietet Funktionen zum Ablaufen von Modifikationen in Transaktionen.

Regeln für Transaktionen

---

• Eine Transaktion ist fest an einen Thread gebunden, außerhalb davon ist sie nicht sichtbar.
• Tritt während einer laufenden Transaktion ein Fehler auf, rollen Sie die Transaktion zurück. Ansonsten können Inkonsistenzen entstehen (kein try-catch-ignore).
• Der Index wird frühestens nach Ende einer Transaktion aktualisiert, vorher sind Änderungen nicht sichtbar.
• Transaktionen dürfen nicht zu lange laufen und nicht zu viele Objekte innerhalb einer Transaktion verarbeiten. Ansonsten können Deadlocks auftreten.
• Wenn viele Objekte verarbeitet werden sollen, teilen Sie die Menge in Teilblöcke unter.
• In der Regel wird innerhalb der Iteration über alles mit einem Modulo einer gewissen Menge gearbeitet, etwa 100, und ein transaction.restart() ausgeführt. Dadurch wird die Transaktion bis dahin commited und neu gestartet.
• Zu große Transaktionen können bei einem Neustart dazu führen, dass das System für den Neustart lange benötigt, da die Transaktion abgebrochen wird und komplett zurückgerollt werden muss.
• In Bezug auf andere Systeme wirken Transaktionen nicht oder müssen gesondert beachtet werden (siehe Beispiel).

Verwendung

---

Binden Sie die Bibliothek stets am Anfang eines Skripts ein:

let transaction = require('common/transaction');

Aufruf

---

transaction(timeout, (t) => callback(t));

Parameter

Parameter	Beschreibung	Standard
timeout	Definiert in Sekunden, wie lange die Transaktion maximal dauern darf. Wenn diese Zeit abgelaufen ist, wird die Transaktion abgebrochen und es wird ein Rollback ausgeführt.	-1 (Timeout wird nicht berücksichtigt, die Transaktion kann beliebig lange laufen.)
callback	Definiert die zu übergebene Funktion, die innerhalb der Transaktion ausgeführt wird. Läuft diese Funktion ohne Fehler durch, wird am Ende automatisch ein Commit durchgeführt. Wird ein Fehler geworfen, so wird stattdessen ein Rollback durchgeführt.​​​​​​ Der Funktion wird als Parameter eine Referenz auf das Transaktions-Objekt übergeben. Für kleinere Transaktionen ist dieses typischerweise nicht nötig, aber bei der Verarbeitung von größeren Datenmengen muss die Transaktion regelmäßig über t.restart() neu gestartet werden. Hinweis: Rollen Sie die Transaktion nicht manuell zurück, sondern verwenden Sie den automatischen Rollback, indem ein geeigneter Fehler per throw geworfen wird. Nur so ist sichergestellt, dass der Transaktionsblock nach dem Rollback korrekt verlassen wird. Folgende Funktionen bietet der Parameter t an: restart Führt einen Commit aus und startet sofort eine neue Transaktion. Es existieren keine weiteren Parameter für restart.	–

Allgemein mit Timeout in Sekunden

let obj = require('common/objects'),
    transaction = require('common/transaction');

let timeout = 300; // Maximal 5 Minuten

transaction(timeout, t => {
  // Everything that takes place here is performed within a single transaction.
});

Allgemein ohne Timeout

Der Timeout wird auf den Standard -1 gesetzt.

let transaction = require('common/transaction');

transaction(t => {
  // Everything that takes place here is performed within a single transaction.
});

Beispiele

---

Beispiel 1

Nachfolgendes Beispiel zeigt eine Iteration über alle Objekte, bei der der Name eines jeden gefundenen Objekts umgesetzt wird. Es werden immer 50 Objekte in einer Transaktion umgesetzt.

let obj = require('common/objects');
let transaction = require('common/transaction');

function forEach(query, threshold, callback) {
  transaction(t => {
    let c = 0;

    obj.query(query).forEach(object => {
      if (++c > threshold) {
        t.restart();
        c = 0;
      }

      callback(object);
    });
  });
}

let ret = [];

forEach('name:("Dokumente" NOT "Sonstige_Dokumente") area:(Vorgangsdokumente NOT "Vorgangsdokumente - Ablage")', 50, object => {
  object.name = "Sonstige_Dokumente";
  ret.push(object.ID);
});

ret;

Beispiel 2

Nachfolgendes Beispiel zeigt, wie jede Änderung innerhalb einer Schleife als einzelne Transaktion durchgeführt wird.

// Delete DocumentTextObjects
// Unten in den Aufruf: clear(..) das entsprechende Suchmuster einstellen.


let IndexHelper = Packages.agorum.roi.searchengine.IndexHelper;
let MessageUtils = Packages.agorum.roi.ejb.messaging.common.MessageUtils;
let MessageBean = Packages.agorum.roi.ejb.messaging.common.MessageBean;

let objects = require('common/objects');
let transaction = require('common/transaction');

function clear(query) {
  let count = 0;
  let mu = new MessageUtils();

  objects.query(query).forEach(object => {
    transaction(() => {
      IndexHelper.disableRealtimeIndex();

      object.deleteDocumentText();

      let mb = new MessageBean();

      mb.setObjectProperty('value', new java.lang.Long(object.getId()));
      mb.setObjectProperty('eventType', 'updateObjectListener');
      mb.setObjectProperty('className', object.className);
      mb.setObjectProperty('NoEventAssistanceObject', '');

      mu.publishToTopic('updateObjectListener', mb, true);

      ++count;
    });
  });

  return count;
}

clear('nameextension:(html OR htm OR txt OR json OR xml)');

Beispiel 3

Nachfolgendes Beispiel zeigt, wie Sie eine Transaktion nach einer gewissen Zeit und nicht nach x Durchgängen neu starten.

let transaction = require('common/transaction');

// Definiere die Abbruchfunktion
// nach x Sekunden wird der übergebene callback ausgeführt
let periodic = (period, fn) => {
  let next = Date.now() + period;

  return () => {
    if (Date.now() > next) {
      fn();
      next = Date.now() + period;
    }
  };
};

transaction(t => {
  // ...

  // Define exact function; in this case, a flush to a log file is also performed with every transaction restart
  // The interval is set to 30 seconds
  let auto = periodic(30 * 1000, () => {
    ow.flush();
    t.restart();
  });

  // For example, a loop or forEach
  // In this loop, it is regularly checked whether the time is up and it needs to be executed again
  while (...) {

    // ...
    auto();
    // ...
  }
});

Beispiel 3

Nachfolgendes Beispiel zeigt, wie Sie eine Transaktion zurückrollen.

transaction(t => {
  // Everything that takes place here is performed within a single transaction.

  throw new Error('Transaktion beenden und Rollback machen');
});