DIRECTORY
BasicTime USING [ Now, Period ],
LarkPlay USING [ MergeToneSpecs, ToneSpec, ToneSpecRec ],
Process USING [ Detach, EnableAborts, SecondsToTicks, SetTimeout ],
RefID USING [ nullID, Release ],
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, MakeServiceRname, PartyBody, PartyData, RingMethod, outsideRingTune, Verify ],
Thrush USING [ ConversationHandle, ConvEvent, Credentials, Disposition, EventSequence, EventSequenceBody, H, HandleFault, KillHandle, NB, nullHandle, PartyHandle, Priorities, SHHH, StateID, ThHandle ],
Triples USING [ Any, Erase, Foreach, ForeachProc, Select ],
ThSmartsRpcControl,
TU USING [ MakeUnique],
VoiceUtils USING [ Problem ]
;

ThPartySupervisorImpl: CEDAR MONITOR LOCKS root
IMPORTS
BasicTime,
LarkPlay,
Process,
root: ThPartyMonitorImpl,
RefID,
RPC,
SafeStorage,
--SpyLog,--
ThNet,
Thrush,
ThParty,
ThPartyPrivate,
ThSmartsRpcControl,
Triples,
TU,
VoiceUtils
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 (event.proseSpecs=NIL OR (event.proseSpecs.first.type=request AND party.type=individual)) AND
(NOT yourParty) AND (event.state#initiating) THEN RETURN;
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];
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=> {
VoiceUtils.Problem[remark: "Invalid distribute return code", where: $System];
RETURN[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;
IF cfRef.socket#RefID.nullID THEN [] _ RefID.Release[cfRef.socket];
cfRef.socket _ RefID.nullID;
Triples.Erase[cfRef, conv, party];
conv.numParties _ conv.numParties-1;
party.numConvs _ party.numConvs-1;
IF conv.numParties=0 THEN ThPartyPrivate.DestroyConversation[conv];
TRUSTED { SELECT party.type FROM
trunk => {
party.outgoing _ NIL;
party.reservedBy _ Thrush.nullHandle;
Triples.Erase[$RnameForTrunk, party, Triples.Any];
};
service => {
party.reservedBy _ Thrush.nullHandle;
TU.MakeUnique[$RnameForParty, party,
ThPartyPrivate.MakeServiceRname[party.serviceName].serviceRnameAtom];
};
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;
SELECT party.type FROM
individual => {
SELECT party.ringEnable FROM
offTimed, subduedTimed =>
IF BasicTime.Period[from: party.ringTime, to: BasicTime.Now[]] > 0 THEN
ThParty.SetRingEnable[partyID: partyID, ringEnable: party.defaultRingEnable];
ENDCASE;
SELECT party.ringEnable FROM
offTimed, off => RETURN;
ENDCASE;
otherParty _ ThPartyPrivate.DehandleParty[
ThPartyPrivate.FindOtherParty[partyID,
ThPartyPrivate.DehandleConv[event.credentials.convID]].partyID];
IF otherParty#NIL THEN SELECT otherParty.type FROM
individual => {
divisor _ 2; otherMethod _ otherParty.ringDo;
IF otherMethod # standard THEN otherTune _ otherParty.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 _ party.ringTune;
IF party.ringDo # bothTunes OR otherMethod # bothTunes OR otherTune=NIL THEN RETURN;
event.ringTune _
LarkPlay.MergeToneSpecs[event.ringTune, otherTune, divisor, ringTuneDelay];
};
ENDCASE;
};

}.
vThPartySupervisorImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Last modified by D. Swinehart, July 5, 1986 2:13:59 pm PDT
Polle Zellweger (PTZ) August 22, 1985 1:59:56 pm PDT
Copies, Obligatory Concrete

Types

Supervision Process . . . One per party

PROC[smarts: SmartsData ] RETURNS [ d: Thrush.Disposition ];
Don't report uninteresting events.  Allow request proseSpecs to get to service (for speech) and/or trunk (for feeping) smarts.  (Note: a proseSpec list will be either wholly requests or some combination of started and finished at this level.)  Need to change if proseSpecs used to communicate with own Lark. 
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
Swinehart, May 15, 1985 10:35:09 am PDT
Cedar 6.0
changes to: Dissolve (new way to idle service (recording) party), proseSpecs test in Inform
Swinehart, May 20, 1985 1:16:28 pm PDT
PartyBody is not a variant record any more
changes to: Dissolve, SetupRingTunes
Swinehart, May 22, 1985 12:02:13 pm PDT
ServiceName changes
changes to: Dissolve
Swinehart, May 22, 1985 12:08:44 pm PDT
recording => service
changes to: Dissolve
Polle Zellweger (PTZ) August 14, 1985 4:22:41 pm PDT
Don't report proseSpec transitions to the individual's party -- would have to be changed to use proseSpecs to send tunes to your own Lark.  Idea is to keep traffic of large ropes down.  Since Dan is using proseSpecs to make the trunk feep to his bank, have to report them to trunk parties.
changes to: Inform (local of Supervisor)
Polle Zellweger (PTZ) August 22, 1985 1:59:57 pm PDT
changes to: Inform (local of Supervisor)
Swinehart, May 17, 1986 3:19:05 pm PDT
Cedar 6.1
changes to: DIRECTORY, ThPartySupervisorImpl, DistOne

Κ˜š
œ™Icodešœ
Οm
œ7™BJš
œ:™:K™4—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˜Jšžœ
˜J˜Jš
Οc˜Jš
œ˜Jš
œ˜J˜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šžœžœ
žœ˜$šžœžœ
žœžœ
žœžœ
žœ&žœž˜“
š	œ
žœžœžœ
žœ
˜9Jšœ³Ÿ
™΄——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š
žœžœžœ
žœ
žœ˜K—Jš
œ˜J˜—š
œH™Hš 
œžœ
žœ;˜RJšžœ#˜*J˜Jšžœ	žœ
žœ
žœ˜!Jšœ
žœ$Ÿœ˜KJš
œ8™8šžœ!žœ$Ÿœžœžœ
ž˜‡
J™(š	žœ$žœ'žœžœ
ž˜nJšœ
žœžœ˜-š œ˜ Jšœžœ˜#šžœž˜
Jšœžœ
˜Jšœ1žœ
˜>šžœž˜Jš
œM˜MJšžœ
žœ˜
J˜——Jš
œ˜—Jš
œ0™0Jš
œ7˜7Jš
žœžœ
žœžœžœ˜3——J˜—J˜—š œžœ
žœ<˜SJ™CJ™RJšžœžœ
žœ
˜&Jšžœžœ"˜CJ˜J˜"J˜$J˜"Jšžœžœ*˜CJ™]J™7šžœžœž˜ š
œ
˜
Jšœžœ
˜J˜%Jš
œ2˜2Jš
œ˜—˜J˜%˜$J˜E—J˜—Jšžœ
˜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šžœž˜˜šžœž˜š
œ˜šžœAž˜GJš
œM˜M——Jšžœ
˜—šžœž˜Jšœžœ
˜Jšžœ
˜—˜*˜&J˜@——š	žœžœ
žœ
žœž˜2š
œ˜Jš
œ-˜-Jšžœžœ!˜?Jš
œ˜—šœ	žœžœ˜&Jš
œD˜DJš
œ˜—Jšžœ
˜—šžœ
ž˜˜
Jšžœžœ
žœ
žœ
˜Jšœžœ$˜8J˜/Jšœ$žœ
˜)Jšžœ
˜Jš
œ˜—Jšœžœ
˜Jšžœžœ
˜—J˜ Jšžœžœžœžœ
žœ
žœ
˜T˜J˜K—J˜——Jšžœ
˜Jš
œ˜—J˜—J˜™'K™	KšœΟrœG™[—™&K™*Kšœ‘™$—™'K™Kšœ‘™—™'K™Kšœ‘™—™4K™‘Kšœ‘œ™(—™4Kšœ‘œ™(—™&K™	Kšœ‘)™5—K™—…—!ζ8s