Concurrente toegang in Apps Script

Concurrentieproblemen in Apps Script

Wanneer meerdere script-instanties tegelijk dezelfde data bewerken, ontstaan race conditions. Typische scenario's:

1. Meerdere formulierinzendingen tegelijk.
2. Een trigger-run die begint terwijl de vorige nog loopt.
3. Twee gebruikers die dezelfde spreadsheet-data bijwerken.
4. Een webhook die meerdere keren razendsnel wordt aangeroepen.

function onFormSubmit_ONVEILIG(e) {
  const blad = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Log');
  const volgNummer = blad.getLastRow();
  blad.appendRow([volgNummer + 1, e.response.getRespondentEmail()]);
}

Twee gelijktijdige inzendingen lezen beide getLastRow() voordat er geschreven is, en genereren hetzelfde volgnummer. Het resultaat is een dubbel nummer of een overschreven rij.

Veilige formulierverwerking met locks

De LockService geeft je drie soorten locks: getScriptLock() blokkeert alle gebruikers, getDocumentLock() blokkeert binnen één document en getUserLock() blokkeert per gebruiker. Voor gedeelde resources zoals een logblad gebruik je vrijwel altijd de script-lock.

function onFormSubmit(e) {
  const lock = LockService.getScriptLock();

  try {
    lock.waitLock(30000);

    const blad = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Registraties');
    const volgNummer = blad.getLastRow();
    const tijdstip = new Date();
    const email = e.response.getRespondentEmail();

    blad.appendRow([volgNummer, tijdstip, email, 'Nieuw']);
    SpreadsheetApp.flush();

  } finally {
    lock.releaseLock();
  }
}

waitLock(ms) wacht maximaal het opgegeven aantal milliseconden en gooit een fout als de lock niet vrijkomt. tryLock(ms) doet hetzelfde maar geeft false terug in plaats van een fout. Geef de lock altijd vrij in een finally-blok.

Idempotente operaties

Een idempotente operatie geeft hetzelfde resultaat, ongeacht hoe vaak je hem uitvoert. Dit is de veiligste aanpak voor situaties waar je niet zeker bent of een operatie al is uitgevoerd, zoals bij webhooks die opnieuw worden geprobeerd.

function idempotentGebruikerAanmaken(email, naam) {
  const lock = LockService.getScriptLock();

  try {
    lock.waitLock(10000);

    const blad = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Gebruikers');
    const data = blad.getDataRange().getValues();

    const bestaatAl = data.some(rij => rij[0] === email);
    if (bestaatAl) {
      Logger.log(`Gebruiker ${email} bestaat al, overgeslagen`);
      return false;
    }

    blad.appendRow([email, naam, new Date(), 'Actief']);
    Logger.log(`Gebruiker ${email} aangemaakt`);
    return true;

  } finally {
    lock.releaseLock();
  }
}

Optimistische vergrendeling met versienummers

Bij optimistische vergrendeling ga je ervan uit dat conflicten zeldzaam zijn. Elke record krijgt een versienummer; bij het bijwerken controleer je of de versie nog klopt. Komt die niet overeen, dan heeft iemand anders de record intussen aangepast en weiger je de schrijfactie.

function bijwerkenMetVersiecontrole(recordId, nieuweWaarde, verwachteVersie) {
  const lock = LockService.getScriptLock();

  try {
    lock.waitLock(10000);

    const blad = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Records');
    const data = blad.getDataRange().getValues();

    const rijIdx = data.findIndex(r => r[0] === recordId);
    if (rijIdx === -1) throw new Error(`Record ${recordId} niet gevonden`);

    const huidigVersie = data[rijIdx][3];
    if (huidigVersie !== verwachteVersie) {
      throw new Error(`Versieconflict: verwacht ${verwachteVersie}, actueel ${huidigVersie}`);
    }

    blad.getRange(rijIdx + 1, 2).setValue(nieuweWaarde);
    blad.getRange(rijIdx + 1, 4).setValue(verwachteVersie + 1);
    Logger.log(`Record ${recordId} bijgewerkt naar versie ${verwachteVersie + 1}`);

  } finally {
    lock.releaseLock();
  }
}

Dubbele trigger-uitvoeringen voorkomen

Met tryLock(0) probeer je een lock zonder te wachten. Lukt dat niet, dan loopt er al een andere instantie en sla je deze run gewoon over.

function dagelijkseImport() {
  const lock = LockService.getScriptLock();

  if (!lock.tryLock(0)) {
    Logger.log('dagelijkseImport wordt al uitgevoerd, deze run overgeslagen');
    return;
  }

  try {
    Logger.log('Import gestart');
    Utilities.sleep(3000);
    Logger.log('Import klaar');
  } finally {
    lock.releaseLock();
  }
}

Wachtrij-patroon voor seriële verwerking

Soms wil je taken niet weigeren maar netjes achter elkaar afhandelen. Bewaar dan een wachtrij in PropertiesService en verwerk telkens één taak per run.

function voegToeAanWachtrij(taak) {
  const lock = LockService.getScriptLock();

  try {
    lock.waitLock(10000);

    const props = PropertiesService.getScriptProperties();
    const wachtrij = JSON.parse(props.getProperty('WACHTRIJ') || '[]');
    wachtrij.push({...taak, id: Utilities.getUuid(), tijdstip: new Date().toISOString()});
    props.setProperty('WACHTRIJ', JSON.stringify(wachtrij));

  } finally {
    lock.releaseLock();
  }
}

function verwerkWachtrij() {
  const lock = LockService.getScriptLock();

  if (!lock.tryLock(1000)) {
    Logger.log('Wachtrij wordt al verwerkt');
    return;
  }

  try {
    const props = PropertiesService.getScriptProperties();
    const wachtrij = JSON.parse(props.getProperty('WACHTRIJ') || '[]');

    if (wachtrij.length === 0) return;

    const taak = wachtrij.shift();
    props.setProperty('WACHTRIJ', JSON.stringify(wachtrij));

    lock.releaseLock();

    verwerkTaak(taak);
  } catch(e) {
    lock.releaseLock();
    throw e;
  }
}

function verwerkTaak(taak) {
  Logger.log(`Verwerken: ${JSON.stringify(taak)}`);
}

Concurrente toegang is een onderschat probleem in Apps Script. Door consistent gebruik van locks en idempotente operaties bouw je scripts die ook onder belasting betrouwbaar functioneren.