-- Copyright (C) 1981, 1984, 1985  by Xerox Corporation. All rights reserved. 
-- Log.mesa, Transport Mechanism Mail Server: disk log --

-- HGM, 16-Sep-85 22:47:18
-- Andrew Birrell   September 14, 1982 2:03 pm --
-- Redell          20-May-81 17:13:35 --
-- M. D. Schroeder   June 7, 1982  7:07 PM --
-- Hankins	13-Aug-84 16:27:50	(add ReleasePage in DoSpill)
-- Wobber	29-Aug-84 17:58:36	(fix above faulty fix)

DIRECTORY
  Ascii USING [CR, SP],
  Heap USING [systemZone],
  LogDefs USING [],
  LogWatchDefs USING [],
  Process USING [DisableTimeout, SecondsToTicks, SetTimeout],
  String USING [
    AppendChar, AppendDecimal, AppendString, AppendSubString, EqualSubString,
    SubString, SubStringDescriptor],
  Time USING [Append, Current, Unpack],
  VMDefs USING [
    AbandonFile, CantOpen, CantReadBackingStore, CantWriteBackingStore, CloseFile,
    Error, FileHandle, FileSystem, Login, Logout, LookAheadCount, MarkStart,
    OpenFile, Page, PageAddress, PageByteIndex, pageByteSize, PageNumber,
    Position, ReadPage, Release, SetCreationTime, SetFileLength,
    UnableToLogin, UsePage, Wait];

Log: MONITOR
  IMPORTS Heap, Process, String, Time, VMDefs EXPORTS LogDefs, LogWatchDefs =

  BEGIN OPEN Ascii, String, Time, VMDefs;

  halfPagesInLogFile: CARDINAL = 60;
  pagesInLogFile: CARDINAL = halfPagesInLogFile * 2;
  endMarker: CHARACTER = '¬;
  dayLength: CARDINAL = 10;  -- format is "dd-mmm-yy "
  timeLength: CARDINAL = 8;  --format is "hh:mm:ss"

  spillLimit: CARDINAL = 40;  -- cycle length for spilling log files
  logSequence: [0..spillLimit);  -- number for backing up this log file cycle

  logFileHandle: FileHandle;
  current: Position;
  pageArray: LONG POINTER TO PACKED ARRAY PageByteIndex OF CHARACTER ¬ NIL;
  firstPage: Page ¬ NIL;

  lastDay: STRING = [dayLength];
  lastDaySSD: SubStringDescriptor ¬ [lastDay, 0, dayLength];
  lastDaySS: SubString = @lastDaySSD;

  logChange: CONDITION ¬ [timeout: Process.SecondsToTicks[2]];


  -- procedure to write a log entry --

  WriteLogEntry: PUBLIC ENTRY PROCEDURE [s: LONG STRING] =
    BEGIN

    dayTimeString: STRING ¬ [dayLength + timeLength];
    timeString: STRING ¬ [timeLength];
    daySSD: SubStringDescriptor ¬ [dayTimeString, 0, dayLength];
    daySS: SubString = @daySSD;
    timeSSD: SubStringDescriptor ¬ [dayTimeString, dayLength, timeLength];
    timeSS: SubString = @timeSSD;

    front: STRING = "  "L;
    crString: STRING = "
"L;

    Append[dayTimeString, Unpack[Current[]]];
    IF ~EqualSubString[daySS, lastDaySS] THEN
      BEGIN
      lastDay.length ¬ 0;
      AppendSubString[lastDay, daySS];
      LogLastDay[];
      END;
    AppendSubString[timeString, timeSS];
    StartLogEntry[];
    PutStringInLog[timeString];
    PutStringInLog[front];
    PutStringInLog[s];
    PutStringInLog[crString];
    FinishLogEntry[];

    BROADCAST logChange;

    END;


  -- procedure to start a log entry

  StartLogEntry: INTERNAL PROCEDURE =
    BEGIN
    Wait[LOOPHOLE[pageArray, VMDefs.Page]];
    -- make sure previous write completed before updating page
    END;


  -- procedure to put a string into the log file

  PutStringInLog: INTERNAL PROCEDURE [ls: LONG STRING] =
    BEGIN
    c: CHARACTER;
    Copy: PROC [offset: CARDINAL] RETURNS [done: CARDINAL] =
      BEGIN
      done ¬ MIN[pageByteSize - current.byte, ls.length - offset];
      FOR i: CARDINAL IN [0..done) DO
        pageArray­[current.byte + i] ¬
          IF (c ¬ ls[i + offset]) = endMarker THEN SP ELSE c;
        ENDLOOP;
      current.byte ¬ current.byte + done;
      END;

    firstChunkLength: CARDINAL = Copy[0];

    IF current.byte = pageByteSize  --cross a page boundary--
      AND firstPage = NIL  --not at end of second page--
      THEN
      BEGIN
      current.page ¬ current.page + 1;
      SELECT TRUE FROM
        (current.page >= pagesInLogFile) => {
          current.page ¬ 0; SpillLog[second, logSequence]};
        (current.page = halfPagesInLogFile) => SpillLog[first, logSequence];
        ENDCASE => NULL;
      firstPage ¬ LOOPHOLE[pageArray, VMDefs.Page];  --remember first page
      GetCurrentLogPage[];  --get second page; sets current.byte
      [] ¬ Copy[firstChunkLength];
      END;

    IF current.byte = pageByteSize THEN current.byte ¬ current.byte - 1  -- leave room for endMarker;

    END;


  -- procedure to complete a log entry

  FinishLogEntry: INTERNAL PROCEDURE =
    BEGIN
    pageArray­[current.byte] ¬ endMarker;  --will be overwritten by next log entry

    MarkStart[LOOPHOLE[pageArray, VMDefs.Page]];
    --writes second page first if entry crosses page boundary

    IF firstPage # NIL THEN
      BEGIN  -- wait for second page write to complete then write and release first page
      Wait[LOOPHOLE[pageArray, VMDefs.Page]];
      MarkStart[firstPage];
      Release[firstPage];
      firstPage ¬ NIL;
      IF current.page = 0 OR current.page = halfPagesInLogFile THEN LogLastDay[];
      -- write day at start of each half of file
      END;
    END;


  -- procedure to write a log entry containing the last day value

  LogLastDay: INTERNAL PROCEDURE =
    BEGIN
    binaryBit: STRING = [1];
    binaryBit[0] ¬ 377C;
    binaryBit.length ¬ 1;
    lastDay[lastDay.maxlength - 1] ¬ CR;
    StartLogEntry[];
    PutStringInLog[binaryBit];
    PutStringInLog[lastDay];
    FinishLogEntry[];
    SetCreationTime[logFileHandle];
    lastDay[lastDay.maxlength - 1] ¬ SP;
    END;


  -- procedure to read the current log page --

  GetCurrentLogPage: INTERNAL PROCEDURE =
    BEGIN
    pageArray ¬ LOOPHOLE[ReadPage[
      addr: PageAddress[file: logFileHandle, page: current.page], lookAhead: 0]];
    current.byte ¬ 0;
    IF current.page = 0 THEN
      BEGIN
      logSequence ¬ (logSequence + 1) MOD spillLimit;
      pageArray[0] ¬ LOOPHOLE[logSequence];
      current.byte ¬ 1;
      -- but don't mark it dirty yet --
      END;
    END;

  -- procedures to implement the LogWatchDefs interface --

  LogPosition: PUBLIC TYPE = VMDefs.Position;

  GetLogPosition: PUBLIC ENTRY PROCEDURE RETURNS [LogPosition] = {
    RETURN[current]};


  PutLogChars: PUBLIC PROCEDURE [
    p: LogPosition, put: PROCEDURE [CHARACTER], gap: PROCEDURE,
    stop: PROCEDURE RETURNS [BOOLEAN]] RETURNS [LogPosition] =
    BEGIN
    e: Position;
    page: LONG POINTER TO PACKED ARRAY PageByteIndex OF CHARACTER;
    WaitForNewChars: ENTRY PROCEDURE = INLINE {
      IF p = current THEN WAIT logChange; e ¬ current};
    CaughtUp: ENTRY PROCEDURE RETURNS [BOOLEAN] = INLINE {RETURN[p = current]};
    DO
      WaitForNewChars[];
      IF p # e THEN
        BEGIN
        ENABLE UNWIND => Release[LOOPHOLE[page, Page]];
        lastByte: PageByteIndex;
	page ¬ LOOPHOLE[ReadPage[PageAddress[logFileHandle, p.page], 0]];
        lastByte ¬ IF p.page = e.page THEN e.byte ELSE pageByteSize;
        FOR i: PageByteIndex IN [p.byte..lastByte) DO
          IF p.page # 0 OR i # 0 THEN put[page[i]]; -- First character in file is log file #
	  ENDLOOP;
        p ¬ IF p.page = e.page THEN e ELSE [(p.page + 1) MOD pagesInLogFile, 0];
        IF CaughtUp[] THEN gap[];
        Release[LOOPHOLE[page, Page]];
        END;
      IF stop[] THEN RETURN[p];
      ENDLOOP;
    END;  -- PutLogChars --


  -- procedure to spill half of log to backing file server

  SpillRequest: TYPE = {first, second};
  spillRequest: SpillRequest;  -- which half to spill this time --
  spillSequence: [0..spillLimit);  -- which file to spill to this time --
  spillerWanted: BOOLEAN;  -- spilling request has been set up --
  spillerChange: CONDITION;  -- used in both directions --
  spillerSeconds: CARDINAL ¬ 5 * 60;  -- delay between retries after failures --
  spillerProcess: PROCESS;  -- for debugging only --
  myName: LONG STRING ¬ NIL;  -- credentials for spilling --
  myPwd: LONG STRING ¬ NIL;
  server: LONG STRING ¬ NIL;  -- server name for spilling --
  spillName: LONG STRING ¬ NIL;  -- spill file name --
  spillPrefix: CARDINAL;
  spillEnabled: BOOLEAN ¬ FALSE;

  KeepString: INTERNAL PROC [from: LONG STRING, extra: CARDINAL ¬ 0]
    RETURNS [to: LONG STRING] =
    BEGIN
    to ¬ Heap.systemZone.NEW[StringBody[from.length + extra]];
    String.AppendString[to, from];
    END;

  EnableLogSpilling: PUBLIC ENTRY PROC [name, pwd, host, path: LONG STRING] =
    BEGIN
    IF spillEnabled THEN RETURN;
    myName ¬ KeepString[name];
    myPwd ¬ KeepString[pwd];
    server ¬ KeepString[host];
    spillName ¬ KeepString[path, myName.length + 5 -- "Cabernet-00!1" -- ];
    spillPrefix ¬ path.length;
    spillEnabled ¬ TRUE;
    -- Assume last spill of previous run failed, and possibly re-try --
    IF current.page < halfPagesInLogFile THEN  -- previous request was for second half of previous cycle --
      BEGIN
      spillRequest ¬ second;
      spillSequence ¬ (logSequence + spillLimit - 1) MOD spillLimit;
      END
    ELSE  -- last spill request was for first half of this cycle --
      BEGIN spillRequest ¬ first; spillSequence ¬ logSequence; END;
    spillerWanted ¬ FALSE;  -- Spiller may retry after normal delay --
    spillerProcess ¬ FORK LogSpiller[];
    END;

  SpillLog: INTERNAL PROC [half: SpillRequest, cycle: [0..spillLimit)] =
    BEGIN
    IF spillEnabled THEN
      BEGIN
      -- don't wait for spiller if it isn't ready: it might take too long!
      spillRequest ¬ half;
      spillSequence ¬ cycle;
      spillerWanted ¬ TRUE;
      NOTIFY spillerChange;
      END;
    END;

  WaitForSpillRequest: ENTRY PROC [completed: BOOLEAN]
    RETURNS [SpillRequest, [0..spillLimit)] =
    BEGIN
    IF completed THEN Process.DisableTimeout[@spillerChange]
    ELSE
      Process.SetTimeout[@spillerChange, Process.SecondsToTicks[spillerSeconds]];
    DO
      IF NOT spillerWanted THEN WAIT spillerChange;
      IF spillerWanted  -- new request --
        OR
          (  -- possible retry after timeout --
            NOT completed
            AND
              ((spillRequest = first
                 AND current.page < halfPagesInLogFile + halfPagesInLogFile / 2)
                OR
                  (spillRequest = second
                    AND current.page < halfPagesInLogFile / 2))) THEN EXIT;
      ENDLOOP;
    spillerWanted ¬ FALSE;
    RETURN[spillRequest, spillSequence]
    END;

  LogSpiller: PROC =
    BEGIN
    Behind: ENTRY PROC RETURNS [BOOLEAN] = INLINE {RETURN[spillerWanted]};
    completed: BOOLEAN ¬ FALSE;  -- assume last run failed --
    DO
      half: SpillRequest;
      currentCycle: [0..spillLimit);
      [half, currentCycle] ¬ WaitForSpillRequest[completed];
      BEGIN
      ENABLE
        VMDefs.UnableToLogin, VMDefs.CantOpen, VMDefs.Error,
          VMDefs.CantReadBackingStore, VMDefs.CantWriteBackingStore => GOTO crash;
      DoSpill[half, currentCycle];
      completed ¬ TRUE;
      EXITS crash => completed ¬ FALSE;
      END;
      LogSpillEnded[half, spillName, completed, Behind[]];
      ENDLOOP;
    END;

  LogSpillEnded: PROC [half: SpillRequest, file: LONG STRING, ok, late: BOOLEAN] =
    BEGIN
    log: LONG STRING ¬ Heap.systemZone.NEW[StringBody[200]];
    String.AppendString[log, "Log "L];
    String.AppendString[log, IF ok THEN "spilled: ["L ELSE "spill failed: ["L];
    String.AppendString[log, server];
    String.AppendString[log, "]"L];
    String.AppendString[log, file];
    String.AppendString[log, IF half = first THEN ", first"L ELSE ", second"L];
    String.AppendString[log, " half"L];
    WriteLogEntry[log];
    IF late THEN WriteLogEntry["Started next spill request late"L];
    Heap.systemZone.FREE[@log];
    END;


  DoSpill: --EXTERNAL-- PROC [half: SpillRequest, currentCycle: [0..spillLimit)] =
    BEGIN
    fs: VMDefs.FileSystem = VMDefs.Login[ifs, server, myName, myPwd];
    spillName.length ¬ spillPrefix;
    String.AppendString[spillName, myName];
    FOR i: CARDINAL DECREASING IN [spillPrefix..spillName.length) DO
      IF spillName[i] = '. THEN {spillName.length ¬ i; EXIT} ENDLOOP;
    String.AppendChar[spillName, '-];
    IF currentCycle < 10 THEN String.AppendChar[spillName, '0];
    String.AppendDecimal[spillName, currentCycle];
    String.AppendString[spillName, "!1"L];
    BEGIN
    ENABLE UNWIND => VMDefs.Logout[fs];
    file: VMDefs.FileHandle ¬ VMDefs.OpenFile[
      system: fs, name: spillName, options: oldOrNew];
    from: VMDefs.Page ¬ NIL;
    BEGIN
    ENABLE UNWIND => VMDefs.AbandonFile[file];
    base: VMDefs.PageNumber = IF half = first THEN 0 ELSE halfPagesInLogFile;
    limit: VMDefs.PageNumber = base + halfPagesInLogFile;
    VMDefs.SetFileLength[file, [page: limit, byte: 0]];
    FOR p: VMDefs.PageNumber IN [base..limit) DO
      to: VMDefs.Page = VMDefs.UsePage[[file, p]];
      BEGIN
      ENABLE UNWIND => VMDefs.Release[to];
      from: VMDefs.Page ¬ VMDefs.ReadPage[[logFileHandle, p], 2];
      to­ ¬ from­;
      VMDefs.Release[from];  -- must be released first --
      VMDefs.MarkStart[to];
      --TEMP-- VMDefs.Wait[to];  -- avoid VM deadlock on connection failure --
      --? just how temp is this latter?  can it be removed in Klamath?
      END;  -- of enable unwind
      VMDefs.Release[to];
      ENDLOOP;
    VMDefs.CloseFile[file];
    END;
    END;
    VMDefs.Logout[fs];
    END;



  -- initialization procedure

  InitializeLog: ENTRY PROCEDURE =
    BEGIN
    AppendString[lastDay, "01-Jan-01 "L];  -- forces day to be logged on startup
    logFileHandle ¬ OpenFile[
      name: "GV.log"L, options: oldOrNew, cacheFraction: 0];
    SetFileLength[
      file: logFileHandle, position: Position[page: pagesInLogFile, byte: 0]];
    -- initialize "logSequence" --
    current.page ¬ 0;
    pageArray ¬ LOOPHOLE[ReadPage[
      addr: PageAddress[file: logFileHandle, page: 0], lookAhead: 0]];
    logSequence ¬ (LOOPHOLE[pageArray[0], CARDINAL]) MOD spillLimit;
    current.byte ¬ 1;
    -- search for endMarker --
    DO
      FOR i: CARDINAL IN [current.byte..pageByteSize) DO
        IF pageArray­[i] = endMarker THEN {current.byte ¬ i; GOTO found}; ENDLOOP;
      Release[LOOPHOLE[pageArray, VMDefs.Page]];
      current.page ¬ current.page + 1;
      IF current.page = pagesInLogFile THEN
        BEGIN
        -- no endMarker found: start at 0 and increment logSequence --
        current.page ¬ 0;
        GetCurrentLogPage[];
        EXIT
        END;
      GetCurrentLogPage[];
      REPEAT found => NULL;
      ENDLOOP;
    END;


  -- initialization code

  InitializeLog[];

  END.