DIRECTORY
BasicTime USING [ Now, Period ],
LarkPlay USING [ MergeToneSpecs, ToneSpec, ToneSpecRec ],
Process USING [ Detach, EnableAborts, SecondsToTicks, SetTimeout ],
Log USING [ ProblemBool, SLOG ],
RPC USING [ CallFailed ],
SafeStorage USING [ GetCanonicalType, Type ],
ThNet USING [ pd ],
ThParty USING [ Deregister, SetRingEnable ],
ThPartyMonitorImpl,
ThPartyPrivate USING [
CFRef, ConversationBody, ConversationData, DehandleConv, DehandleParty, DestroyConversation, Distribute, DistributionProc, FindOtherParty, GetEvent, PartyBody, PartyData, RingMethod, outsideRingTune, recordingRAtom, Verify ],
Thrush USING [ ConversationHandle, ConvEvent, Credentials, Disposition, EventSequence, EventSequenceBody, H, HandleFault, KillHandle, MakeUnique, NB, PartyHandle, Priorities, SHHH, StateID, ThHandle ],
Triples USING [ Any, Erase, Foreach, ForeachProc, Select ]
;

ThPartySupervisorImpl: CEDAR MONITOR LOCKS root
IMPORTS
BasicTime,
LarkPlay,
Log,
Process,
root: ThPartyMonitorImpl,
RPC,
SafeStorage,
--SpyLog,--
ThNet,
Thrush,
ThParty,
ThPartyPrivate,
Triples
EXPORTS ThPartyPrivate
SHARES ThPartyMonitorImpl = {

CFRef: TYPE = ThPartyPrivate.CFRef;
ConversationData: TYPE = ThPartyPrivate.ConversationData;
RTConvType: SafeStorage.Type = SafeStorage.GetCanonicalType[CODE[ThPartyPrivate.ConversationBody]];
ConvEvent: TYPE = Thrush.ConvEvent;
Credentials: TYPE = Thrush.Credentials;
H: PROC[r: REF] RETURNS [Thrush.ThHandle] = INLINE { RETURN[LOOPHOLE[Thrush.H[r]]]; };
NB: TYPE = Thrush.NB;
PartyData: TYPE = ThPartyPrivate.PartyData;
RTPartyType: SafeStorage.Type = SafeStorage.GetCanonicalType[CODE[ThPartyPrivate.PartyBody]];
StateID: TYPE = Thrush.StateID;

maxSpvrInterval: NAT _ 10;
ringTuneDelay: NAT _ 2400; -- ms. delay between tune starts.

Supervisor: PUBLIC PROC[ party: PartyData ] = {
event: ConvEvent;
toDo, failing, latest: BOOL_FALSE;
informationOnly: BOOLEAN_FALSE;

Inform: ThPartyPrivate.DistributionProc = {
ENABLE RPC.CallFailed => {
smarts.canProgress_FALSE;
ThParty.Deregister[smartsID: H[smarts]];
RETRY; };
yourParty: BOOL = event.credentials.partyID=H[party];
d_pass;
IF ~smarts.canProgress THEN RETURN; 
IF event.keyTable=NIL AND event.intervalSpecs=NIL AND
(NOT yourParty) AND (event.state#initiating) THEN RETURN; -- don't report uninteresting events 
IF yourParty AND smarts.properties.role=voiceTerminal THEN
SetupRingTunes[event];
SELECT (d _ smarts.interface.Progress[shh: smarts.shh, smartsID: H[smarts],
informationOnly: informationOnly, yourParty: yourParty,
event: event, latestEvent: latest ]) FROM
actedAndPass  => informationOnly_TRUE;
willAlwaysPassThisRequest  => smarts.canProgress_FALSE;
ENDCASE; 
event.ringTune _ NIL;
};

TRUSTED {
Process.EnableAborts[@party.actionNeeded];
Process.SetTimeout[@party.actionNeeded, Process.SecondsToTicks[maxSpvrInterval]];
};
DO
ENABLE ABORTED => CONTINUE;
[ event, toDo, latest ] _ ScanPostOrWait[party];
informationOnly _ FALSE;
IF toDo THEN []_ThPartyPrivate.Distribute[party: party, proc: Inform]
ELSE IF failing THEN EXIT
ELSE IF party.partyFailed THEN failing_TRUE -- one more pass to clean up!
ELSE IF party.supervisor=NIL THEN RETURN; -- vanish to keep local frames to minimum.
ENDLOOP;
EndParty[party];
};

Supervise: PUBLIC INTERNAL PROC[party: PartyData] =  TRUSTED {
IF party.supervisor=NIL THEN
Process.Detach[party.supervisor _ FORK Supervisor[party]];
NOTIFY party.actionNeeded; -- Spurious if process just spawned?
};

ScanPostOrWait: ENTRY PROC[ party: PartyData ]
RETURNS [ event: ConvEvent, toDo: BOOL_FALSE, latest: BOOL ] = {
ENABLE UNWIND => NULL;
Scanner: INTERNAL Triples.ForeachProc = TRUSTED {
conv: ConversationData;
WITH trip.att SELECT FROM
r: CFRef => {
cfRef: CFRef_NIL;
conv _ NARROW[trip.obj];
IF r.lastNotedID<conv.currentStateID THEN cfRef _ r
ELSE IF r.event.state=idle THEN Dissolve[r, conv, party];
IF cfRef#NIL THEN {
cfRef.lastNotedID _ cfRef.lastNotedID+1;
toDo_TRUE;
latest _
cfRef.lastNotedID = conv.currentStateID OR cfRef.lastNotedID = cfRef.lastPostedID;
event _ ThPartyPrivate.GetEvent[conv, cfRef.lastNotedID];
Log.SLOG[];
RETURN[FALSE];
};
};
ENDCASE;
};
Triples.Foreach[Triples.Any, Triples.Any, party, Scanner];
IF ~toDo AND ~party.partyFailed THEN
IF party.numConvs=0 THEN party.supervisor_NIL ELSE WAIT party.actionNeeded;
};

Distribute: PUBLIC PROC[ party: PartyData, proc: ThPartyPrivate.DistributionProc ]
RETURNS [ d: Thrush.Disposition_pass ] = {
priorities: Thrush.Priorities;
IF party = NIL THEN RETURN[pass];
priorities _ NARROW[Triples.Select[$Priorities, party, -- priorities -- ]];
FOR priorities: Thrush.Priorities _ NARROW[Triples.Select[$Priorities, party, --priorities--]], priorities.rest
WHILE priorities#NIL DO
FOR subpriorities: Thrush.Priorities _ NARROW[priorities.first], subpriorities.rest
WHILE subpriorities#NIL DO
priority: ATOM _ NARROW[subpriorities.first];
DistOne: Triples.ForeachProc = {
d _ proc[smarts: NARROW[trip.val]];
SELECT d FROM
actedAndStop => RETURN[FALSE];
actedAndPass, pass, willAlwaysPassThisRequest => RETURN[TRUE];
ENDCASE=> RETURN[Log.ProblemBool[
remark: "Invalid distribute return code", where: $System, bool: TRUE]];
};
Triples.Foreach[priority, party, Triples.Any, DistOne];
IF d=actedAndStop THEN RETURN; ENDLOOP; ENDLOOP; };


Dissolve: INTERNAL PROC[cfRef: CFRef, conv: ConversationData, party: PartyData] = {
IF cfRef.event.state#idle THEN RETURN;
Triples.Erase[cfRef, conv, party];
conv.numParties _ conv.numParties-1;
party.numConvs _ party.numConvs-1;
IF conv.numParties=0 THEN ThPartyPrivate.DestroyConversation[conv];
TRUSTED { WITH p: party SELECT FROM
trunk => { p.outgoing _ NIL; Triples.Erase[$RnameForTrunk, party, Triples.Any]; };
recording => Thrush.MakeUnique[$RnameForParty, party, ThPartyPrivate.recordingRAtom];
ENDCASE;
};
};

EndParty: ENTRY PROC[party: PartyData] = {
Thrush.KillHandle[H[party], RTPartyType!Thrush.HandleFault=>CONTINUE];
Triples.Erase[Triples.Any, party, Triples.Any];
party.supervisor _ NIL;
};

GetHistory: PUBLIC ENTRY PROC[
shhh: Thrush.SHHH,
credentials: Credentials,
firstState: StateID,
lastState: StateID -- default: get latest
] RETURNS [ nb: Thrush.NB, events: Thrush.EventSequence_NIL ] = {
ENABLE UNWIND => NULL;
conv: ConversationData;
numStates: NAT;
[conv, , , nb] _ ThPartyPrivate.Verify[credentials];
IF nb#success OR conv=NIL OR conv.currentStateID=0 THEN RETURN;
IF lastState=0 OR lastState>conv.currentStateID THEN lastState_conv.currentStateID;
SELECT firstState FROM
<1 => firstState_1;
>conv.currentStateID => RETURN;
ENDCASE;
IF lastState<firstState THEN RETURN;
numStates _ lastState-firstState+1;
events_NEW[Thrush.EventSequenceBody[numStates]];
FOR i: NAT IN [0..numStates) DO events[i] _ conv.log[i+firstState]; ENDLOOP; };

SetupRingTunes: PROC[event: Thrush.ConvEvent] = TRUSTED {
partyID: Thrush.PartyHandle = event.credentials.partyID;
party: PartyData = ThPartyPrivate.DehandleParty[partyID];
otherParty: PartyData;
otherTune: LarkPlay.ToneSpec;
otherMethod: ThPartyPrivate.RingMethod _ standard;
divisor: NAT _ 1;
SELECT event.state FROM ringing, maybe => NULL; ENDCASE => RETURN;
WITH iParty: party^ SELECT FROM
individual => {
SELECT iParty.ringEnable FROM
offTimed, subduedTimed =>
IF BasicTime.Period[from: iParty.ringTime, to: BasicTime.Now[]] > 0 THEN
ThParty.SetRingEnable[partyID: partyID, ringEnable: iParty.defaultRingEnable];
ENDCASE;
SELECT iParty.ringEnable FROM
offTimed, off => RETURN;
ENDCASE;
otherParty _ ThPartyPrivate.DehandleParty[
ThPartyPrivate.FindOtherParty[partyID,
ThPartyPrivate.DehandleConv[event.credentials.convID]].partyID];
IF otherParty#NIL THEN WITH oParty: otherParty^ SELECT FROM
individual => {
divisor _ 2; otherMethod _ oParty.ringDo;
IF otherMethod # standard THEN otherTune _ oParty.ringTune;
};
trunk => IF event.state=ringing THEN {
otherTune _ ThPartyPrivate.outsideRingTune; otherMethod _ bothTunes;
};
ENDCASE;
SELECT event.state FROM
maybe => {
IF otherTune=NIL THEN RETURN;
event.ringTune _ NEW[LarkPlay.ToneSpecRec _ otherTune^];
event.ringTune.volume _ ThNet.pd.tonesVolume+2;
event.ringTune.repeatIndefinitely _ TRUE;
RETURN;
}; 
ringing => NULL;
ENDCASE => RETURN;
event.ringTune _ iParty.ringTune;
IF iParty.ringDo # bothTunes OR otherMethod # bothTunes OR otherTune=NIL THEN RETURN;
event.ringTune _
LarkPlay.MergeToneSpecs[event.ringTune, otherTune, divisor, ringTuneDelay];
};
ENDCASE;
};

}.
ÞThPartySupervisorImpl.mesa
Last modified by D. Swinehart, January 13, 1985 2:35:36 pm PST
Copies, Obligatory Concrete

Types

Supervision Process . . . One per party

PROC[smarts: SmartsData ] RETURNS [ d: Thrush.Disposition ];
I think this is a hack. July 23, 1984 3:06 pm PDT
Tell only voiceTerminals about the ring or ringback tune
More hack. July 23, 1984 3:06 pm PDT
<<Party can't fail until all its smarts do.  Likely this abort was issued by operator from debugger due to an RPC failure that will be worse next time.  If that doesn't work, must fail party by failing all of its smarts.  Things aren't very clean in here.>>
{ party.partyFailed _ TRUE; CONTINUE; };
Have discovered a change in state that our Smarts should know about.  The Smarts will now learn about it, even if the state changes again before they can act on the change.
PROC[trip: TripleRec] RETURNS [continue: BOOLEAN_TRUE]
Distribution utility.  Basic Party distribution function << At last!! >>
Perform distribution in order of this Party's priorities
<<Flatten next priority level, for now>>
Distribute to all Smarts at this priority level.
If Post generates new work to do, stop and do it, then cycle again.
Post is probably the wrong word for this activity, now.  But the work needs doing.
When a trunk party leaves a conversation, it loses its identity (<< something wrong here? >>)
When a recording party leaves, it reverts to available.
If timed, see if time has expired.  If so, switch back to default ring tune
�Ê
˜Jš
œ™Jš
œ>™>J˜š
Ïk	˜	J˜ Jšœ	�œ+˜9Jšœ�œ6˜CJšœ�œ�œ˜ Jš�œ
�œ˜J˜-Jšœ�œ˜Jšœ�œ˜,Jš
œ˜šœ�œ˜Jš
χ
˜á
—Jš	œ�œ^�
œ'�œ�œ˜É
Jšœ�œ-˜:J˜
J˜—šœ�
œ
�œ˜/š
�˜J˜
J˜	J˜Jš
œ˜J˜Jš�œ
˜J˜Jš
Ïc˜Jš
œ˜Jš
œ˜J˜Jš
œ˜Jš
œ˜—Jš�œ˜Jš�œ˜J˜—J™™Jšœ�œ˜#šœ�œ#˜9Jšœ<�œ#˜c—Jšœ�œ˜#Jšœ
�œ˜'Jšœ�œ�œ�œ�œ�œ
�œ�
œ	˜VJš�œ�œ
�œ
˜šœ�œ˜+Jšœ=�œ˜]—J˜J˜—™J™Jšœ�œ˜Jšœ�œ	ž!˜<J˜—™'J™šÏn
œ�œ˜/Jš
œ˜Jšœ�
œ
˜"Jšœ�œ
�œ
˜J˜šŸœ%˜+Jš�œ�œ™<š�œ
�œ˜Jšœ�œ
˜Jšœ�
œ
˜(Jš�œ˜	—Jšœ�œ�
œ˜5J˜Jš�œ�œ
�œ˜$š	�œ�œ
�œ�œ
�˜5Jš
œ
�œ�œ�œ
�œž%˜_—J™1š�œ�œ&�˜:J˜J™8—š�œE˜KJš
œ7˜7šœ%�˜)Jšœ!�œ
˜&Jšœ1�œ
˜7Jš�œ˜	——J™$Jšœ�œ
˜Jš
œ˜J˜—š�œ˜	J˜*J˜QJ˜—š
�˜š�œ
�œ�œ
˜Jšœn�œ�
™�Jšœ�œ�œ™(—Jš
œ0˜0J™¬
Jšœ�œ
˜Jš�œ�œ9˜EJš�œ
�œ	�œ
�˜Jš	�œ
�œ�œ	�œ
ž˜IJš�œ
�œ�œ
�œ
�œž*˜TJš�œ
˜—J˜J˜—J˜š
Ÿ	œ�œ
�œ
�œ�œ˜>š�œ�œ
�˜Jšœ"�œ˜:—Jš�œž$˜?J˜J˜—šŸœ�œ
�œ˜.Jš�œ�œ
�œ
�œ˜@Jš�œ
�œ�œ
˜šœ	�œ�œ˜1Jš�œ�œ�
™6J˜š�œ
�œ
�˜š
œ
˜
Jšœ
�œ
˜Jšœ�œ˜Jš�œ#�œ
˜3Jš�œ
�œ�œ˜9š�œ�œ
�œ˜Jš
œ(˜(Jšœ�œ
˜
š
œ˜Jšœ(�œ(˜R—Jš
œ9˜9Jšœ�œ˜Jš�œ
�œ˜Jš
œ˜—Jš
œ˜—Jš�œ
˜—Jš
œ˜—Jš
œ:˜:š�œ�œ�˜$Jš
�œ�œ�œ
�œ
�œ˜K—Jš
œ˜J˜—š
œH™HšŸ
œ�œ
�œ;˜RJš�œ#˜*J˜Jš�œ	�œ
�œ
�œ˜!Jšœ
�œ$žœ˜KJš
œ8™8š�œ!�œ$žœ�œ�œ
�˜‡
J™(š	�œ$�œ'�œ�œ
�˜nJšœ
�œ�œ˜-šŸœ˜ Jšœ�œ˜#š�œ�˜
Jšœ�œ
˜Jšœ1�œ
˜>š�œ�œ˜!Jšœ@�œ˜G——Jš
œ˜—Jš
œ0™0Jš
œ7˜7Jš
�œ�œ
�œ�œ�œ˜3——J˜—J˜—šŸœ�œ
�œ<˜SJ™CJ™RJš�œ�œ
�œ
˜&J˜"J˜$J˜"Jš�œ�œ*˜CJ™]J™7š�œ�œ
�œ
�˜#Jšœ�œ7˜RJ˜UJš�œ
˜J˜—Jš
œ˜—J˜šŸœ�œ
�œ˜*Jšœ�
œ)�œ˜FJ˜/Jšœ�œ
˜Jš
œ˜J˜—šŸ
œ�œ
�œ
�œ
˜Jšœ
�œ
˜Jš
œ˜J˜Jšœž˜)Jšœ�œ�œ�œ˜AJš�œ
�œ�œ
˜J˜Jšœ�œ
˜Jš
œ4˜4Jš�œ�œ�œ
�œ�œ
�œ
˜?Jš�œ
�œ�œ˜Sš�œ�˜J˜Jšœ�œ
˜Jš�œ
˜—Jš�œ�œ
�œ
˜$J˜#Jšœ�œ&˜0Jš
�œ�œ
�œ�œ%�œ˜O—J˜šŸœ�œ�œ˜9J˜8J˜9J˜Jš
œ˜Jš
œ2˜2Jšœ	�œ˜J™KJš
�œ
�œ�œ�œ�œ
˜Bš�œ�˜˜š�œ�˜š
œ˜š�œB�˜HJš
œN˜N——Jš�œ
˜—š�œ�˜Jšœ�œ
˜Jš�œ
˜—˜*˜&J˜@——š	�œ�œ
�	œ�œ
�˜;š
œ˜Jš
œ)˜)Jš�œ�œ˜;Jš
œ˜—šœ	�œ�œ˜&Jš
œD˜DJš
œ˜—Jš�œ
˜—š�œ
�˜˜
Jš�œ�œ
�œ
�œ
˜Jšœ�œ$˜8J˜/Jšœ$�œ
˜)Jš�œ
˜Jš
œ˜—Jšœ�œ
˜Jš�œ�œ
˜—J˜!Jš�œ�œ�œ�œ
�œ
�œ
˜U˜J˜K—J˜——Jš�œ
˜Jš
œ˜—J˜—J˜—…— „0u