DIRECTORY
BasicTime USING [ Update, Now ],
CardTable USING [ Create, Delete, EachPairAction, Fetch, Pairs, Ref, Store ],
DESFace USING [ GetRandomKey, Key ],
IV USING [ KeyTableBody ],
MBQueue USING [ QueueClientAction ],
Process USING [ Detach, SecondsToTicks, SetTimeout ],
Pup USING [ nullSocket, Socket ],
PupName USING [ AddressToRope ],
RefID USING [ ID, Reseal, Unseal ],
Rope USING [ Equal, ROPE ],
RPC USING [ CallFailed, GetConversationID, ShortROPE ],
ThNet USING [ pd ],
ThParty,
ThPartyPrivate
USING [
ConversationBody, ConversationData, ConvState, ConvStateBody, DoDescribeParty, GetRnameFromParty, PartyBody, PartyData, SetPoaching, SmartsBody, SmartsData ],
ThPartyMonitorImpl,
Thrush
USING [
ActionID, ActionReport, AlertKind, CallUrgency, ConversationID, ConvEvent, ConvEventBody, Credentials, EncryptionKey, epoch, InterfaceSpec, KeyTable, NB, NetAddress, noAddress, nullConvID, nullID, nullKey, PartyID, Reason, ROPE, SHHH, SmartsID, StateID, StateInConv, unencrypted ],
ThSmartsRpcControl USING [ InterfaceRecord ],
Triples USING [ Any, Erase, Foreach, ForeachProc, Make, Select ],
TU USING [ MakeUnique ],
VoiceUtils USING [ OwnNetAddress, Problem ]
;
Implementation of ThParty
CreateConversation:
PUBLIC
ENTRY
PROC[
shhh: SHHH,
credentials: Credentials,
state: Thrush.StateInConv,
urgency: Thrush.CallUrgency,
alertKind: Thrush.AlertKind,
reason: Thrush.Reason,
comment: ROPE,
subject: ROPE,
checkConflict: BOOL
] RETURNS [ nb: NB, convEvent: ConvEvent←NIL ] = {
ENABLE UNWIND => NULL;
conv: ConversationData =
NEW[ThPartyPrivate.ConversationBody ← [
timeOfID: BasicTime.Now[],
startTime: BasicTime.Now[],
subject: subject,
urgency: urgency,
alertKind: alertKind,
conferenceHost: ConferenceHost[],
keyTable: NEW[IV.KeyTableBody[20B]]
] ];
Special check for "front door"/"back door" conflict
IF checkConflict
THEN {
callingParty: PartyData = UnsealParty[credentials.partyID];
IF callingParty#
NIL
AND PartyConflict[callingParty,
NIL]
THEN RETURN[nb: $voiceTerminalBusy];
};
IF ThNet.pd.nullKeyCorrectParity
THEN
FOR i: [0..16) IN [0..16) DO conv.keyTable[i] ← ALL[[b: 0, p: 1]]; ENDLOOP;
TRUSTED { []𡤎nterKey[conv, DESFace.GetRandomKey[]]; };
This conv's key, will be key index 1.
conv.convID ← EnhandleConv[conv];
credentials.stateID ← 0;
credentials.state ← $neverWas;
credentials.convID ← conv.convID;
[nb, convEvent] ← DoAdvance[credentials: credentials, state: state, newInConv: TRUE, reason: reason, comment: comment];
IF nb # $success THEN DeleteConversation[ conv ];
};
CreateConversation.nb~$success
CreateConversation.nb~$voiceTerminalBusy -- checkConflict only
CreateConversation.Verify.nb~~$noSuchSmarts
CreateConversation.Verify.nb~~$noSuchParty
CreateConversation.nb~$<unexpectedErrors>
Alert:
PUBLIC
ENTRY PROC[
shhh: SHHH,
credentials: Credentials,
calledPartyID: PartyID,
comment: ROPE
] RETURNS [ nb: NB ] = {
ENABLE UNWIND => NULL;
calledParty: PartyData;
visitedParty: PartyData;
nb2: NB ← $wuddYaTalkinAbout;
calledParty ← UnsealParty[calledPartyID];
visitedParty ←
IF calledParty=
NIL
THEN
NIL
ELSE NARROW[Triples.Select[$Visiting, calledParty, --visitee--]];
IF visitedParty#NIL THEN nb2 ← AlertOne[credentials, Reseal[visitedParty], calledPartyID];
nb ← AlertOne[credentials, calledPartyID];
IF nb#$success AND nb2=$success THEN nb←$success;
};
Alert.nb~$success
Alert.nb~$narcissism
Alert.nb~$alreadyInConv
Alert.nb~$noSuchParty2
Alert.nb~$voiceTerminalBusy
Alert.Verify.nb~~$noSuchSmarts
Alert.Verify.nb~~$noSuchParty
Alert.Verify.nb~~$noSuchConv
Alert.Verify.nb~~$notInConv
Alert.Verify.nb~~$stateMismatch
Alert.Verify.nb~~$interfaceError
Alert.DoAdvance.nb~~$convIdle
Alert.nb~$<unexpectedErrors>
AlertOne:
PUBLIC INTERNAL PROC[
credentials: Credentials,
calledPartyID: PartyID,
intendedPartyID: PartyID ← nullID
] RETURNS [ nb: NB ] = {
Alert alerts a party and whoever it's visiting. This routine is responsible for alerting just one party. It's used by Alert and by the Visit function
ENABLE UNWIND => NULL;
convState: ConvState;
conv: ConversationData;
callingParty: PartyData;
calledParty: PartyData;
partyID: PartyID = credentials.partyID;
[, callingParty,, nb] ← Verify[credentials];
IF nb # $success THEN RETURN;
credentials.partyID ← calledPartyID;
[conv, calledParty, convState, nb] ← Verify[credentials];
SELECT nb
FROM
$notInConv, $success => NULL;
$success => IF conv#NIL THEN RETURN[$alreadyInConv]; -- already in the conversation!
$noSuchParty => RETURN[$noSuchParty2];
ENDCASE=> RETURN;
ThPartyPrivate.SetPoaching[calledParty, callingParty];
Be sure $individual parties are associated with the right voice terminals.
IF VoiceParty[calledParty] = VoiceParty[UnsealParty[partyID]]
THEN
RETURN[$narcissism];
It is not permitted to call yourself. This is the only check in the system for this case.
IF nb = $success
AND conv#
NIL
THEN
RETURN[$alreadyInConv];
Already in the conversation!
One more check: make sure "front door" and "back door" usages for calling and called parties do not conflict.
IF PartyConflict[callingParty, calledParty]
OR PartyConflict[calledParty, callingParty]
THEN RETURN[$voiceTerminalBusy];
credentials.smartsID remains the originator's — this produces a strange value for convEvent.situation.other.smartsID; at present, no one uses that — if they do, they'll have to understand.
credentials.stateID ← 0;
IF calledParty=
NIL
OR
(calledParty.type = $trunk AND calledParty.reservedBy # Reseal[callingParty]) THEN
RETURN[nb: $noSuchParty2];
nb ← DoAdvance[credentials: credentials, intendedPartyID: intendedPartyID, state: $notified, newInConv: TRUE].nb;
};
AlertOne.nb~$success
AlertOne.nb~$narcissism
AlertOne.nb~$alreadyInConv
AlertOne.nb~$noSuchParty2
AlertOne.nb~$voiceTerminalBusy
AlertOne.Verify.nb~~$noSuchSmarts
AlertOne.Verify.nb~~$noSuchParty
AlertOne.Verify.nb~~$noSuchConv
AlertOne.Verify.nb~~$notInConv
AlertOne.Verify.nb~~$stateMismatch
AlertOne.Verify.nb~~$interfaceError
AlertOne.DoAdvance.nb~~$convIdle
AlertOne.nb~$<unexpectedErrors>
Advance:
PUBLIC
ENTRY
PROC[
shhh: SHHH,
credentials: Credentials,
state: Thrush.StateInConv,
reportToAll: BOOL,
reason: Thrush.Reason,
comment: ROPE,
bilateral: BOOL
] RETURNS [nb: NB, convEvent: ConvEvent] = {
ENABLE UNWIND => NULL;
[nb, convEvent] ← DoAdvance[
credentials: credentials,
state: state,
reportToAll: reportToAll,
reason: reason,
comment: comment,
newInConv: FALSE,
bilateral: bilateral
];
};
Advance.nb~$success
Advance.nb~$convIdle
Advance.nb~$bilateralConv -- $active only
Advance.nb~$conferenceConv -- $active only
Advance.nb~$voiceTerminalUnavailable -- $active only
Advance.Verify.nb~~$noSuchSmarts
Advance.Verify.nb~~$noSuchParty
Advance.Verify.nb~~$noSuchConv
Advance.Verify.nb~~$notInConv
Advance.Verify.nb~~$stateMismatch
Advance.Verify.nb~~$interfaceError
DoAdvance:
PUBLIC
INTERNAL
PROC [
credentials: Credentials,
intendedPartyID: PartyID ← nullID,
state: Thrush.StateInConv,
reportToAll: BOOL←FALSE,
reason: Thrush.Reason←NIL,
comment: ROPE←NIL,
newInConv: BOOL, -- if TRUE, party must not be in the conversation yet . . . and vice versa
bilateral: BOOL←FALSE
] RETURNS [nb: NB←$success, convEvent: ConvEvent←NIL] = {
convState: ConvState;
conv: ConversationData;
party: PartyData;
[conv, party, convState, nb] ← Verify[credentials, newInConv];
IF intendedPartyID#nullID
THEN
IF convState.intendedPartyID # nullID THEN ERROR -- Why does this case arise?
ELSE convState.intendedPartyID ← intendedPartyID; -- See ThPartyPrivate.ConvState
SELECT nb
FROM
$success => {
IF convState=NIL THEN RETURN;
IF state = $active AND party.partyActive THEN RETURN[nb: $partyAlreadyActive];
IF conv.numIdle = conv.numParties AND state # $idle THEN RETURN[nb: $convIdle];
credentials.state ← state;
};
$stateMismatch, $interfaceError => credentials.state ← convState.state; -- Don't change state, but return current one as report.
ENDCASE => RETURN;
IF nb=$success
AND state = $active
AND ~party.partyActive
THEN {
cStateB: ConvState ← conv.cStateBilateral;
voiceP: PartyData;
voiceS: SmartsData;
Some parties, due to hardware limitations, cannot participate in conference calls. They must assert bilateral as they attempt to enter the active state. Here we check all that, and deal with it.
IF cStateB#
NIL
AND cStateB#convState
AND cStateB.state=$active
AND Triples.Select[conv, cStateB, NIL]#NIL
AND conv.numActive>1 THEN RETURN[nb: $bilateralConv];
IF bilateral
THEN {
IF conv.numActive>1 THEN RETURN[nb: $conferenceConv];
conv.cStateBilateral ← convState;
};
A party is not allowed to be $active unless it can support a voice connection.
IF (voiceP←VoiceParty[party])=
NIL
OR
(voiceS ← NARROW[Triples.Select[$Smarts, voiceP, NIL]])=NIL OR
voiceS.properties.role#$voiceTerminal THEN RETURN[nb: $voiceTerminalUnavailable];
};
convEvent ← PostConvEvent[
credentials: credentials, convState: convState,
reason: reason, comment: comment, reportToAll: reportToAll];
};
DoAdvance.nb~$success
DoAdvance.nb~$convIdle
DoAdvance.nb~$bilateralConv -- $active only
DoAdvance.nb~$conferenceConv -- $active only
DoAdvance.nb~$voiceTerminalUnavailable -- $active only
DoAdvance.Verify.nb~~$noSuchSmarts
DoAdvance.Verify.nb~~$noSuchParty
DoAdvance.Verify.nb~~$noSuchConv
DoAdvance.Verify.nb~~$notInConv
DoAdvance.Verify.nb~~$stateMismatch
DoAdvance.Verify.nb~~$interfaceError
GetConversationInfo:
PUBLIC ENTRY PROC [ shh:
SHHH←none, convID: ConversationID ]
RETURNS [
nb: NB←$success,
cInfo: ThParty.ConversationInfo←[]
] = { [nb, cInfo] ← GetConversationInfoInt[UnsealConv[convID]]; };
GetConversationInfo.nb~$success
GetConversationInfo.nb~$noSuchConv
GetConversationInfoInt:
INTERNAL
PROC[conv: ConversationData ]
RETURNS [
nb: NB←$success,
cInfo: ThParty.ConversationInfo←[]
] = {
IF conv=NIL THEN RETURN[nb: $noSuchConv];
cInfo.subject ← conv.subject;
cInfo.urgency ← conv.urgency;
cInfo.alertKind ← conv.alertKind;
cInfo.startTime ← conv.startTime;
cInfo.conferenceHost ← conv.conferenceHost;
cInfo.numParties ← conv.numParties;
cInfo.numActive ← conv.numActive;
cInfo.numIdle ← conv.numIdle;
cInfo.originator ← Reseal[Triples.Select[$Originator, conv, -- originator --]];
};
GetConversationInfoInt.nb~$success
GetConversationInfoInt.nb~$noSuchConv
GetPartyInfo:
PUBLIC ENTRY PROC [
shh: SHHH←none, credentials: Credentials, nameReq: ThParty.NameReq, allParties: BOOL ]
RETURNS [
nb: NB,
pInfo: ThParty.PartyInfo←NIL
] = {
conv: ConversationData = UnsealConv[credentials.convID];
convState: ConvState;
ownParty: PartyData = UnsealParty[credentials.partyID];
name: Rope.ROPE;
intendedName: Rope.ROPE;
intendedPartyID: PartyID;
activeIndex: NAT𡤀 -- when incremented, the index of the next active party description
inactiveIndex: NAT; -- when incremented, the index of the next non-active party description
GetParties:
INTERNAL FinishProcType = {
Computes the socket values (and corresponding party/smarts ident) for each voice terminal participant in a conversation, when invoked by Report. A party that does not have an associated voice terminal will not be allowed to enter the Active state.
index: NAT;
HowToReport ← NIL;
IF Triples.Select[$Poaching, party,
-- poachee party -- ]#
NIL
AND smarts.properties.role#$voiceTerminal THEN RETURN; -- Wait for voice terminal
index ←
SELECT TRUE FROM
party=ownParty => 0,
convState.state=$active => (activeIndex�tiveIndex+1),
ENDCASE => (inactiveIndex←inactiveIndex+1);
pInfo.numParties ← MAX[index+1, pInfo.numParties];
name ←
IF nameReq=$none
THEN
NIL
ELSE ThPartyPrivate.DoDescribeParty[party, nameReq];
intendedPartyID ← convState.intendedPartyID;
IF conv.cStateBilateral = convState
AND convState.state=$active
THEN pInfo.conversationInfo.bilateralConv ← TRUE;
pInfo[index] ← [
partyID: Reseal[party],
name: name,
intendedPartyID: intendedPartyID,
intendedName:
IF nameReq=$none
THEN
NIL
ELSE IF intendedPartyID = nullID THEN name
ELSE IF (intendedName ←ThPartyPrivate.DoDescribeParty[UnsealParty[intendedPartyID], nameReq])#NIL THEN intendedName ELSE name,
type: party.type,
state: convState.state,
numConvs: party.numConvs,
enabled: party.enabled,
partyActive: party.partyActive,
socket: smarts.properties.netAddress
];
};
nb ←
IF conv=
NIL
THEN $noSuchConv
ELSE IF ownParty=NIL THEN $noSuchParty ELSE $success;
IF nb=$success
THEN {
convState ← GetConvState[conv, ownParty];
IF convState=NIL THEN nb ← $notInConv
};
IF nb#$success THEN RETURN;
inactiveIndex ← conv.numActive-(IF convState.state=$active THEN 1 ELSE 0);
pInfo ← NEW[ThParty.PartyInfoSeq[IF allParties THEN conv.numParties ELSE 1]];
pInfo.conversationInfo ← GetConversationInfoInt[conv].cInfo;
pInfo[0] ← [];
Report[
FinishProc: GetParties, reportToAll: allParties,
conv: conv, party: ownParty, whatToReport: NIL];
};
GetPartyInfo.nb~$success
GetPartyInfo.nb~$noSuchConv
GetPartyInfo.nb~$noSuchParty
GetPartyInfo.nb~$notInConv
GetKeyTable:
PUBLIC
ENTRY
PROC [ shh:
SHHH←none, credentials: Credentials ]
RETURNS [ nb: NB, keyTable: Thrush.KeyTable←NIL ] = {
conv: ConversationData;
[conv,,,nb] ← Verify[credentials];
IF conv#NIL THEN keyTable ← conv.keyTable; -- always answer the question if possible
IF nb=$stateMismatch THEN nb←$success;
};
GetKeyTable.nb~$success
GetKeyTable.Verify.nb~~$noSuchSmarts
GetKeyTable.Verify.nb~~$noSuchParty
GetKeyTable.Verify.nb~~$noSuchConv
GetKeyTable.Verify.nb~~$notInConv
GetKeyTable.Verify.nb~~$interfaceError
RegisterKey:
PUBLIC ENTRY PROC [
shh: SHHH ← none,
credentials: Credentials,
key: Thrush.EncryptionKey,
reportNewKeys: BOOL] -- note: reportNewKeys is no longer used
RETURNS [ nb: NB, keyIndex: [0..17B] ← 0 ] = TRUSTED {
ENABLE UNWIND => NULL;
conv: ConversationData;
ekResults: EKResults←$duplicate;
[conv, , , nb] ← Verify[credentials];
Don't care about stateMismatch here (maps to $success).
SELECT nb FROM $success, $stateMismatch => NULL; ENDCASE => RETURN;
[keyIndex, ekResults] ← EnterKey[conv, key];
nb ← IF ekResults#$new THEN $success ELSE $newKeys;
};
RegisterKey.nb~$success
RegisterKey.nb~$newKeys
RegisterKey.Verify.nb~~$noSuchSmarts
RegisterKey.Verify.nb~~$noSuchParty
RegisterKey.Verify.nb~~$noSuchConv
RegisterKey.Verify.nb~~$notInConv
RegisterKey.Verify.nb~~$interfaceError
UnregisterKey:
PUBLIC ENTRY PROC[
shh: SHHH ← none,
credentials: Credentials,
key: Thrush.EncryptionKey
]
RETURNS [ nb: NB ← $success ] = {
conv: ConversationData;
[conv, , , nb] ← Verify[credentials];
SELECT nb FROM $success, $stateMismatch => nb ← $success; ENDCASE => RETURN;
RemoveKey[conv, key];
};
UnregisterKey.nb~$success
RegisterKey.Verify.nb~~$noSuchSmarts
RegisterKey.Verify.nb~~$noSuchParty
RegisterKey.Verify.nb~~$noSuchConv
RegisterKey.Verify.nb~~$notInConv
RegisterKey.Verify.nb~~$interfaceError
RegisterServiceInterface:
PUBLIC
ENTRY
PROC[
shhh: SHHH ← none,
credentials: Thrush.Credentials,
interfaceSpecPattern: Thrush.InterfaceSpec
] RETURNS[nb: NB, interfaceSpec: Thrush.InterfaceSpec] = {
interface: REF Thrush.InterfaceSpec;
instance: RPC.ShortROPE←NIL;
hostHint: Thrush.NetAddress;
party: PartyData;
type: RPC.ShortROPE = interfaceSpecPattern.interfaceName.type;
[party: party, nb: nb] ← Verify[credentials];
IF nb = $noSuchParty AND party = NIL THEN RETURN; -- else just not yet enabled
nb ← $success;
interface ← FindServiceInterface[party, type];
IF interface =
NIL
THEN {
interface ← NEW[Thrush.InterfaceSpec ← [interfaceName: [type: type], serviceID: interfaceSpecPattern.serviceID, interfaceID: interfaceSpecPattern.interfaceID]];
party.actionInterfaces ← CONS[interface, party.actionInterfaces];
};
Produce hostHint value
IF interfaceSpecPattern.hostHint # Thrush.noAddress
THEN
hostHint ← interfaceSpecPattern.hostHint
ELSE IF shhh=NIL THEN hostHint ← VoiceUtils.OwnNetAddress[]
ELSE {
na: Thrush.NetAddress = LOOPHOLE[RPC.GetConversationID[shhh]];
hostHint ← [na.net, na.host, Pup.nullSocket];
};
interface.hostHint ← hostHint;
instance ← interfaceSpecPattern.interfaceName.instance;
IF instance =
NIL
THEN {
hostHint.socket ← NewId[];
instance ← PupName.AddressToRope[hostHint];
};
interface.interfaceName.instance ← instance;
interface.interfaceName.version ← interfaceSpecPattern.interfaceName.version;
interface.serviceID ← interfaceSpecPattern.serviceID;
interfaceSpec ← interface^;
};
RegisterServiceInterface.nb~$success
Verify.nb~$noSuchParty
LookupServiceInterface:
PUBLIC ENTRY PROC[
shhh: SHHH ← none,
credentials: Thrush.Credentials,
serviceParty: PartyID,
type: RPC.ShortROPE
] RETURNS[nb: NB ← $success, interfaceSpec: Thrush.InterfaceSpec] = {
interface: REF Thrush.InterfaceSpec;
party: PartyData;
[nb: nb] ← Verify[credentials]; -- There's no strong reason for checking credentials.
SELECT nb FROM $success, $stateMismatch => NULL; ENDCASE => RETURN;
party ← UnsealParty[serviceParty];
IF party=NIL THEN { nb ← $noSuchParty2; RETURN; };
interface ← FindServiceInterface[party, type];
IF interface=
NIL
THEN {
party ← NARROW[Triples.Select[$Poaching, party, NIL]];
IF party#NIL THEN interface ← FindServiceInterface[party, type];
IF interface = NIL THEN { nb ← $noSuchInterface; RETURN; };
};
interfaceSpec ← interface^;
};
LookupServiceInterface.nb~$success
LookupServiceInterface.nb~$noSuchParty2
LookupServiceInterface.nb~$noSuchInterface
Utilities
Verify:
INTERNAL
PROC[ credentials: Credentials, newInConv:
BOOL←
FALSE ]
RETURNS [
conv: ConversationData←NIL,
party: PartyData←NIL,
convState: ConvState←NIL,
nb: Thrush.NB ] = {
Validate parameters: existence, in conversation, state match; produce dehandled values.
Validation for smarts is only partial; verifies that it's a smarts.
smarts: SmartsData ← UnsealSmarts[credentials.smartsID];
conv←UnsealConv[credentials.convID];
party←UnsealParty[credentials.partyID];
nb ←
SELECT
NIL[REF ANY]
FROM
smarts => $noSuchSmarts,
party => $noSuchParty,
conv =>
IF credentials.convID#nullConvID
THEN $noSuchConv
ELSE $success,
This is dangerous. If caller inadvertently omitted convID, kablooey!
ENDCASE=> $success;
IF nb=$success AND ~party.enabled THEN nb ← $noSuchParty;
IF nb#$success
OR conv=
NIL
THEN
RETURN;
Not interested in any conversation, or it doesn't exist
convState ← GetConvState[conv, party, newInConv];
IF convState=
NIL
THEN { nb ← $notInConv;
RETURN; };
IF newInConv is TRUE and convState already existed, it's a logical error, but we're not checking it.
SELECT credentials.stateID
FROM
< convState.stateID => nb←$stateMismatch;
> convState.stateID => nb←$interfaceError; -- really bogus behaviour!
ENDCASE;
};
Verify.nb~$success
Verify.nb~$noSuchSmarts
Verify.nb~$noSuchParty
Verify.nb~$noSuchConv
Verify.nb~$notInConv
Verify.nb~$stateMismatch
Verify.nb~$interfaceError
GetConvState:
PUBLIC INTERNAL
PROC[ conv: ConversationData, party: PartyData, createOK:
BOOL←
FALSE]
RETURNS [convState: ConvState←NIL] = {
GCS: Triples.ForeachProc = {
WITH trip.att SELECT FROM cS: ConvState => { convState𡤌S; RETURN[FALSE]; }; ENDCASE;
};
Triples.Foreach[Triples.Any, conv, party, GCS];
IF convState#NIL OR ~createOK THEN RETURN;
convState ← NEW[ThPartyPrivate.ConvStateBody ← []];
Triples.Make[convState, conv, party];
Triples.Make[$Party, conv, party];
IF conv.numParties=0 THEN TU.MakeUnique[$Originator, conv, party];
party.numConvs ← party.numConvs+1;
conv.numParties ← conv.numParties+1;
};
PostConvEvent:
INTERNAL PROC[
credentials: Credentials,
convState: ConvState,
reason: Thrush.Reason←NIL,
comment: Thrush.ROPE←NIL,
reportToAll: BOOL
] RETURNS [convEvent: ConvEvent ] = {
conv: ConversationData ← UnsealConv[credentials.convID];
party: PartyData ← UnsealParty[credentials.partyID];
SELECT convState.state
FROM
-- states that was, but will no longer be
$idle => { conv.numIdle ← conv.numIdle-1; party.numConvs ← party.numConvs+1; };
Prev. line is for protection: you're not supposed to leave idle state, or enter it twice, but this will keep the counts correct if it happens. party.numConvs becomes 0 once a party goes idle.
$active => { conv.numActive ← conv.numActive -1; party.partyActive ← FALSE; };
ENDCASE;
SELECT credentials.state
FROM
-- states that will be
$idle => { conv.numIdle ← conv.numIdle+1; party.numConvs ← party.numConvs-1; };
$active => { conv.numActive ← conv.numActive+1; party.partyActive ← TRUE; };
ENDCASE;
convState.stateID ← credentials.stateID ← convState.stateID+1;
convState.state ← credentials.state;
conv.timeOfID ← convState.time ← BasicTime.Now[];
convEvent ←
NEW[ Thrush.ConvEventBody ← [
self: [ ],
other: credentials,
time: convState.time,
reason: reason,
comment: comment
] ];
Report Progress
Report[FinishEvent, reportToAll, conv, party, convEvent ]; -- will queue up either a report or an idle check for each recipient.
};
PackagedReport: TYPE = REF ReportBody;
ReportBody:
TYPE =
RECORD [
smarts: SmartsData,
whatToReport: REF
];
FinishProcType:
TYPE =
PROC[party: PartyData, smarts: SmartsData, convState: ConvState, whatToReport:
REF]
RETURNS [HowToReport: PROC[r: REF]←NIL, whatToReallyReport: REF←NIL];
Generic reporting routine, synchronous with ThPartyOps procedure, and protected by its monitor. Depending on reportToAll, queues up the report to be distributed to the smarts' for all parties in the conversation (TRUE), or just to the requesting party (FALSE). Reports are made to the indicated parties and their poachees. $visiting will be dealt with later. Having identified a party and smarts to which to report, calls FinishProc to complete the report (to indicate in the report the addressee of the report, for instance); FinishProc may veto the report by returning FALSE.
Report:
PUBLIC INTERNAL PROC[
FinishProc: FinishProcType, -- provides Report proc as one of its return values
reportToAll: BOOL,
conv: ConversationData,
party: PartyData,
whatToReport: REF
] = {
ReportToOne:
INTERNAL Triples.ForeachProc = {
[trip: Triples.TripleRec] RETURNS [continue: BOOLEAN ← TRUE]
party: PartyData = NARROW[trip.val];
ReportToParty[party, party];
};
ReportToParty:
INTERNAL
PROC[party: PartyData, participant: PartyData] = {
party is the one we're reporting to; it might be a poachee of the participant. participant is the party that's actually a member of the conversation.
pSmarts: SmartsData;
packagedReport: PackagedReport;
realReport: REF ← whatToReport;
HowToReport: PROC[r: REF]←NIL;
IF party=NIL OR ~party.enabled THEN RETURN;
pSmarts ← NARROW[Triples.Select[$Smarts, party, --pSmarts--]];
IF pSmarts#
NIL
AND FinishProc#
NIL THEN [HowToReport, realReport] ←
FinishProc[participant, pSmarts, GetConvState[conv, participant], whatToReport];
IF HowToReport#
NIL
THEN {
packagedReport ← NEW[ReportBody ← [smarts: pSmarts, whatToReport: realReport] ];
conv.numReportsOut ← conv.numReportsOut + 1;
pSmarts.notifications.QueueClientAction[HowToReport, packagedReport];
};
party ← NARROW[Triples.Select[$Poaching, party, -- poachee --]];
IF party#NIL THEN ReportToParty[party, participant];
};
IF ~reportToAll THEN ReportToParty[party, party]
ELSE Triples.Foreach[$Party, conv, Triples.Any --party--, ReportToOne];
};
Called as report is being prepared to fill in addressee information
FinishEvent:
INTERNAL FinishProcType = {
Two cases:
1) reporting to originating smarts: don't copy convEvent, and use report only to do CheckIdle asynchronously with the originating operation.
2) reporting to some other smarts: copy convEvent before filling in self field, request a ReportProgress.
convEvent: ConvEvent = NARROW[whatToReport];
reportEvent: ConvEvent =
IF (convEvent.other.smartsID = Reseal[smarts])
THEN convEvent
ELSE NEW[Thrush.ConvEventBody ← convEvent^];
reportEvent.self ← [
Reseal[party], Reseal[smarts], reportEvent.other.convID, convState.state, convState.stateID];
IF convEvent = reportEvent
THEN
RETURN[ReportCheckIdle, UnsealConv[convEvent.self.convID]] -- no report to initiator
ELSE RETURN[ReportProgress, reportEvent];
};
Called to issue state-change progress report
ReportProgress:
PROC[r:
REF] = {
Specific reporting routine, dispatched from a smarts notification queue, for reporting party state changes.
report: PackagedReport = NARROW[r];
convEvent: ConvEvent = NARROW[report.whatToReport];
{
ENABLE
RPC.CallFailed => {
IF ~report.smarts.failed
THEN {
VoiceUtils.Problem["Communications to smarts failed", $System];
[]←ThParty.Deregister[smartsID: Reseal[report.smarts]];
};
report.smarts.failed←TRUE;
RETRY;
};
IF ~report.smarts.failed
THEN
report.smarts.interface.clientStubProgress[
interface: report.smarts.interface, shh: report.smarts.shh, convEvent: convEvent];
CheckIdle[UnsealConvE[convEvent.self.convID]];
};
};
ReportCheckIdle:
PROC[r:
REF] = {
If all parties are idle in conversation, conversation can go away.
report: PackagedReport = NARROW[r];
CheckIdle[NARROW[report.whatToReport]];
};
CheckIdle:
ENTRY
PROC[conv: ConversationData] = {
If all parties are idle in conversation, conversation can go away.
conv.numReportsOut ← conv.numReportsOut - 1;
IF conv.numIdle = conv.numParties
AND conv.numReportsOut<=0
THEN
TRUSTED {
Process.Detach[FORK IdleAfterAWhile[conv]]; };
};
IdleAfterAWhile:
ENTRY
PROC[conv: ConversationData] =
TRUSTED {
If all parties are idle in conversation, conversation can go away.
idler: CONDITION;
Process.SetTimeout[@idler, Process.SecondsToTicks[ThNet.pd.postIdleTimeout]];
WAIT idler;
DeleteConversation[conv];
};
DeleteConversation:
INTERNAL
PROC[ conv: ConversationData ] = {
Triples.Erase[Triples.Any, conv, Triples.Any];
[]𡤌onvTable.Delete[LOOPHOLE[conv.convID]]; -- KillConv[conv.convID];
};
NewId:
PUBLIC
PROC
RETURNS [ Pup.Socket ] =
TRUSTED {
idKey: DESFace.Key ← DESFace.GetRandomKey[]; -- connection specs.
keys:
LONG
POINTER
TO
ARRAY[0..2)
OF Pup.Socket ←
LOOPHOLE[LONG[@idKey]];
RETURN[keys[0]];
};
FindServiceInterface:
INTERNAL
PROC[
party: PartyData,
type: RPC.ShortROPE
] RETURNS[interface: REF Thrush.InterfaceSpec←NIL] = {
FOR iF:
LIST
OF
REF Thrush.InterfaceSpec ← party.actionInterfaces, iF.rest
WHILE iF#
NIL
DO
IF type.Equal[iF.first.interfaceName.type, FALSE] THEN RETURN[iF.first];
ENDLOOP;
};
VoiceParty:
PUBLIC INTERNAL
PROC[party: PartyData]
RETURNS [voiceParty: PartyData ] = {
Find the associated party that actually carries the voice connection.
If none, return party. So it doesn't guarantee that there really can be a voice connection.
IF party=NIL THEN RETURN;
IF party.type#$individual THEN RETURN[party];
voiceParty ← NARROW[Triples.Select[$Poaching, party, -- poachee --]];
IF voiceParty = NIL THEN voiceParty ← party;
};
PartyConflict:
PUBLIC INTERNAL
PROC[party: PartyData, targetParty: PartyData]
RETURNS [isConflict: BOOL ] = {
There's a conflict if:
there exists other such that other = $Other[VoiceParty[party]] (or vice/versa), AND
other # VoiceParty[targetParty], AND
other or its poacher is involved in at least one conversation, not in idle state.
vParty: PartyData ← VoiceParty[party];
otherParty: PartyData;
IF vParty=NIL THEN RETURN[FALSE];
otherParty ← NARROW[Triples.Select[$Other, vParty, NIL]];
IF otherParty=NIL THEN otherParty ← NARROW[Triples.Select[$Other, NIL, vParty]];
IF otherParty=NIL OR otherParty = VoiceParty[targetParty] THEN RETURN[FALSE];
IF otherParty.numConvs#0 THEN RETURN[TRUE];
otherParty ← NARROW[Triples.Select[$Poaching, NIL, otherParty]];
RETURN[otherParty#NIL AND otherParty.numConvs#0];
};
Reporting of actions generated by voice services
AReport: TYPE = REF AReportRec;
AReportRec:
TYPE =
RECORD [
report: Thrush.ActionReport,
numReportsOut: INTEGER𡤀, -- for selfOnCompletion feature
finalReport: AReport←NIL, -- for selfOnCompletion feature
reportToAll: BOOL,
selfOnCompletion: BOOL
];
ReportAction:
PUBLIC
ENTRY
PROC[
shhh: SHHH ← none,
report: Thrush.ActionReport, -- includes credentials (in other field) identifying the service party.
reportToAll: BOOL ← FALSE,
selfOnCompletion: BOOL ← FALSE
] RETURNS [nb: NB, numReportsIssued: NAT𡤀] = {
ENABLE UNWIND => NULL;
[nb, numReportsIssued] ← ReportActionInt[report, reportToAll, selfOnCompletion];
};
ReportAction.nb~$success
ReportAction.Verify.nb~~$noSuchSmarts
ReportAction.Verify.nb~~$noSuchParty
ReportAction.Verify.nb~~$noSuchConv
ReportAction.Verify.nb~~$notInConv
ReportAction.Verify.nb~~$stateMismatch
ReportAction.Verify.nb~~$interfaceError
ReportActionInt:
INTERNAL
PROC[
report: Thrush.ActionReport, -- includes credentials (in other field) identifying the service party.
reportToAll: BOOL ← FALSE,
selfOnCompletion: BOOL ← FALSE
] RETURNS [nb: NB, numReportsIssued: NAT𡤀] = {
rReport: AReport;
conv: ConversationData;
[nb: nb, conv: conv] ← Verify[report.other];
IF nb # $success THEN RETURN; -- Reports are not that important.
rReport ← NEW[AReportRec ← [report, 0, NIL, reportToAll, selfOnCompletion]];
rReport.finalReport ← rReport; -- for selfOnCompletion feature.
Report[FinishProc: FinishReportAction, reportToAll:
TRUE,
conv: conv, party: NIL, whatToReport: rReport];
If report.reportToAll is FALSE, the actual reportee will be detected in due time; it isn't the caller of ReportAction.
numReportsIssued ← rReport.numReportsOut;
};
See ReportAction for nb's
FinishReportAction:
INTERNAL FinishProcType = {
Three cases:
1) reporting to caller of ThParty.ReportAction. Don't report (at least wait, if selfOnCompletion).
2) reporting to the originator of the service request, as defined by the action report, and this party isn't the originator. Don't report.
3 reporting to all or reporting to the originator of the service request, and this is it. Generate a report.
aReport: AReport ← NARROW[whatToReport];
aReportCopy: AReport ← aReport;
IF aReport.report.other.smartsID = Reseal[smarts]
THEN
IF aReport.selfOnCompletion THEN NULL ELSE RETURN -- requestingParty
ELSE
IF ~aReport.reportToAll
AND Reseal[party] # aReport.report.requestingParty
THEN RETURN -- no report to non-requesting party.
ELSE aReportCopy ← NEW[AReportRec ← aReport^]; -- must be a copy, because . . .
aReportCopy.report.self ← [
Reseal[party], Reseal[smarts], aReportCopy.report.other.convID, convState.state, convState.stateID];
IF aReportCopy = aReport THEN RETURN; -- Will be used indirectly through finalReport link of other reports if selfOnCompletion
aReport.numReportsOut ← aReport.numReportsOut+1; -- aReport = aReportCopy.finalReport
RETURN[DoReportAction, aReportCopy];
};
DoReportAction:
PROC[r:
REF] = {
Specific reporting routine, dispatched from a smarts notification queue, for reporting party state changes.
report: PackagedReport = NARROW[r];
aReport: AReport ← NARROW[report.whatToReport];
finalReport: AReport ← aReport.finalReport;
{
ENABLE
RPC.CallFailed => {
IF ~report.smarts.failed
THEN {
VoiceUtils.Problem["Communications to smarts failed", $System];
[]←ThParty.Deregister[smartsID: Reseal[report.smarts]];
};
report.smarts.failed←TRUE;
RETRY;
};
conv: ConversationData ← UnsealConvE[aReport.report.self.convID];
IF report.smarts.failed THEN { CheckIdle[conv]; RETURN; };
report.smarts.interface.clientStubReportAction[
interface: report.smarts.interface, shh: report.smarts.shh, report: aReport.report];
IF aReport.selfOnCompletion
THEN {
FinalReport:
ENTRY
PROC= {
To original reporter, when all others have been delivered!
ENABLE UNWIND => NULL;
pSmarts: SmartsData;
finalReport.numReportsOut ← finalReport.numReportsOut-1;
IF finalReport.numReportsOut#0 THEN RETURN;
pSmarts ← UnsealSmarts[finalReport.report.self.smartsID];
conv.numReportsOut ← conv.numReportsOut + 1;
report.smarts ← pSmarts;
report.whatToReport ← finalReport;
pSmarts.notifications.QueueClientAction[DoReportAction, report];
};
FinalReport[];
};
CheckIdle[conv];
};
};