LarkTrunkSmartsImpl.mesa
Smarts for the Lark "Back Door"
Last modified by D. Swinehart, December 10, 1983 2:00 am
Note: Incoming calls are those from the Etherphone to the outside party, whom this system represents. Outgoing calls are those from the outside world to an Etherphone. Remember; trunk party is a representative of people in the public telephone system.
DIRECTORY
IO,
Lark -- USING [
-- CommandEvents, ConnectionSpec, Event, LarkModel, Passel, SHHH, StatusEvents ]--,
LarkSmartsMonitorImpl,
Nice,
Log USING [ Problem, ProblemHandle, Report ],
Process USING [ SecondsToTicks, SetTimeout ],
Rope USING [ Concat ],
ThParty USING [ Advance, Alert, CreateParty ],
ThPartyPrivate USING [
DehandleParty, DehandleSmarts, LocalSmartsInterface, RegisterLocal, SmartsBody, SmartsData ],
Thrush USING [
ConversationHandle, ConvEvent, PartyHandle, H, MakeUnique, NB, nullConvHandle, nullHandle, pERROR, Reason, ROPE, SmartsHandle, StateInConv, ThHandle ],
ThSmartsPrivate USING [
Apprise, ConvDesc, Deregister, EnterLarkState, GetConv, GetConvDesc, GetSIC, GetSmartsInfo, LarkFailed, LarkProgress, OpenConversations, SmartsInfo, SmartsInfoBody ],
ThSmartsRpcControl,
Triples USING [Any, Make, Select ],
TU
;
LarkTrunkSmartsImpl: CEDAR MONITOR LOCKS root
IMPORTS
root: LarkSmartsMonitorImpl,
IO,
Log,
Nice,
Process,
Rope,
Thrush,
ThParty,
ThPartyPrivate,
ThSmartsPrivate,
ThSmartsRpcControl,
Triples,
TU
EXPORTS ThSmartsPrivate --, ThSmarts via Interface record --
SHARES LarkSmartsMonitorImpl = { OPEN IO;
Types and Constants
ConvDesc: TYPE = ThSmartsPrivate.ConvDesc;
H: PROC[r: REF] RETURNS[Thrush.ThHandle] = INLINE {RETURN[Thrush.H[r]]; };
ROPE: TYPE = Thrush.ROPE;
SHHH: TYPE = Lark.SHHH; -- Encrypts conv. if first arg to RPC PROC
PartyHandle: TYPE = Thrush.PartyHandle;
nullHandle: Thrush.ThHandle = Thrush.nullHandle;
nullConvHandle: Thrush.ConversationHandle = Thrush.nullConvHandle;
SmartsInfo: TYPE = ThSmartsPrivate.SmartsInfo;
StateInConv: TYPE = Thrush.StateInConv;
PD: TYPE = RECORD [
timeoutNoAction: INT�,
cSp: REF Ctr←NEW[Ctr←[0,1000000]],
cRs: REF Ctr←NEW[Ctr←[0,1000000]],
cZp: REF Ctr←NEW[Ctr←[0,1000000]],
doReports: BOOLFALSE,
doNice: BOOLFALSE
];
pd: REF PDNEW[PD←[]];
Ctr: TYPE = RECORD[
count: INT,
stop: INT
];
Report: PROC[what: ROPE, info: SmartsInfo, ctr: REF Ctr] = {
IF NOT pd.doReports THEN RETURN;
Log.Report[what, $Lark, info.larkInfo];
ctr.count𡤌tr.count+1;
IF ctr.count>ctr.stop THEN { Log.Problem["Report overflow", $Lark, info.larkInfo]; };
};
BeNice: PROC[r: REF, d: INT, info: SmartsInfo] = {
IF NOT pd.doNice THEN RETURN;
Nice.BeNice[r, d, $Lark, info.larkInfo];
};
Initialization
RegisterTrunk: PUBLIC ENTRY PROC[
hostPartyID: PartyHandle, hostSmarts: ThPartyPrivate.SmartsData, hostInfo: SmartsInfo ]
RETURNS [ smartsID: Thrush.SmartsHandle ] = { {
ENABLE UNWIND => NULL;
There's no provision here at all for reregistration. Yet.
localSmarts: ThPartyPrivate.LocalSmartsInterface;
info: SmartsInfo;
partyID: PartyHandle = ThParty.CreateParty[type: trunk];
hostParty: REF = ThPartyPrivate.DehandleParty[hostPartyID];
party: REF = ThPartyPrivate.DehandleParty[partyID];
smarts: ThPartyPrivate.SmartsData;
IF hostParty=NIL OR party = NIL THEN
RETURN[Log.ProblemHandle["TrunkSmarts didn't register", $Party, nullHandle, hostParty]];
Thrush.MakeUnique[$TrunkParty, hostParty, party];
localSmarts ← ThSmartsRpcControl.NewInterfaceRecord[];
localSmarts.Progress ← ThSmartsPrivate.LarkProgress;
smartsID ← ThPartyPrivate.RegisterLocal [
partyID: partyID,
interface: localSmarts,
properties: hostSmarts.properties
];
IF smartsID = nullHandle THEN GOTO NotSmart;
smarts ← ThPartyPrivate.DehandleSmarts[smartsID, TRUE];
info ← NEW[ThSmartsPrivate.SmartsInfoBody ← [
smarts: smarts,
otherSmarts: hostSmarts,
ParseEvent: LarkTrunkParseEvent,
Supervise: TrunkSupervise,
larkInfo: hostInfo.larkInfo ]];
Triples.Make[$SmartsData, smarts, info];
EXITS
NotSmart => RETURN[nullHandle]; }; };
Events
RecordTrunkEvent handles events from the EtherPhone Trunk connection.
The only interesting events at present are "ring" (place trunk->station call) and "tones F" (station->trunk call being "answered")
The upstream code produces a single "enabled" event when the line starts ringing, and a single "disabled" event when it appears that ringing has stopped. This "disabled" event must be anticipated and ignored if the station answers (calling trunk can't hang up on completed call!)
LarkTrunkParseEvent: ENTRY PROC[
smartsInfo: SmartsInfo, sEvent: Lark.StatusEvent] = {
ENABLE {
UNWIND=>NULL;
ThSmartsPrivate.LarkFailed => { Log.Problem["Lark Failed", $Smarts, smartsInfo]; GOTO Failed; };
ANY => { Log.Problem[, $Smarts, smartsInfo]; GOTO Failed; };
};
SELECT sEvent.device FROM
ringDetect => SELECT sEvent.event FROM
Lark.enabled => CmdCall[smartsInfo];
Lark.disabled => CmdOnhook[smartsInfo];
ENDCASE => ERROR Thrush.pERROR;
tones =>
IF sEvent.event = 'F THEN CmdAnswer[smartsInfo];
ENDCASE;
EXITS
Failed =>
ThSmartsPrivate.Deregister[ThSmartsPrivate.GetSmartsInfo[smarts: smartsInfo.otherSmarts]];
};
CmdCall: INTERNAL PROC[info: SmartsInfo] = {
calledPartyID: PartyHandle;
cDesc: ConvDesc;
SELECT ThSmartsPrivate.GetSIC[info] FROM
idle => NULL;
ENDCASE => RETURN; -- not a valid time for this call. Ignore. Host system will handle.
cDesc ← ThSmartsPrivate.GetConv[info, nullConvHandle, TRUE];
calledPartyID ← H[Triples.Select[$TrunkParty, --owner--,
ThPartyPrivate.DehandleParty[cDesc.cState.credentials.partyID]]]; --<<UGH!>>
IF calledPartyID = nullHandle THEN RETURN;
Ignore the incoming call. It will be handled as unanswered by the host telephone system.
cDesc.desiredState ← active;
cDesc.desiredPartyID ← calledPartyID;
cDesc.desiredReason ← wontSay;
cDesc.desiredComment ← NIL;
cDesc.cState.state ← any; -- meaning "This is a new conversation to be made."
ThSmartsPrivate.Apprise[info];
};
CmdOnhook: INTERNAL PROC[info: SmartsInfo] = {
cDesc: ConvDesc=ThSmartsPrivate.GetConvDesc[info];
IF cDesc=NIL THEN RETURN;
SELECT cDesc.cState.state FROM
initiating, maybe => NULL; -- ringing stopped before called party answered.
ENDCASE => RETURN; -- already active or something; ignore end of ringing
cDesc.desiredState←idle;
cDesc.desiredReason ← wontSay;
cDesc.desiredComment ← NIL;
ThSmartsPrivate.Apprise[info];
};
CmdAnswer: INTERNAL PROC[info: SmartsInfo] = {
cDesc: ConvDesc=ThSmartsPrivate.GetConvDesc[info];
IF cDesc=NIL THEN RETURN;
SELECT cDesc.cState.state FROM
pending => NULL; -- this is the only state in which we expect any such action.
ENDCASE => RETURN;
cDesc.desiredState ← active;
ThSmartsPrivate.Apprise[info];
};
Supervision
TrunkSupervise: ENTRY PROC[info: SmartsInfo ] = {
TRUSTED {
Process.SetTimeout[@info.thAction, Process.SecondsToTicks[pd.timeoutNoAction]]; };
IF info.apprise THEN DO
ENABLE {
UNWIND => NULL;
ThSmartsPrivate.LarkFailed => GOTO Failing;
ANY => { Log.Problem[NIL, $Smarts, info]; GOTO Failing; };
};
prevL: ThSmartsPrivate.OpenConversations ← NIL;
nb: Thrush.NB←success;
convL: ThSmartsPrivate.OpenConversations;
trans: TrkTransition;
info.apprise ← FALSE;
FOR convL ← info.conversations,
convL.rest WHILE convL#NIL DO
cDesc: ConvDesc = convL.first;
stateNow: StateInConv = cDesc.cState.state;
ours: BOOL ← ( cDesc.cState.credentials.convID = info.currentConvID );
IF pd.doReports THEN Report[
Rope.Concat[
IO.PutFR["**** TkSup: %t(%d) %g %g->%g",
time[cDesc.cState.credentials.convID], int[cDesc.cState.credentials.stateID],
TU.RefAddr[info], refAny[NEW[StateInConv←stateNow]], refAny[NEW[StateInConv�sc.desiredState]]],
IO.PutFR[" %g%g\n",
refAny[NEW[TrkTransition←trkTransForStates[stateNow][cDesc.desiredState]]],
rope[IF ours THEN " (ours)" ELSE ""]]],
info, pd.cSp];
BeNice[cDesc, 6, info];
IF NOT cDesc.descValid THEN LOOP;
IF info.currentConvID = nullConvHandle AND stateNow#idle THEN {
<<This stuff feels like it's in the wrong place. Will feel more so when multi-calls
are dealt with. >>
ours←TRUE; info.currentConvID ← cDesc.cState.credentials.convID;
};
IF stateNow#idle AND (NOT ours) THEN
Conv isn't the one we're interested in, and doesn't look like it's going idle: idle it.
Should probably consult transForStates for validity.
nb ← ThParty.Advance[
credentials: cDesc.cState.credentials,
state: idle,
reason: busy,
comment: "One conversation at a time, please."
]
ELSE {
State and substate (below) and desired state indicate there's something to do. Do it:
SELECT (trans←trkTransForStates[stateNow][cDesc.desiredState]) FROM
noop => NULL;
elim => {
Conv. is now idle: forget about it.
Remove dead conversation from list.
IF pd.doReports THEN Report[IO.PutFR[" ** Zap: %t\n",
time[cDesc.cState.credentials.convID]], info, pd.cZp];
IF prevL#NIL THEN {
prevL.rest ← convL.rest; convL ← prevL; }
ELSE info.conversations𡤌onvL.rest;
IF ours THEN {
info.currentConvID ← nullConvHandle;
IF info.larkInfo.larkState=trunkForwarding THEN
ThSmartsPrivate.EnterLarkState[info.larkInfo, idle, info];
};
};
alrt => { -- placing call
convID: Thrush.ConversationHandle;
[nb, convID] ← ThParty.Alert [
credentials: cDesc.cState.credentials,
calledPartyID: cDesc.desiredPartyID,
state: initiating
];
IF nb=success THEN {
cDesc.cState.credentials.convID ← info.currentConvID ← convID;
ours←TRUE;
cDesc.cState.credentials.stateID ← 0;
};
};
idle, actv => -- Simple transitions
nb ← ThParty.Advance [
credentials: cDesc.cState.credentials,
state: cDesc.desiredState,
reason: cDesc.desiredReason,
comment: cDesc.desiredComment
];
spvs => {
spec: Lark.ConnectionSpec = cDesc.cState.spec;
IF cDesc.newEvent AND spec#NIL AND (spec.localSocket.net # spec.remoteSocket.net
OR spec.localSocket.host # spec.remoteSocket.host) THEN
ThSmartsPrivate.EnterLarkState[info.larkInfo, trunkForwarding, info];
cDesc.newIntervals ← NIL; -- Ignore interval Specs.
};
pend => { -- Handle an incoming (from Etherphone) call.
info.phoneNumber ← cDesc.cState.address;
IF info.phoneNumber = NIL THEN {
Direct access to outside line requested.
cDesc.desiredState�tive;
info.apprise ← TRUE;
}
ELSE IF NOT cDesc.signallingStarted THEN
Request signalling.
ThSmartsPrivate.EnterLarkState[info.larkInfo, trunkSignalling, info];
<<ELSE timeout with signalling not complete . . . shut down??>>
cDesc.signallingStarted←TRUE;
};
invl => {
Log.Problem["LarkSmarts: Invalid state transition request.", $Smarts, info];
info.apprise←TRUE;
cDesc.desiredState ← idle;
cDesc.desiredReason ← error;
cDesc.desiredComment ← "Invalid state transition";
};
ntiy => {
Log.Problem["LarkSmarts: State transition not yet implemented.", $Smarts, info];
info.apprise←TRUE;
cDesc.desiredState ← idle;
cDesc.desiredReason ← error;
cDesc.desiredComment ← "Unimplemented state transition";
};
ENDCASE => Thrush.pERROR;
};
Analyze any results of trying to reach a different state.
IF nb#success THEN
Report[IO.PutFR[" ** Results: nb=%g\n", refAny[NEW[Thrush.NB←nb]]], info, pd.cRs];
SELECT nb FROM
success, stateMismatch => NULL;
noSuchParty2, narcissism => { -- Have to get to error tone here. No such party.
Log.Problem["Called party not found, or calling self", $Smarts, info];
cDesc.cState.comment ← NIL;
cDesc.cState.reason ← notFound;
cDesc.desiredState←idle;
info.apprise←TRUE;
};
partyNotEnabled => { -- See old version; vamp until enabled.
Log.Problem["Party not yet enabled, ignore as much as possible.", $Smarts, info];
};
invalidTransition, convNotActive, convStillActive => {
Complain and transition to idle
comment: ROPE="Party-level detected invalid state transition request";
Log.Problem[comment, $Smarts, info];
cDesc.desiredState ← idle;
cDesc.cState.comment ← comment;
cDesc.cState.reason ← error;
info.apprise←TRUE;
};
notInConv, noSuchConv => { -- Complain, zap, go idle and repeat.
comment: ROPE="NotInConv or NoSuchConv";
Log.Problem[comment, $Smarts, info];
IF ours THEN info.currentConvID ← nullConvHandle;
cDesc.cState.credentials.convID ← nullConvHandle;
cDesc.cState.credentials.stateID ← 0;
cDesc.desiredState ← idle;
cDesc.cState.comment ← comment;
cDesc.cState.reason ← error;
info.apprise←TRUE;
};
noSuchParty, noSuchSmarts => { -- Complain, deregister, we gone! Needs tuning.
Log.Problem[
"NoSuchParty or NoSuchSmarts reported, must try to go away", $Smarts, info];
GOTO Failing;
};
ENDCASE => Thrush.pERROR;
prevL ← convL;
ENDLOOP;
IF NOT info.apprise THEN WAIT info.thAction;
IF info.conversations = NIL THEN EXIT;
REPEAT Failing => ThSmartsPrivate.Deregister[info]; -- now Failed
ENDLOOP;
info.thProcess ← NIL;
};
TrkTransition: TYPE = {
Just codes to dispatch on in Supervisor; explained there
noop, elim, idle, alrt, pend, actv, spvs, invl, ntiy
};
trkTransForStates: ARRAY StateInConv OF ARRAY StateInConv OF TrkTransition ← [
idle resrv pars init pend mayb ring canAc activ inact any -- desired
[ elim, invl, invl, invl, invl, invl, invl, invl, elim, ntiy, elim ], -- idle  (current)
[ invl, invl, invl, invl, invl, invl, invl, invl, invl, invl, invl ], -- reserved
[ invl, invl, invl, invl, invl, invl, invl, invl, invl, invl, invl ], -- parsing
[ idle, invl, invl, noop, invl, invl, invl, invl, noop, ntiy, invl ], -- initiating
[ idle, invl, invl, invl, invl, invl, invl, invl, actv, ntiy, pend ], -- pending
[ idle, invl, invl, invl, invl, noop, invl, invl, noop, ntiy, invl ], -- maybe
[ invl, invl, invl, invl, invl, invl, invl, invl, invl, ntiy, invl ], -- ringing
[ ntiy, invl, invl, invl, invl, invl, invl, invl, ntiy, ntiy, invl ], -- canActivate
[ idle, invl, invl, invl, invl, invl, invl, invl, spvs, ntiy, invl ], -- active
[ ntiy, invl, invl, invl, invl, invl, invl, invl, ntiy, noop, invl ], -- inactive
[ elim, invl, invl, invl, invl, invl, invl, invl, alrt, ntiy, invl ] -- any (nonex)
];
Debugging nonsense
Nice.View[pd, "Lark Trunk PD"];
}.
<< Comments left over from previous system. Think about it all sometime. was in section involving analysis of new pending state. >>
<<This is here to deal with the case where we saw ringing, launched a call, were rebuffed by the selected station, and thus went idle. Now we look available even though the phone is still ringing. Alternative to having a hook state for the back door is to enter the reserved state on rebuff until the disabled event comes in (caller gives up or is transferred.)>>
nb ← ChangeState[info, busy, "Sorry, trunk in use"]; RETURN; };