DIRECTORY
Atom USING [ GetPName, GetProp, PutProp ],
Commander USING [ CommandProc, Register ], 
Convert USING [ RopeFromInt, IntFromRope ],
BasicTime USING [ Update, Now, GMT ],
GVNames USING [ AddForward, AuthenticateKey, CreateIndividual, Expand, ExpandInfo, GetConnect, Outcome, RemoveForward, RListHandle, SetConnect ],
IO,
Log USING [ CLog, CloseCLog, MakeCLog, RedoCLog, Report, WriteCLog ],
MBQueue USING [ Action, Create, DequeueAction, Flush, Queue, QueueClientAction ],
MBQueueImpl USING [ QueueObj ], -- I HATE OPAQUE TYPES!
Names,
NamesGV,
Process USING [ Detach --, Pause, SecondsToTicks-- ],
RefTab USING [ Create, EachPairAction, Fetch, GetSize, Pairs, Ref, Store ],
SymTab USING [ Create, EachPairAction, Fetch, Pairs, Ref, Store ],
Rope USING [ Cat, Concat, Find, Index, Length, ROPE, Substr ],
RPC USING [ EncryptionKey ]
;

NamesGVImpl: CEDAR MONITOR
IMPORTS Atom, BasicTime, Commander, Convert, GVNames, IO, Log, MBQueue, MBQueueImpl, Names, Process, RefTab, SymTab, Rope
EXPORTS NamesGV, MBQueue SHARES MBQueueImpl = {
OPEN IO;

Queue: TYPE = REF QueueObj;
QueueObj: PUBLIC TYPE = MBQueueImpl.QueueObj;
ROPE: TYPE= Names.ROPE;
larkRegistry: ROPE=".Lark";
Results: TYPE = {ok, notFound, error};
ModeNotFound: TYPE = { ok, create, error }; -- create not available
CacheBehavior: TYPE = { lookupAfter, lookupFirst, lookInCacheOnly };
Authenticity: TYPE = NamesGV.Authenticity; -- { unknown, authentic, bogus };
AttributeSeq: TYPE = NamesGV.AttributeSeq;
AttributeSeqRec: TYPE = NamesGV.AttributeSeqRec;

GVDetails: TYPE=REF GVDetailsR;
GVDetailsR: TYPE=RECORD [
rName: ROPE,
attributes: DetailsAttributes_NIL,
authenticity: Authenticity_unknown,

key: RPC.EncryptionKey_NULL,
valid: BOOL_FALSE,
canCreate: BOOL_FALSE, -- GetDetails can make one if it isn't there.
mustAuthenticate: BOOL_FALSE,

lastTimeValid: BasicTime.GMT,
recording: BOOL_FALSE, -- Attribute update is illegal while this is TRUE
dirty: BOOL_FALSE, -- Some attribute has been changed by the client
done: CONDITION
];

DetailsAttribute: TYPE = REF DetailsAttributeR;
DetailsAttributeR: TYPE = RECORD [
attributeValue: ROPE, -- NIL only when this attribute is being deleted.
formerValue: ROPE_NIL -- Non-NIL only when this attribute has changed.
];

DetailsCache: TYPE = SymTab.Ref;
DetailsAttributes: TYPE = RefTab.Ref;

gvCacheLog: Log.CLog _ NIL;
cacheMod: CARDINAL _ 37;
squawking: BOOL _ FALSE;
queuesEmpty: BOOL_TRUE;
queuesEmptyCond: CONDITION;
gvCacheVersion: ATOM _ $V1;
cache: DetailsCache_NIL;
cacheQueue: Queue;
refreshCacheQueue: Queue;

assumedValidInterval: INT _ 60; -- GV updates done elsewhere may take a minute, and two calls, to be noticed.
assumedValidIntervalAfterChange: INT _ 600; -- GV updates done elsewhere may take a minute, and two calls, to be noticed.  GV updates done elsewhere after a change here may take up to ten minutes to get noticed unless you explicitly flush the local cache.
realOldTime: BasicTime.GMT _ ValidUntil[-1];


GVGetAttribute: PUBLIC ENTRY PROC[rName: ROPE, attribute: ATOM, default: ROPE_NIL]
RETURNS [value: ROPE] = {
details: GVDetails _ GetGVDetails[rName].details;
detailsAttribute: DetailsAttribute;
IF ~details.valid THEN RETURN[default];
IF attribute=$dirty THEN RETURN[IF details.dirty THEN "TRUE" ELSE NIL];
IF details.attributes=NIL THEN RETURN[default];
detailsAttribute _ NARROW[details.attributes.Fetch[key: attribute].val];
IF detailsAttribute=NIL THEN RETURN[default];
RETURN[detailsAttribute.attributeValue];
};

GVSetAttribute: PUBLIC ENTRY PROC[rName: ROPE, attribute: ATOM, value: ROPE] = {
details: GVDetails _ GetGVDetails[rName: rName, mode: create].details;
detailsAttribute: DetailsAttribute;
IF ~details.valid THEN RETURN;
IF (~details.dirty) OR details.recording THEN
UNTIL queuesEmpty DO WAIT queuesEmptyCond; ENDLOOP; -- GVWait
IF details.recording THEN ERROR; -- Sanity check
details.dirty _ TRUE;
IF details.attributes # NIL THEN
detailsAttribute _ NARROW[details.attributes.Fetch[key: attribute].val];
IF detailsAttribute = NIL THEN StoreAttribute[details, attribute, value, NIL]
ELSE detailsAttribute.attributeValue _ value;
};

GVIsAuthenticated: PUBLIC ENTRY PROC[rName: ROPE]
RETURNS [authenticity: Authenticity] = {
details: GVDetails _ GetGVDetails[rName].details;
RETURN[details.authenticity];
};

GVAuthenticate: PUBLIC ENTRY PROC[rName: ROPE, key: RPC.EncryptionKey]
RETURNS [authenticity: Authenticity] = {
details: GVDetails _ GetGVDetails[rName: rName, mode: error, key: key, authenticate: TRUE].details;
RETURN[details.authenticity];
};

GVGetAttributeSeq: PUBLIC PROC [rName: ROPE, attribute: ATOM]
RETURNS [value: AttributeSeq] = {
attributeValue: ROPE _ GVGetAttribute[rName, attribute];
index: INT_0;
IF attributeValue = NIL THEN RETURN[NIL];
value _ NEW[AttributeSeqRec[10]];
WHILE index < attributeValue.Length[] DO
newIndex: INT _ attributeValue.Index[pos1: index, s2: ", "];
value[value.length].attributeValue _ attributeValue.Substr[index, newIndex-index];
value.length _ value.length+1;
index _ newIndex+2;
ENDLOOP;
};
GVSetAttributeSeq: PUBLIC PROC[rName: ROPE, attribute: ATOM, value: AttributeSeq] = {
attVal: ROPE_NIL;
FOR i: INT IN [0..value.length) DO
attVal _ Rope.Cat[attVal, value[i].attributeValue, ", "]; ENDLOOP;
IF attVal#NIL THEN attVal _ attVal.Substr[len: attVal.Length[]-2];
GVSetAttribute[rName, attribute, attVal];
};

GVGetAttributes: PUBLIC ENTRY PROC[rName: ROPE] RETURNS [value: AttributeSeq_NIL] = {
details: GVDetails _ GetGVDetails[rName: rName, mode: create].details;
len: CARDINAL;
i: CARDINAL_0;
GetEachAttribute: RefTab.EachPairAction = {
quit_FALSE;
value[i] _ [NARROW[key], NARROW[val, DetailsAttribute].attributeValue];
i_i+1;
};
IF ~details.valid THEN RETURN;
IF details.attributes#NIL THEN len _ details.attributes.GetSize[];
IF details.dirty THEN len_len+1;
IF len=0 THEN RETURN;
value _ NEW[AttributeSeqRec[len]];
value.length _ len;
[]_details.attributes.Pairs[GetEachAttribute];
IF details.dirty THEN value[len-1] _ [$dirty, "TRUE"];
};
GVWait: PUBLIC ENTRY PROC = {
UNTIL queuesEmpty DO WAIT queuesEmptyCond; ENDLOOP;
}; 

GVUpdate: PUBLIC ENTRY PROC[rName: ROPE] = {
SetGVDetails[GetGVDetails[rName, error].details];
};

GVUpdateAll: PUBLIC ENTRY PROC = {
UpdateEachRName: INTERNAL SymTab.EachPairAction = {
details: GVDetails _ NARROW[val];
IF details.dirty AND ~details.recording THEN
QueueAction[refreshCacheQueue, SetNewDetails, details];
quit_FALSE;
};
[]_SymTab.Pairs[cache, UpdateEachRName];
};

GVFlushCache: PUBLIC ENTRY PROC = {
GetGVCache[TRUE]; -- Old one fades into oblivion
};

GVSaveCache: PUBLIC ENTRY PROC = {
ros: IO.STREAM;
SaveEachRName: INTERNAL SymTab.EachPairAction = {
details: GVDetails _ NARROW[val];
SaveEachAttribute: RefTab.EachPairAction = {
attributeName: ATOM _ NARROW[key];
detailsAttribute: DetailsAttribute _ NARROW[val];
quit_FALSE;
ros.PutF["%s: %s\n",
rope[Atom.GetPName[attributeName]], rope[detailsAttribute.attributeValue]];
};
quit_FALSE;
ros _ IO.ROS[ros];
IF details.recording THEN
UNTIL queuesEmpty DO WAIT queuesEmptyCond; ENDLOOP; -- GVWait
IF ~details.valid OR details.authenticity=bogus THEN RETURN;
ros.PutF["rname: %s\n", rope[details.rName]];
IF details.authenticity = authentic THEN TRUSTED {
key: RPC.EncryptionKey _ details.key;
cardKey: LONG POINTER TO ARRAY[0..2) OF LONG CARDINAL = LOOPHOLE[LONG[@key]];
ros.PutF["key: %bB %bB\n", card[cardKey[0]], card[cardKey[1]]];
};
IF details.attributes#NIL THEN []_details.attributes.Pairs[SaveEachAttribute];
IF details.dirty THEN ros.PutRope["dirty: TRUE\n"];
ros.PutChar['\n];
Log.WriteCLog[gvCacheLog, IO.RopeFromROS[ros, FALSE]];
};
GetGVCache[FALSE];
gvCacheLog _ Log.MakeCLog["GVCacheLog.txt", RestoreEntry, TRUE, 3];
IF gvCacheLog=NIL THEN { Log.Report["GV:** Couldn't create GVCacheLog.txt", $System]; RETURN; };
ros _ IO.ROS[];
[]_cache.Pairs[SaveEachRName];
gvCacheLog_Log.CloseCLog[gvCacheLog];
ros.Close[];
};

GVRestoreCache: PUBLIC ENTRY PROC = {
GetGVCache[FALSE];
gvCacheLog _ Log.MakeCLog["GVCacheLog.txt", RestoreEntry, FALSE, 3];
IF gvCacheLog=NIL THEN { Log.Report["GV:** Couldn't find GVCacheLog.txt", $System]; RETURN; };
GetGVCache[TRUE]; -- Old one fades into oblivion
Log.RedoCLog[gvCacheLog];
gvCacheLog_Log.CloseCLog[gvCacheLog];
};



GetGVDetails: INTERNAL PROC[rName: ROPE, mode: ModeNotFound_ok, behavior: CacheBehavior_lookupAfter, authenticate: BOOL_FALSE, key: RPC.EncryptionKey_NULL] RETURNS [results: Results_ok, details: GVDetails_NIL] = TRUSTED {
GetGVCache[FALSE];
details _ NARROW[cache.Fetch[rName].val];
IF details=NIL AND behavior#lookInCacheOnly THEN
[]_cache.Store[rName, details _
NEW[GVDetailsR_[rName: rName, lastTimeValid: realOldTime]]];
details.mustAuthenticate _ details.mustAuthenticate OR authenticate;
IF authenticate THEN details.key _ key;
details.canCreate _ ~details.valid AND mode=create;
SELECT behavior FROM
lookupFirst => {
QueueAction[cacheQueue, LookupDetails, details];
WAIT details.done;
};
lookupAfter => {
dontKnow: BOOL = ~details.valid OR (details.mustAuthenticate AND 
(SELECT details.authenticity FROM unknown, perhaps=>TRUE, ENDCASE=>FALSE));
IF (details.mustAuthenticate AND dontKnow) OR
Names.GMTComp[BasicTime.Now[], details.lastTimeValid]=greater THEN {
details.lastTimeValid _ ValidUntil[assumedValidInterval];
QueueAction[
(IF dontKnow THEN cacheQueue ELSE refreshCacheQueue), LookupDetails, details];
IF dontKnow THEN WAIT details.done;
};
};
ENDCASE;
details.canCreate _ FALSE;
IF ~details.valid THEN RETURN[
IF mode=ok THEN notFound ELSE Report[notFound, notFound, details], details];
IF squawking THEN Log.Report[IO.PutFR["GV: Found %g", rope[rName]], $System];
};

SetGVDetails: INTERNAL PROC[details: GVDetails] = {
GetGVCache[FALSE];
IF details=NIL OR details.dirty = FALSE THEN RETURN;
details.lastTimeValid _ ValidUntil[assumedValidIntervalAfterChange];
details.recording _ TRUE;
QueueAction[refreshCacheQueue, SetNewDetails, details];
IF squawking THEN Log.Report[IO.PutFR["GV: Modified %g", rope[details.rName]], $System];
};

RestoreEntry: SAFE PROC[cLog: Log.CLog] = { -- DoCLog command procedure
logStream: IO.STREAM = cLog.logStream;
details: GVDetails;
DO
line: ROPE_ReadLine[logStream];
key: ATOM;
val: ROPE;
IF line=NIL OR line.Length[]=0 THEN RETURN;
[key, val] _ ParseAttribute[line];
SELECT key FROM
$rname => {
IF details#NIL THEN ERROR;
details _ NEW[GVDetailsR_[
rName: val, lastTimeValid: realOldTime, valid: TRUE, authenticity: perhaps]];
[]_cache.Store[key: val, val: details];
};
$key => TRUSTED {
keyStream: IO.STREAM _ IO.RIS[val];
key: RPC.EncryptionKey;
cardKey:LONG POINTER TO ARRAY[0..2) OF LONG CARDINAL = LOOPHOLE[LONG[@key]];
cardKey[0] _ IO.GetCard[keyStream];
cardKey[1] _ IO.GetCard[keyStream];
IF details=NIL THEN ERROR;
details.key _ key;
IO.Close[keyStream];
details.mustAuthenticate _ TRUE; details.authenticity _ authentic;
};
$dirty => TRUSTED {
IF details=NIL THEN ERROR;
details.dirty _ TRUE; -- inhibits GV refreshes!!!
};
NIL => ERROR; -- Didn't find a key!
ENDCASE => {
IF details=NIL THEN ERROR;
StoreAttribute[details, key, val, val];
};
ENDLOOP;
};

LookupDetails: SAFE PROC[reallyDetails: REF ANY] = TRUSTED {
details: GVDetails _ NARROW[reallyDetails];
authenticity: Authenticity_details.authenticity;
rName: ROPE = details.rName;
connect: ROPE;
expandInfo: GVNames.ExpandInfo _ [notFound []];
info, aInfo: GVNames.Outcome_notFound;
entries: GVNames.RListHandle_NIL;
valid: BOOL_FALSE;
RecordDetails: ENTRY PROC = CHECKED INLINE {
details.rName _ rName;
details.valid _ valid;
details.lastTimeValid _ ValidUntil[
IF details.canCreate AND details.valid THEN assumedValidIntervalAfterChange
ELSE assumedValidInterval];
details.authenticity _ authenticity;
details.canCreate _ FALSE;
ParseDetails[details, entries];
NOTIFY details.done;
};
IF details.dirty THEN {
IF squawking THEN Log.Report[IO.PutFR["GV:---Not seeking %g (dirty)", rope[rName]], $System];
RETURN;
};
IF squawking THEN Log.Report[IO.PutFR["GV:---Seeking %g", rope[rName]], $System];
[info, connect] _ GVNames.GetConnect[rName];
valid _ info=individual;
IF ~valid THEN 
IF info=notFound THEN info _ DoCreate[details, "MFLFLX"]
ELSE []_Report[info, error, details]
ELSE {
expandInfo _ GVNames.Expand[rName];
WITH expandInfo SELECT FROM
group => entries_members;
noChange, individual => NULL;
ENDCASE => []_Report[type, error, details];
};
IF connect#NIL THEN {
connect _ Rope.Concat["connect: ", connect];
IF entries=NIL THEN entries _ LIST[ connect ]
ELSE entries _ CONS[connect, entries];
};
IF valid AND (SELECT details.authenticity FROM
bogus, authentic, nonexistent => FALSE, unknown, perhaps =>TRUE, ENDCASE=>ERROR)
THEN
IF details.mustAuthenticate THEN {
IF squawking THEN
Log.Report[IO.PutFR["GV:---Authenticating %g", rope[rName]], $System];
SELECT (aInfo_GVNames.AuthenticateKey[rName, details.key]) FROM
badPwd => authenticity_bogus; 
individual => authenticity_authentic;
ENDCASE => []_Report[aInfo, error, details];
}
ELSE authenticity _ perhaps;
IF info=notFound THEN authenticity _ nonexistent;
RecordDetails[];
IF squawking THEN Log.Report[IO.PutFR["GV:---End %g", rope[rName]], $System];
};

SetNewDetails: SAFE PROC[reallyDetails: REF ANY] = TRUSTED {
details: GVDetails _ NARROW[reallyDetails];
outcome: GVNames.Outcome;
somethingStillDirty: BOOL_FALSE;
EachAttribute: RefTab.EachPairAction = TRUSTED {
attribute: DetailsAttribute _ NARROW[val];
attributeName: ATOM _ NARROW[key];
quit_FALSE;
IF attribute.attributeValue=attribute.formerValue THEN RETURN; 
IF attributeName=$connect THEN {
outcome _ GVNames.SetConnect[
user: Names.CurrentRName[], password: Names.CurrentPasskey[],
individual: details.rName, connect: attribute.attributeValue];
SELECT outcome FROM
noChange, individual => attribute.formerValue _ attribute.attributeValue;
ENDCASE=> {
[]_Report[outcome, error, details, TRUE];
somethingStillDirty _ TRUE;
RETURN; };
};
IF attribute.formerValue # NIL THEN {
oldFwd: ROPE_ Atom.GetPName[attributeName].Cat[": ", attribute.formerValue];
outcome _ GVNames.RemoveForward[
user: Names.CurrentRName[], password: Names.CurrentPasskey[],
individual: details.rName, dest: oldFwd];
SELECT outcome FROM
noChange, individual => attribute.formerValue _ NIL;
ENDCASE=> {
[]_Report[outcome, error, details, TRUE];
somethingStillDirty _ TRUE;
RETURN; };
};
IF attribute.attributeValue # NIL THEN {
newFwd: ROPE_ Atom.GetPName[NARROW[key]].Cat[": ", attribute.attributeValue];
outcome _ GVNames.AddForward[
user: Names.CurrentRName[], password: Names.CurrentPasskey[],
individual: details.rName, dest: newFwd];
SELECT outcome FROM
noChange, individual => attribute.formerValue _ attribute.attributeValue;
ENDCASE=> {
[]_Report[outcome, error, details, TRUE]; 
somethingStillDirty _ TRUE;
RETURN; };
};
};
{
ENABLE UNWIND => details.recording _ FALSE;
IF squawking THEN
Log.Report[IO.PutFR["GV:---Change attributes for %g", rope[details.rName]], $System];
IF details.attributes # NIL THEN []_RefTab.Pairs[details.attributes, EachAttribute];
details.recording _ FALSE;
details.dirty _ somethingStillDirty;
IF squawking THEN Log.Report["GV:---End update", $System];
};
};

DoCreate: PROC[details: GVDetails, password: ROPE] RETURNS [info: GVNames.Outcome] = TRUSTED {
IF ~details.canCreate THEN RETURN[notFound];
IF squawking THEN
Log.Report[IO.PutFR["GV:---Creating %g", rope[details.rName]], $System];
info _ GVNames.CreateIndividual[
user: Names.CurrentRName[], password: Names.CurrentPasskey[],
individual: details.rName, newPwd: Names.CurrentPasskey[password]];
SELECT info FROM
individual => NULL;
ENDCASE => []_Report[info, error];
};

ParseDetails: PROC[details: GVDetails, entries: GVNames.RListHandle] = {
attributeTable: RefTab.Ref_NIL;
details.attributes_NIL;
IF ~details.valid THEN RETURN;
FOR e: GVNames.RListHandle _ entries, e.rest WHILE e#NIL DO
key: ATOM;
val: ROPE;
[key, val] _ ParseAttribute[e.first];
IF key=NIL THEN LOOP; -- Not the right syntax for an entry
StoreAttribute[details, key, val, val];
ENDLOOP;
};

ParseAttribute: PROC[attributeSpec: ROPE] RETURNS [key: ATOM_NIL, val: ROPE_NIL] = {
index: INT _ attributeSpec.Find[": "];
IF index<0 THEN RETURN; -- Not the right syntax for an entry
key _ Names.MakeAtom[rName: attributeSpec.Substr[start: 0, len: index], case: FALSE];
val _ attributeSpec.Substr[start: index+2];
};

StoreAttribute: PROC[details: GVDetails, key: ATOM, val: ROPE, oldVal: ROPE] = {
detailsAttribute: DetailsAttribute _ NEW[DetailsAttributeR _ [val, oldVal]];
IF details.attributes = NIL THEN details.attributes _ RefTab.Create[];
[] _ details.attributes.Store[key: key, val: detailsAttribute];
};


QueueAction: INTERNAL PROC [q: MBQueue.Queue, proc: PROC [REF ANY], data: REF ANY] = {
queuesEmpty_FALSE;
MBQueue.QueueClientAction[q, proc, data];
IF q=cacheQueue THEN MBQueue.QueueClientAction[refreshCacheQueue, Arise, NIL];
};
Arise: SAFE PROC [whatever: REF] = { NULL };

MBQueueEmpty: ENTRY PROC[q: Queue, notifyIfEmpty: BOOL_FALSE]
RETURNS [empty: BOOL] = {
empty _ q.firstEvent=NIL;
IF ~empty OR ~notifyIfEmpty THEN RETURN;
queuesEmpty_TRUE;
NOTIFY queuesEmptyCond;
};

Action: TYPE = MBQueue.Action;
Notifier: PROC [] = {
DO
ENABLE ABORTED => {
MBQueue.Flush[cacheQueue]; MBQueue.Flush[refreshCacheQueue]; LOOP; };
UNTIL MBQueueEmpty[cacheQueue] DO
WITH MBQueue.DequeueAction[cacheQueue] SELECT FROM
e2: Action.client => { queuesEmpty_FALSE; e2.proc[e2.data]; };
ENDCASE => ERROR;
ENDLOOP;
[] _ MBQueueEmpty[refreshCacheQueue, TRUE]; -- if TRUE, about to wait
WITH MBQueue.DequeueAction[refreshCacheQueue] SELECT FROM
e2: Action.client => { queuesEmpty_FALSE; e2.proc[e2.data]; };
ENDCASE => ERROR;
ENDLOOP;
};
SemiTok: IO.BreakProc = TRUSTED {RETURN[IF char='; THEN break ELSE other]; };
CommaTok: IO.BreakProc = TRUSTED {RETURN[IF char=', THEN break ELSE other]; };

Report: PROC[outcome: GVNames.Outcome, r: Results, details: GVDetails_NIL, timeout: BOOL_FALSE]
RETURNS[rr: Results] = {
rName: ROPE_NIL;
rr_r;
IF details#NIL THEN {
details.valid_FALSE; rName_details.rName; 
IF timeout THEN details.lastTimeValid _ realOldTime; -- next query will go to GV fer sherr
};
Log.Report[IO.PutFR["GV: **%s %s\n", rope[rName], rope[SELECT outcome FROM
noChange => "no change",
group => "group",
individual => "individual",
notFound => "not found",
protocolError => "protocol error",
wrongServer => "wrong server",
allDown => "all servers down",
badPwd => "bad password",
outOfDate => "out of date",
notAllowed => "not allowed",
ENDCASE => "??"]], $System]; };
ValidUntil: PROC[interval: INT] RETURNS [BasicTime.GMT] = { 
RETURN[BasicTime.Update[BasicTime.Now[], interval]];
};

GetGVCache: INTERNAL PROC[new: BOOL_FALSE] = {
cRef: REF DetailsCache _ NIL;
cache_NIL;
DO
ref: REF _ Atom.GetProp[$GVCache, gvCacheVersion];
IF ref=NIL THEN EXIT;
WITH ref SELECT FROM
cRef1: REF DetailsCache => { cRef_cRef1; EXIT; };
ENDCASE;
gvCacheVersion _ Names.MakeAtom[
rName: Rope.Cat["V",
Convert.RopeFromInt[
Convert.IntFromRope[
Rope.Substr[ Atom.GetPName[gvCacheVersion], 1]
]+1
]
],
case: TRUE
];
ENDLOOP;
IF ~new AND cRef#NIL THEN { cache _ cRef^; RETURN};
cache _ SymTab.Create[cacheMod, FALSE];
Atom.PutProp[$GVCache, gvCacheVersion, NEW[DetailsCache _ cache]];
};


CmdSaveGVCache: Commander.CommandProc = {
GVSaveCache[];
};

CmdRestoreGVCache: Commander.CommandProc = {
GVRestoreCache[];
};

CmdRefreshGVCache: ENTRY Commander.CommandProc = {
RefreshEachRName: INTERNAL SymTab.EachPairAction = {
details: GVDetails _ NARROW[val];
quit_FALSE;
IF ~details.dirty THEN QueueAction[refreshCacheQueue, LookupDetails, details];
};
[]_SymTab.Pairs[cache, RefreshEachRName];
};

CmdUpdateGVCache: Commander.CommandProc = {
GVUpdateAll[];
};

CmdFlushGVCache: Commander.CommandProc = {
GVFlushCache[];
};

CmdWaitForGV: Commander.CommandProc = {
GVWait[];
};

CmdGVSquawk: Commander.CommandProc = {
squawking _ ~squawking;
Log.Report[IO.PutFR["Squawking[%g]", bool[squawking]], $System];
};



ReadLine: PROC[s: IO.STREAM] RETURNS [ line: ROPE] = { RETURN[s.GetLineRope[]]; };

cacheQueue _ MBQueue.Create[pushModel: FALSE];
refreshCacheQueue _ MBQueue.Create[pushModel: FALSE];
TRUSTED { Process.Detach[FORK Notifier[]]; };
Commander.Register["GVFlushCache", CmdFlushGVCache, "Flush GV Cache"];
Commander.Register["GVSaveCache", CmdSaveGVCache, "Save GV Cache"];
Commander.Register["GVRestoreCache", CmdRestoreGVCache, "Restore GV Cache"];
Commander.Register["GVRefreshCache", CmdRefreshGVCache,
"Refresh all GV Cache entries from GV"];
Commander.Register["GVUpdateCache", CmdUpdateGVCache,
"Write all dirty cache entries to GV"];
Commander.Register["GVWait", CmdWaitForGV, "Wait for GV communications to complete"];
Commander.Register["GVSquawk", CmdGVSquawk, "Inform user of GV activity"];
}.

XNamesGVImpl.Mesa
Last modified by Swinehart, July 19, 1984 10:37:40 am PDT
Last Edited by: Pier, May 20, 1984 7:08:08 pm PDT
Data

GV Procedures exported to Names


The following nonsense truncates the log file before beginning to write.

GV Utilities
DontKnow: cached copy doesn't exist, is incorrect, or is incomplete.
At most one refresh try per interval
Queued GV Utilities

Special case: connect attribute is really RName's connect field.
GV Utilities Utilities
Derived from MBQueueImpl.Notifier; runs all the time.
Exhaust cacheQueue before considering entries on refreshCacheQueue.
When cacheQueue operations are queued, dummy refresh operations are, too, to wake us up.

timeout=TRUE means that next attempt to fetch info about this RName consult Grapevine right away


All copies of the same version of Names on same machine get the same cache!!
Different versions jockey for position among the gvCacheVersion entries.
A cache is a SymTab.Ref, which is opaque, which means that a REF ANY containing one can't be narrowed, so it's stored inside another REF.  Sigh.
GV user commands
Initialization

�ÊȘJš
œ™Jš
œ9™9J™1J˜š
Ïk	˜	Jšœ�œ ˜*Jšœ
�œ˜+J˜+Jšœ
�œ�œ˜%Jšœ�œ„
˜‘
Jš�œ
˜Jšœ�œ<˜EJšœ�œD˜QJšÏbÐbkžÐbc˜7J˜J˜J˜5Jšœ�œ?˜KJšœ�œ6˜BJšœ�œ%�œ	˜>J˜J˜
J˜—šœ
�œ
�˜Jš�œ/�œž
œ$˜yš�œž
Ÿœ
žœ˜/Jš�œ
�œ
˜J˜——™J™JšžŸžŸž
˜Jšž
Ÿž
Ÿž˜-Jš�œ�œ�œ
˜Jšœ�œ	˜J˜&Jšœ�œÏc˜CJšœ�œ1˜DJšœ�œ¡!˜LJšœ�œ˜*Jšœ�œ˜0J˜Jšœ�œ
�œ˜šœ�œ
�œ˜Jšœ�œ
˜Jšœ�œ
˜"Jš
œ#˜#J˜Jšœ�œ�œ
˜Jšœ�œ
�˜Jšœ�œ
�œ¡-˜DJšœ�œ
�œ
˜J˜Jšœ�œ
˜Jšœ�œ
�œ¡1˜HJšœ�œ
�œ¡0˜CJšœ�	˜J˜—J˜Jšœ�œ�œ˜/šœ�œ�œ˜"Jšœ�œ¡1˜GJšœ
�œ
�œ
¡0˜FJ˜J˜—Jšœ�œ˜ Jšœ�œ˜%J˜Jšœ�œ
˜Jšœ
�œ˜Jšœ�œ�œ
˜Jšœ
�œ
�œ
˜Jšœ�	œ
˜Jšœ�œ˜Jšœ�œ
˜Jš
œ˜Jš
œ˜J˜Jšœ�œ¡M˜mJšœ!�œ¡Ó
˜ÿ
Jš
œ,˜,J˜—J™˜šÏnœ�œ
�œ
�œ�œ
�œ�œ
�œ
˜RJš�œ	�œ˜J˜1J˜#Jš�œ�œ
�œ
˜'Jš�œ�œ
�œ
�œ�œ�œ
�œ˜GJš�œ�œ
�œ
�œ
˜/Jšœ�œ/˜HJš�œ�œ
�œ
�œ
˜-Jš�œ"˜(J˜J˜—š¢œ�œ
�œ
�œ�œ
�œ	�œ˜PJ˜FJ˜#Jš�œ�œ
�œ
˜š�œ�œ�˜-Jš	�œ
�œ
�œ�œ¡	˜=—Jš�œ�œ
�œ¡˜0Jšœ�œ
˜š�œ�œ
�˜ Jšœ�œ/˜H—Jš�œ�œ
�œ+�œ
˜MJš�œ)˜-J˜J˜—š
¢œ�œ
�œ
�œ�œ
˜1Jš�œ!˜(J˜1Jš�œ˜J˜J˜—š¢œ�œ
�œ
�œ�œ�œ˜FJš�œ!˜(JšœU�œ
˜cJš�œ˜J˜J˜—š
¢œ�œ
�œ	�œ
�œ
˜=Jš�œ˜!Jšœ�œ$˜8Jšœ�œ˜
Jš
�œ�œ
�œ
�œ
�œ˜)Jšœ�œ˜!š�œ!�˜(Jšœ
�œ/˜<Jš
œR˜RJ˜J˜Jš�œ
˜—J˜J™—š
¢œ�œ
�œ�œ
�œ˜UJšœ�œ
�œ
˜š�œ�œ
�œ�˜"Jšœ:�œ
˜B—Jš�œ�œ
�œ0˜BJ˜)J˜J˜—š¢œ�œ
�œ
�œ�œ�œ�œ˜UJ˜FJšœ�œ
˜Jšœ�œ˜˜+Jšœ�œ
˜Jšœ�œ�œ(˜GJ˜J˜—Jš�œ�œ
�œ
˜Jš�œ�œ
�œ$˜BJš�œ�œ˜ Jš�œ�œ
�œ
˜Jšœ�œ˜"J˜J˜.Jš�œ�œ!˜6J˜J™—š¢œ�œ
�
œ˜Jš�œ
�œ
�œ�œ
˜3J˜—J˜š
¢œ�œ
�œ
�œ�œ˜,Jš
œ1˜1Jš
œ˜—J˜š¢œ�œ
�œ
�œ˜"šœ�œ˜3Jšœ�œ˜!š�œ�œ�˜,Jšœ�
œ˜7—Jšœ�œ
˜J˜—Jš
œ(˜(Jš
œ˜J˜—š¢œ�œ
�œ
�œ˜#Jšœ�œ¡˜0Jš
œ˜—J˜Jš¢œ�œ
�œ
�œ˜"™HJšœ�œ
�œ
˜šœ�œ˜1Jšœ�œ˜!š¢œ˜,Jšœ�œ�œ˜"Jšœ%�œ˜1Jšœ�œ
˜˜J˜K—J˜—Jšœ�œ
˜Jšœ�œ
�œ˜š�œ�˜Jš	�œ
�œ
�œ�œ¡	˜=—Jš�œ�œ�œ
�œ
˜<J˜-š�œ"�œ
�œ˜2Jš
œ%˜%Jšœ	�œ
�œ
�œ
�œ�œ
�œ
�œ�œ
�œ˜MJš
œ?˜?J˜—Jš�œ�œ
�œ0˜NJš�œ�œ˜3J˜Jšœ�œ�œ˜6J˜—Jšœ�œ˜Jšœ:�œ˜CJš�œ�œ
�œ@�œ˜`Jšœ�œ
�œ˜Jš
œ˜Jš
œ%˜%J˜J˜—J˜š¢œ�œ
�œ
�œ˜%Jšœ�œ˜Jšœ:�œ˜DJš�œ�œ
�œ>�œ˜^Jšœ�œ¡˜0J˜Jš
œ%˜%J˜J˜—J˜—J™J™˜š¢œ�œ
�œ�œL�œ
�œ�œ�œ�œ*�œ�œ˜Ý
Jšœ�œ˜Jšœ
�œ˜)š�œ	�œ
�œ�˜0š
œ˜Jš�œ9˜<——Jšœ4�œ˜DJš�œ�œ˜'Jšœ#�œ
˜3š�œ
�˜š
œ˜Jš
œ0˜0Jš�œ˜J˜—š
œ˜šœ
�œ�œ�œ
˜AJšœ
�œ�œ�œ�œ�œ˜K—š�œ�œ�˜-šœ>�œ˜DJ™D—Jš
œ9˜9Jšœ
¡#™$š
œ˜Jšœ
�œ
�œ�œ-˜N—Jš�œ
�œ
�œ˜#J˜—J˜—Jš�œ
˜—Jšœ�œ
˜š�œ�œ
�œ
˜Jš�œ	�œ	�œ/˜L—Jš�œ�œ�œ.˜MJ˜——˜š¢œ�
œ˜3Jšœ�œ˜Jš�œ	�œ
�œ�œ
�œ
�œ
˜4J˜DJšœ�œ
˜J˜7Jš�œ�œ�œ9˜XJ˜J˜—š¢œ�œ
�œ¡˜GJšœ�œ
�œ˜&J˜š
�˜Jšœ�œ˜Jšœ�œ
˜
Jšœ�œ
˜
Jš
�œ�œ
�œ�œ
�œ
˜+J˜"š�œ�˜˜Jš�œ	�œ
�œ
�œ
˜šœ
�œ
˜Jšœ/�œ˜M—J˜'J˜—šœ�œ˜Jš	œ�œ
�œ�œ
�œ˜#Jšœ�œ˜Jšœ�œ
�œ
�œ
�œ�œ
�œ
�œ�œ
�œ˜LJšœ
�œ˜#Jšœ
�œ˜#Jš�œ	�œ
�œ
�œ
˜J˜Jš�œ˜Jšœ�œ#˜BJ˜—šœ
�œ˜Jš�œ	�œ
�œ
�œ
˜Jšœ�œ˜1J˜—Jš�œ�œ¡˜#š�œ˜Jš�œ	�œ
�œ
�œ
˜Jš
œ'˜'J˜——Jš�œ
˜—J˜——J˜J™™š¢
œ�œ
�œ�œ
�œ�œ˜<Jšœ�œ˜+Jš
œ0˜0Jšœ�œ˜Jšœ	�œ
˜J˜/J˜&Jšœ�œ
˜!Jšœ�œ
�˜š¢
œ�œ
�œ�œ˜,Jš
œ˜Jš
œ˜š
œ#˜#Jš�œ�œ�œ ˜KJš�œ˜—J˜$Jšœ�œ
˜J˜Jš�œ˜J˜—š�œ�œ˜Jš�œ�œ�œ>˜]Jš�œ
˜J˜—Jš�œ�œ�œ2˜QJ˜,Jš
œ˜š�œ�œ
˜Jš�œ�œ#˜8Jš�œ ˜$—š�œ˜Jš
œ#˜#š�œ�˜Jš
œ˜Jšœ�œ
˜Jš�œ$˜+—J˜—š�œ	�œ
�œ˜J˜,Jš�œ	�œ
�œ�œ˜-Jš�œ�œ˜&J˜—š�œ�œ�œ�˜.Jš	œ!�œ�œ�œ�œ
˜PJš
�˜š�œ�œ˜"š�œ�˜Jšœ�œ9˜F—š�œ5�˜?Jš
œ˜Jš
œ%˜%Jš�œ%˜,—J˜
—Jš�œ˜—Jš�œ�œ˜1Jš
œ˜Jš�œ�œ�œ.˜MJ˜——˜š¢
œ�œ
�œ�œ
�œ�œ˜<Jšœ�œ˜+J˜Jšœ�œ
�œ
˜ šœ'�œ˜0Jšœ�œ˜*Jšœ�œ�œ˜"Jšœ�œ
˜Jš�œ0�œ
�œ˜?J™@š�œ�œ˜ ˜˜=Jš
œ>˜>——š�œ	�˜Jš
œI˜Iš�œ˜Jšœ#�œ˜)Jšœ�œ
˜Jš�œ˜
——J˜—š�œ�œ
�œ˜%Jšœ�œ@˜Lš
œ ˜ ˜=Jš
œ)˜)——š�œ	�˜Jšœ0�œ
˜4š�œ˜Jšœ#�œ˜)Jšœ�œ
˜Jš�œ˜
——J˜—š�œ�œ
�œ˜(Jšœ�œ�œ+˜Mš
œ˜˜=Jš
œ)˜)——š�œ	�˜Jš
œI˜Iš�œ˜Jšœ#�œ˜*Jšœ�œ
˜Jš�œ˜
——J˜—J˜—š
œ
˜
Jš�œ
�œ�œ
˜+š�œ�˜Jšœ�œH˜U—Jš�œ�œ
�œ4˜TJšœ�œ
˜Jš
œ$˜$Jš�œ�œ)˜:J˜—J˜J˜—š
¢œ�œ�œ�œ�œ˜^Jš�œ�œ
�œ˜,š�œ�˜Jšœ�œ;˜H—š
œ ˜ Jš
œ=˜=Jš
œC˜C—š�œ�˜Jšœ�œ
˜Jš�œ˜"—Jš
œ˜——˜š¢œ�œ6˜HJšœ�œ
˜Jšœ�œ
˜Jš�œ�œ
�œ
˜š�œ*�œ�œ
�˜;Jšœ�œ
˜
Jšœ�œ
˜
J˜%Jš	�œ�œ
�œ
�œ¡$˜:J˜'Jš�œ
˜—J˜J˜—š¢œ�œ�œ�œ�œ
�œ�œ
�œ˜TJšœ�œ˜&Jš�œ	�œ
�œ¡$˜<JšœN�œ˜UJš
œ+˜+J˜—J˜š
¢œ�œ�œ�œ
�œ˜PJšœ%�œ$˜LJš�œ�œ
�œ&˜FJš
œ?˜?J˜J˜——™J˜š¢œ�
œ�œ�œ
�œ	�œ
�œ˜VJšœ�œ
˜J˜)Jš�œ�œ5�œ˜NJ˜—Jš
¢œ�œ
�œ�œ�œ˜,J˜š
¢œ�œ
�œ�œ
�œ
˜=Jš�œ	�œ˜J˜Jš�œ�œ�œ
�œ
˜(Jšœ�œ
˜Jš�œ˜J˜—J˜Jšœ�œ˜š¢œ�œ˜J™5J™CJ™Xš
�˜š�œ
�œ˜Jšœ=�œ˜E—š�œ�˜!š�œ#�œ
�˜2Jšœ#�œ˜>Jš�œ�œ
˜—Jš�œ
˜—Jšœ%�œ¡˜Eš�œ*�œ
�˜9Jšœ#�œ˜>Jš�œ�œ
˜—Jš�œ
˜—Jš
œ˜—J™Jš
œ	�œ
�œ�œ
�œ	�œ�œ˜MJš
œ
�œ
�œ�œ
�œ	�œ�œ˜NJ˜š
¢œ�œ:�œ�œ
�œ
˜_Jšœ�œT™`Jš�œ˜Jšœ�œ
�œ
˜J˜š�œ	�œ
�œ˜Jšœ�œ˜*Jš�œ	�œ&¡%˜ZJš
œ˜—šœ7�œ	�˜JJ˜J˜J˜J˜J˜"J˜J˜J˜J˜J˜Jš�œ˜——J™š¢
œ�œ�œ�œ˜<Jš�œ.˜4J˜——˜J™š¢
œ�
œ�œ
�œ˜.J™LJ™HJ™�
Jšœ�œ�œ
˜Jšœ�œ
˜
š
�˜Jšœ�œ*˜2Jš�œ�œ
�œ
�œ
˜š�œ�œ
�˜Jšœ�œ�œ˜1Jš�œ
˜—˜ ˜˜˜J˜.J˜—J˜
—J˜—Jšœ�˜
J˜—Jš�œ
˜—Jš
�œ�œ�œ
�œ�œ˜3Jšœ �œ˜'Jšœ'�œ˜BJ˜——J˜™J˜š¢œ˜)Jš
œ˜Jš
œ˜—J˜š¢œ˜,Jš
œ˜Jš
œ˜—J˜šœ�œ˜2šœ�œ˜4Jšœ�œ˜!Jšœ�œ
˜Jš�œ�œ8˜NJ˜—Jš
œ)˜)Jš
œ˜J˜—š¢œ˜+Jš
œ˜Jš
œ˜J˜—š¢œ˜*Jš
œ˜Jš
œ˜—J˜š¢œ˜'Jš
œ	˜	Jš
œ˜—J˜š¢œ˜&Jš
œ˜J˜@Jš
œ˜J˜——J˜J˜š¢œ�œ�œ
�œ�œ	�œ�œ˜RJ˜—™J™Jšœ'�œ˜.Jšœ.�œ˜5Jš�œ�œ˜-J˜FJ˜CJ˜L˜7J˜(—˜5J˜'—J˜UJ˜J—J˜J˜—…—PlmŒ