DIRECTORY
Atom USING [ GetPName, MakeAtom ],
Commander USING [ CommandProc, Register ],
CommandTool USING [ NextArgument ],
ExplicitExport USING [ ExportExplicitly ],
IO,
LupineRuntime USING [ BindingError ],
NamesGV USING [ GVGetAttribute ],
NamesRPC USING [ StartConversation ],
Nice,
RefID USING [ ID, Release, Reseal, Seal ],
Rope USING [ Concat, Cat, Length, Substr ],
RPC USING [ AuthenticateFailed, EncryptionKey, ExportFailed, ImportFailed ],
ThNet USING [ CloseWhitePagesDatabase, HowToDial, InitWhitePagesDatabase, WhitePagesEntry, WPListing, WPState ],
ThParty USING [ Credentials, NameReq, SmartsInterfaceName, SmartsInterfaceRecord, SmartsProperties ],
ThPartyPrivate USING [ PartyBody, PartyData, SmartsBody, SmartsData, UnsealParty, UnsealSmarts ],
ThPartyRpcControl,
ThPartyRpcServerImpl,
ThPartyMonitorImpl,
Thrush
USING [
ConversationID, NB, PartyID, PartyType, nullID, Machine, ROPE, SHHH, SmartsID, unencrypted ],
ThSmartsRpcControl USING [ ImportNewInterface ],
ThVersions USING [ ThrushVR ],
Triples USING [ Any, Erase, Item, Make, Select ],
TU USING [ MakeUnique, RefAddr ],
VoiceUtils USING [ CmdOrToken, CurrentPasskey, InstanceFromNetAddress, MakeAtom, Registrize, FindWhere, Problem, RegisterWhereToReport, Report, ReportFR, WhereProc ]
;
Definitions
NB: TYPE = Thrush.NB;
PartyData: TYPE = ThPartyPrivate.PartyData; -- REF Concrete
PartyID:
TYPE = Thrush.PartyID;
-- ID
nullID: PartyID = Thrush.nullID;
ROPE: TYPE = Thrush.ROPE;
SmartsData: TYPE = ThPartyPrivate.SmartsData; -- REF Concrete
SmartsID: TYPE = Thrush.SmartsID; -- ID
SHHH:
TYPE = Thrush.
SHHH;
none: SHHH = Thrush.unencrypted;
Reseal: PROC[r: REF] RETURNS[RefID.ID] = INLINE {RETURN[RefID.Reseal[r]]; };
Any: Triples.Item = Triples.Any;
larkRegistry: ROPE=".Lark";
thPartyExported: BOOL←FALSE;
wpState: ThNet.WPState;
Functions for obtaining existing parties, or phone numbers
GetParty:
PUBLIC
ENTRY PROC[shh:
SHHH←
NIL, partyID: PartyID,
rName: Thrush.ROPE, type: Thrush.PartyType←NIL]
RETURNS [nb: NB, newPartyID: PartyID] = {
ENABLE UNWIND=>NULL;
newParty: PartyData;
[nb, newParty] ← GetActiveParty[partyID, rName, type];
newPartyID ← Reseal[newParty];
};
GetPartyFromFeepNum:
PUBLIC
ENTRY PROC[
shh: SHHH←none, partyID: PartyID, feepNum: Thrush.ROPE←NIL]
RETURNS [nb: NB←$success, newPartyID: PartyID←nullID] = {
ENABLE UNWIND=>NULL;
party: PartyData ← NIL;
rName: ROPE;
rName ← ThNet.WhitePagesEntry [
wpState: wpState, name: feepNum, feep: TRUE, key: $officeNumber].fullRName;
IF rName=NIL THEN RETURN[nb: $noEntryFound];
[nb, party] ← GetActiveParty[partyID, rName, NIL];
newPartyID ← Reseal[party];
};
GetPartyFromNumber:
PUBLIC
ENTRY
PROC[
shh: SHHH, partyID: PartyID, phoneNumber: Thrush.ROPE,
description: ROPE]
RETURNS [nb: NB, newPartyID: PartyID] = {
ENABLE UNWIND => NULL;
[nb, newPartyID] ← GetPartyFromNumberInt[partyID, phoneNumber, description, FALSE];
};
GetNumbersForRName:
PUBLIC
PROC[shh:
SHHH←none, rName: Thrush.
ROPE]
RETURNS [fullRName: ROPE, number: ROPE, homeNumber: ROPE] = {
listing: ThNet.WPListing;
[fullRName, number, listing] ← ThNet.WhitePagesEntry[
wpState: wpState, name: rName, key: $officeNumber];
IF listing#
NIL
THEN homeNumber ← ThNet.WhitePagesEntry[
wpState: wpState, key: $outsideNumber, listing: listing].entry;
};
GetRname:
PUBLIC
PROC[shh:
SHHH←none, partyID: PartyID]
RETURNS [nb: NB, Rname: Thrush.ROPE←NIL] = {
[nb, Rname,] ← GetRnameFromParty[ThPartyPrivate.UnsealParty[partyID]];
};
GetActiveParty:
INTERNAL
PROC[partyID: PartyID, rName: Thrush.
ROPE,
type: Thrush.PartyType]
RETURNS [nb: NB←$success, newParty: PartyData←NIL] = {
Obtains a $service, $individual, or $telephone party, if available
number: ROPE;
listing: ThNet.WPListing;
wpRname: ROPE;
IF rName=NIL THEN RETURN[$noIdentSupplied, NIL];
IF type =
NIL
THEN { -- request for $individual or $telephone
[nb, newParty] ← GetActiveParty[partyID, rName, $individual];
IF nb # $success THEN [nb, newParty] ← GetActiveParty[partyID, rName, $telephone];
RETURN;
};
SELECT type
FROM
$service => { [nb, newParty] ← GetIdleParty[partyID, rName]; RETURN; };
$individual, $telephone => NULL; -- go on
$trunk => ERROR; -- until further notice
ENDCASE => ERROR;
newParty ←
NARROW[
Triples.Select[type, VoiceUtils.MakeAtom[VoiceUtils.Registrize[rName]], --party-- ] ];
IF newParty#NIL AND newParty.enabled THEN { SetPoaching[newParty]; RETURN; };
IF type # $telephone THEN RETURN[nb: $noSuchParty2];
No active party; try to get a trunk line for that individual
[wpRname, number, listing] ← ThNet.WhitePagesEntry [
wpState: wpState, name: rName, key: $officeNumber];
IF wpRname=NIL OR listing=NIL THEN RETURN[nb: $noSuchParty2];
IF number=
NIL
THEN number ← ThNet.WhitePagesEntry [
wpState: wpState, name: rName, key: $homeNumber, listing: listing].entry;
IF number=NIL THEN RETURN[nb: $noSuchParty2];
[nb, partyID] ← GetPartyFromNumberInt[partyID, number, rName, TRUE];
IF nb=$success THEN newParty ← ThPartyPrivate.UnsealParty[partyID];
};
GetIdleParty:
INTERNAL
PROC[partyID: PartyID, serviceName:
ROPE]
RETURNS [nb: NB←$success, newParty: PartyData ← NIL] = {
Locates an idle $service party, if available
<<This still needs some work.>>
ENABLE UNWIND=>NULL;
party: PartyData← ThPartyPrivate.UnsealParty[partyID];
myName: ROPE;
rAtom: ATOM;
serviceNameAtom:
ATOM = MakeServiceRname[serviceName].serviceRnameAtom;
e.g., $"text-to-speech.lark"
IF party = NIL THEN RETURN[nb: $noSuchParty];
[nb, myName,] ← GetRnameFromParty[party];
e.g., $"myself.pa"
IF nb # $success THEN RETURN[nb: nb, newParty: NIL];
rAtom ← VoiceUtils.MakeAtom[Rope.Cat[myName, ".", serviceName]];
e.g., $"myself.pa.text-to-speech"
newParty ← NARROW[Triples.Select[$service, serviceNameAtom, --party--]];
IF newParty = NIL OR ~newParty.enabled THEN nb←$noSuchParty2 -- e.g., all channels busy
ELSE
TU.MakeUnique[$service, rAtom, newParty];
-- $service[$"myself.pa.t..."] = <party>
};
GetPartyFromNumberInt:
INTERNAL PROC[
partyID: PartyID, phoneNumber: Thrush.ROPE,
description: ROPE, trunkRequired: BOOL]
RETURNS [nb: NB←$success, newPartyID: PartyID←nullID] = {
Party description has not yielded a party, so phone number will have to do. Perhaps the phone number is an extension of an active $individual; if not, try to find an idle outgoing trunk.
isExt: BOOLEAN ← FALSE;
num: ROPE ← NIL;
party: PartyData ← ThPartyPrivate.UnsealParty[partyID];
trunkParty: PartyData;
myExtAtom: ATOM;
myExt: ROPE;
myExt is used as Intelnet authorization code.
IF party=NIL THEN RETURN[$noSuchParty, nullID];
myExtAtom ← GetRnameFromParty[party, $current].rAtom; -- rName for party.
myExtAtom ←
IF myExtAtom=
NIL
THEN
NIL
ELSE NARROW[Triples.Select[$Extension, myExtAtom, -- extension --]];
myExt ← IF myExtAtom=NIL THEN NIL ELSE Atom.GetPName[myExtAtom];
IF phoneNumber = NIL THEN RETURN[$noIdentSupplied, nullID];
A null phoneNumber is a request for a direct outside line connection.
[num, isExt] ← ThNet.HowToDial[phoneNumber, myExt];
IF isExt
AND ~trunkRequired
THEN {
atom: ATOM𡤊tom.MakeAtom[num]; -- phone extension
IF atom #NIL THEN atom ← NARROW[Triples.Select[$Extension, --party--, atom]];
IF atom#
NIL
THEN {
newParty: PartyData;
[nb, newParty]← GetActiveParty[partyID, Atom.GetPName[atom], NIL];
IF nb=$success THEN RETURN[newPartyID: Reseal[newParty]];
};
};
Get Trunk Party
[nb, trunkParty] ← GetRelatedParty[party]; -- trunk if telephone/individual, or vice/versa
IF nb # $success
THEN {
party ← NARROW[Triples.Select[$Poaching, party, -- poachee--]];
IF party#NIL THEN [nb, trunkParty] ← GetRelatedParty[party];
};
IF nb # $success THEN RETURN;
trunkParty.outgoing ← num;
trunkParty.reservedBy ← partyID;
trunkParty.name ← description; -- starts out as name of trunk owner, changes on first use
newPartyID ← Reseal[trunkParty];
};
GetRelatedParty:
INTERNAL
PROC[party: PartyData]
RETURNS [nb: NB, relatedParty: PartyData←NIL] = {
rAtom: ATOM;
[nb,,rAtom]←GetRnameFromParty[party];
IF nb # $success THEN RETURN; -- VERY strange
SELECT party.type
FROM
$individual, $telephone =>
relatedParty ← NARROW[Triples.Select[$trunk, rAtom, -- trunk party --]];
ENDCASE; -- $trunk case will be added as needed for incoming calls.
IF relatedParty = NIL THEN nb ← $noTrunkParty
ELSE IF relatedParty.numConvs#0 THEN nb ← $convStillActive -- busy
ELSE IF ~relatedParty.enabled THEN nb ← $noSuchParty2; -- not available yet
IF nb # $success THEN relatedParty ← NIL;
};
Making new parties and smartses
Register:
PUBLIC
PROC[
shh: SHHH←none,
rName: ROPE←NIL, -- party identification
type: Thrush.PartyType ← $individual,
clonePartyID: PartyID,
interface: ThParty.SmartsInterfaceName, -- interface
properties: ThParty.SmartsProperties
] RETURNS [
nb: NB, credentials: ThParty.Credentials←[] ] = {
[nb, credentials] ← DoRegister[rName, type, clonePartyID, interface, NIL, properties];
};
RegisterLocal:
PUBLIC
PROC[
shh: SHHH←none,
rName: ROPE←NIL, -- party identification
type: Thrush.PartyType ← $individual,
clonePartyID: PartyID,
interfaceRecord: ThParty.SmartsInterfaceRecord ← NIL,
properties: ThParty.SmartsProperties
] RETURNS [
nb: NB, credentials: ThParty.Credentials←[] ] = {
[nb, credentials] ← DoRegister[rName, type, clonePartyID, [ ], interfaceRecord, properties];
};
DoRegister:
PROC[
rName: ROPE←NIL, -- party identification
type: Thrush.PartyType ← $individual,
clonePartyID: PartyID,
interface: ThParty.SmartsInterfaceName, -- interface
interfaceRecord: ThParty.SmartsInterfaceRecord,
properties: ThParty.SmartsProperties
] RETURNS [
nb: NB, credentials: ThParty.Credentials←[] ] = {
hostAtom:
ATOM = VoiceUtils.MakeAtom[
VoiceUtils.InstanceFromNetAddress[properties.machine, Atom.GetPName[type]]];
smarts: SmartsData←NARROW[Triples.Select[$SmartsForHost, hostAtom, -- smarts --]];
party: PartyData;
partyToSmartsShh: SHHH ← none;
IF clonePartyID#nullID THEN [nb, credentials] ← RegisterClone[clonePartyID];
IF smarts#
NIL
THEN {
Deregister any previous smarts from this machine. When cloning to produce multiple smarts and parties for a multi-channel service, obviously don't want to do this.
Multi-channel services must deregister explicitly, since this won't handle it.
nb�register[none, Reseal[smarts]];
IF nb # $success THEN RETURN;
};
IF rName=NIL THEN RETURN[nb: $noIdentSupplied];
IF interfaceRecord=
NIL
THEN {
partyToSmartsShh ← NamesRPC.StartConversation[
caller: serverInterfaceName.instance,
callee: rName,
key: serverPassword,
level: --<<ECB>>--CBCCheck ! RPC.AuthenticateFailed =>
{ VoiceUtils.Problem["Authenticate failed", $System]; CONTINUE}];
IF partyToSmartsShh=NIL THEN RETURN[nb: $couldntAuthenticate];
interfaceRecord ← SmartsRpc.ImportNewInterface[
interfaceName: interface ! RPC.ImportFailed =>
{ VoiceUtils.Problem["Import failed", $System]; CONTINUE}];
IF interfaceRecord=NIL THEN RETURN[nb: $couldntConnect];
};
{ RegisterEntry: ENTRY PROC={
[nb, party] ← CreateParty[rName, type];
IF nb#$success
THEN
RETURN;
Includes setting RName access, poaching and visiting designations.
smarts←
NEW[ThPartyPrivate.SmartsBody←[
properties: properties,
type: type,
interface: interfaceRecord,
shh: partyToSmartsShh
]];
TU.MakeUnique[$Smarts, party, smarts];
TU.MakeUnique[$SmartsForHost, hostAtom, smarts];
credentials.partyID ← RefID.Reseal[party];
credentials.smartsID ← RefID.Seal[smarts];
SetPoaching[party]; -- This is recomputed on every GetParty, included here for debugging ease.
}; RegisterEntry[]; };
VoiceUtils.Report[IO.PutFR["Register[%g, %g, %g] -> [%g, %g]",
rope[rName], atom[type], TU.RefAddr[ThPartyPrivate.UnsealParty[clonePartyID]],
TU.RefAddr[party], TU.RefAddr[smarts]]];
};
CreateParty:
INTERNAL
PROC[rName: Thrush.
ROPE, type: Thrush.PartyType]
RETURNS [nb: NB←$success, party: PartyData←NIL] = {
rName is a misnomer; it's the name of a service, without registry, if type is service.
partyRname: Thrush.ROPE = IF type # $service THEN rName ELSE MakeServiceRname[rName].serviceRname;
partyID: PartyID←nullID;
rAtom: ATOM=VoiceUtils.MakeAtom[partyRname];
extension: ATOM←NIL;
IF partyRname=NIL THEN RETURN[nb: $noIdentSupplied];
IF type # $service THEN party← NARROW[Triples.Select[type, rAtom, --party--]];
IF party#NIL THEN RETURN[$success, party];
party ← NEW[ThPartyPrivate.PartyBody ← [type: type, name: rName]];
SELECT type
FROM
$individual, $telephone, $service => {
-- Local telephone number
num: ROPE←GetNumbersForRName[rName: partyRname].number;
party.outgoing ← num;
IF num#NIL AND ~(([num,]←ThNet.HowToDial[num]).isLocalExtension) THEN num←NIL;
IF num#NIL THEN extension ← VoiceUtils.MakeAtom[num];
};
ENDCASE;
partyID ← RefID.Seal[party];
TU.MakeUnique[type, rAtom, party];
IF extension#NIL THEN TU.MakeUnique[$Extension, rAtom, extension];
};
SetPoaching:
INTERNAL
PROC[party: PartyData, callingParty: PartyData←
NIL] = {
poacher, poachee: PartyData←NIL;
rName: ROPE ← party.name;
smarts: REF;
workstation: ATOM;
wsName: ROPE;
nb: NB;
{
SELECT party.type
FROM
$individual => {
poacheeID: PartyID;
poacher←party;
IF (smarts ← Triples.Select[$Smarts, poacher,
-- smarts --]) =
NIL
THEN {
VoiceUtils.Problem["No smarts connection?"]; RETURN; };
IF (workstation ←
NARROW[Triples.Select[$SmartsForHost,
-- host--,smarts]]) =
NIL
THEN {
VoiceUtils.Problem["No SmartsForHost?"]; RETURN; };
wsName ← Atom.GetPName[workstation]; -- $"3#456#individual" =>
wsName ← wsName.Substr[len: wsName.Length[]-Rope.Length["individual"]];
wsName ← wsName.Concat[larkRegistry]; -- "3#456#.lark"
IF (rName ← NamesGV.GVGetAttribute[wsName, $owner, NIL]) = NIL THEN RETURN;
poachee ← NARROW[Triples.Select[$telephone, VoiceUtils.MakeAtom[rName], --party--]];
IF poachee#NIL THEN GOTO Done ELSE IF callingParty=NIL THEN RETURN;
There's no voice path for this individual. Try to create one using calling party's trunk.
IF party.outgoing = NIL THEN RETURN; -- No phone number?
[nb, poacheeID] ← GetPartyFromNumberInt[
partyID: Reseal[callingParty],
phoneNumber: party.outgoing,
description: rName,
trunkRequired: TRUE
];
IF nb#$success OR poacheeID=nullID THEN RETURN;
poachee ← ThPartyPrivate.UnsealParty[poacheeID];
};
$telephone => {
wsRope: ROPE ←
NamesGV.GVGetAttribute[rName.Concat[larkRegistry], $workstationhost, NIL];
workstation ← VoiceUtils.MakeAtom[wsRope.Concat["individual"]];
IF workstation = NIL THEN RETURN;
poachee←party;
IF (smarts ← Triples.Select[$SmartsForHost, workstation,-- smarts--])= NIL THEN RETURN;
poacher ← NARROW[Triples.Select[$Smarts, -- party --, smarts]];
IF poacher = NIL THEN { VoiceUtils.Problem["No smarts connection?"]; RETURN; };
};
ENDCASE=>RETURN;
EXITS Done => NULL; };
Triples.Erase[$Poaching, Any, poachee];
Triples.Erase[$Poaching, poacher, Any];
Triples.Make[$Poaching, poacher, poachee];
};
RegisterClone:
ENTRY
PROC[clonePartyID: PartyID]
RETURNS [nb: NB, credentials: ThParty.Credentials←[]] = {
cloneParty: PartyData←ThPartyPrivate.UnsealParty[clonePartyID];
party: PartyData ←
NEW[ThPartyPrivate.PartyBody ← [type: cloneParty.type, name: cloneParty.name]];
cloneSmarts, smarts: SmartsData;
IF cloneParty=NIL THEN RETURN[nb: $noSuchParty];
cloneSmarts ← NARROW[Triples.Select[$Smarts, cloneParty, -- Smarts --]];
IF cloneSmarts=
NIL
THEN {
VoiceUtils.Problem["No Smarts for party?"]; RETURN[nb: $noSuchSmarts]; };
smarts←
NEW[ ThPartyPrivate.SmartsBody ← [
properties: cloneSmarts.properties,
type: cloneSmarts.type,
interface: cloneSmarts.interface,
shh: cloneSmarts.shh
]];
Triples.Make[$Smarts, party, smarts];
credentials.partyID ← RefID.Seal[party];
credentials.smartsID ← RefID.Seal[smarts];
No HostForSmarts entry is made for clones. What should happen here anyhow?
VoiceUtils.Report[IO.PutFR["RegisterClone[%g, %g] -> [%g, %g]",
TU.RefAddr[party], TU.RefAddr[cloneParty], card[credentials.smartsID], TU.RefAddr[smarts] ], $Party, party];
};
Enable:
PUBLIC
ENTRY
PROC[shh:
SHHH←none, smartsID: SmartsID]
RETURNS [nb: Thrush.NB] = { RETURN[Able[smartsID, TRUE]]; };
Disable:
PUBLIC
ENTRY
PROC[shh:
SHHH←none, smartsID: SmartsID]
RETURNS [nb: Thrush.NB] = { RETURN[Able[smartsID, FALSE]]; };
Able:
INTERNAL
PROC[smartsID: SmartsID, enabling:
BOOL]
RETURNS[nb: Thrush.NB←$success] = {
smarts: SmartsData=ThPartyPrivate.UnsealSmarts[smartsID];
party: PartyData;
IF smarts=NIL THEN RETURN[$noSuchSmarts];
IF (party←
NARROW[Triples.Select[$Smarts,
--party--, smarts]])=
NIL
THEN RETURN[$noSuchParty];
party.enabled← smarts.enablesParty← enabling;
};
Deregister Smarts from Party, destroy both
Deregister:
PUBLIC
ENTRY
PROC[shh:
SHHH, smartsID: SmartsID]
RETURNS [nb: NB ← $success] = {
There's but one party per smarts, these days. When the Smarts goes, so goes the party. For the most part, we can (after idling all the conversations in which the party participates) merely erase all the interconnections between the party and smarts and other objects, and release their ID's.
$Visiting implementations and hints for implementations are only suggestions, for now.
ENABLE UNWIND => NULL;
party: PartyData;
smarts: SmartsData ← ThPartyPrivate.UnsealSmarts[smartsID];
IF smarts=NIL THEN RETURN[$noSuchSmarts];
party ← NARROW[Triples.Select[$Smarts, --party--, smarts]];
IF party#
NIL
THEN {
IdleConversationsForParty[party];
Transfer $Visitors from authenticated to assumed.
EraseAsObj[party,
LIST[ $Smarts, $AssumedParty, $AuthenticatedParty, $TrunkParty, $Poaching ] ];
Triples.Erase[$Poaching, Any, party];
VoiceUtils.ReportFR[
"DeleteParty[%g, %g]", $System, NIL, card[Reseal[party]], TU.RefAddr[party]];
IF ~RefID.Release[Reseal[party]] THEN nb ← $noSuchParty; -- ??
}
ELSE nb ← $noSuchParty;
Triples.Erase[$SmartsForHost, Any, smarts];
smarts.failed ← TRUE;
VoiceUtils.ReportFR[
"UnregisterSmarts[%g, %g]", $System, NIL, card[smartsID], TU.RefAddr[smarts]];
IF ~RefID.Release[smartsID] THEN ERROR; -- Having successfully dehandled above!
};
IdleConversationsForParty:
INTERNAL
PROC[party: PartyData] = {
This is now bogus. Fix it a bit later.
IdleOneConv: Triples.ForeachProc -- [trip: TripleRec]
-- RETURNS [continue: BOOLEAN ← TRUE] -- ={
WITH trip.att SELECT FROM r: ThPartyPrivate.ConvState => cfRef ← r; ENDCASE => RETURN[TRUE];
IF cfRef.event.state=idle THEN RETURN[FALSE];
[] ← ThPartyPrivate.DoAdvance[
smartsID: smartsID,
party: party,
conv: NARROW[trip.obj],
cfRef: cfRef,
state: $idle,
reason: $terminating]; -- Idle party in conversation!!
RETURN[FALSE];
};
IdleRelated: Triples.ForeachProc -- [trip: TripleRec]
-- RETURNS [continue: BOOLEAN ← TRUE] -- = {
IdleConversationsForParty[NARROW[trip.obj]];
};
Idle any conversations in which the party is involved. Outside loop avoids Foreach/Erase conflicts.
DO
cfRef←NIL;
Foreach[Any, Any, party, IdleOneConv];
IF cfRef = NIL THEN EXIT;
ENDLOOP;
Apply the process recursively to poachers and visitors: if a poacher is in a conversation, the poachee is not recorded as being in the same one; similarly for visitors, at least at present. But the poachee or visitee is always vital to the conversation's existence, so out it goes.
Triples.Foreach[$Poaching, Any, party, IdleRelated];
Triples.Foreach[$Visiting, Any, party, IdleRelated];
};
DescribeParty:
PUBLIC PROC[partyID: Thrush.PartyID, nameReq: ThParty.NameReq]
RETURNS[nb: NB, description: Thrush.ROPE] = {
a: ATOM;
[nb, description, a] ← GetRnameFromParty[ThPartyPrivate.UnsealParty[partyID], nameReq];
};
ThPartyPrivate Implementations
DoDescribeParty:
PUBLIC
PROC[ party: PartyData, nameReq: ThParty.NameReq ]
RETURNS[ description: Thrush.ROPE←NIL] = {
type: Thrush.PartyType ← party.type;
DescribeTrunk:
PROC
RETURNS[des:
ROPE] =
INLINE {
more: ROPE=IF party.outgoing#NIL THEN party.outgoing ELSE "outside line";
des ←
IF description=
NIL
THEN more
ELSE IO.PutFR["%s (%s)", IO.rope[description], IO.rope[more]];
};
Sel:
PROC[type: Thrush.PartyType, party: PartyData]
RETURNS [name: Thrush.
ROPE] = {
a: ATOM ← NARROW[Triples.Select[$trunk, -- owner --, party]];
RETURN[IF a=NIL THEN NIL ELSE Atom.GetPName[a]];
};
IF nameReq=$none THEN RETURN;
description ←
SELECT type
FROM
$individual, $telephone => party.name,
$trunk => (
SELECT nameReq
FROM
$owner => Sel[$trunk, party],
$description => DescribeTrunk[],
$current => party.name,
$address => party.outgoing,
ENDCASE=>ERROR),
$service => (
SELECT nameReq
FROM
$owner => party.name.Concat[larkRegistry],
$description => IO.PutFR["%g service", rope[party.name]],
$current, $address => Sel[$service, party],
ENDCASE=>ERROR),
ENDCASE => ERROR;
};
GetRnameFromParty:
PROC[party: PartyData, nameReq: ThParty.NameReq←$current]
RETURNS [nb: NB←$success, rName: Thrush.ROPE←NIL, rAtom: ATOM←NIL] = {
Returns (bogus) service name if type = $service
IF party=NIL THEN RETURN[nb: $noSuchParty];
rName ← DoDescribeParty[party, nameReq];
IF rName=NIL THEN nb ← $noNameAvailable
ELSE rAtom ← VoiceUtils.MakeAtom[rName];
};
MakeServiceRname:
PUBLIC
PROC[serviceName: Thrush.
ROPE]
RETURNS [serviceRname: Thrush.ROPE, serviceRnameAtom: ATOM] = {
serviceRname ← Rope.Cat[serviceName, larkRegistry];
serviceRnameAtom ← VoiceUtils.MakeAtom[serviceRname];
};
Which party should we be when initiating calls?
GetCurrentParty:
PUBLIC
ENTRY PROC[shh: Thrush.
SHHH←none, smartsID: Thrush.SmartsID]
RETURNS [nb: NB←$success, partyID: Thrush.PartyID←Thrush.nullID] = {
smarts: REF ← ThPartyPrivate.UnsealSmarts[smartsID];
party: PartyData;
p: PartyData;
IF smarts=NIL THEN RETURN[nb: $noSuchSmarts];
party ← NARROW[Triples.Select[$Smarts, --party--, smarts]];
IF party#NIL AND ~party.enabled THEN RETURN[nb: $noSuchParty];
IF party=NIL THEN { VoiceUtils.Problem["No party?"]; RETURN[nb: $noSuchParty]; };
SetPoaching[party]; -- make sure $Poaching link is correct
IF (p←
NARROW[Triples.Select[$Poaching,
-- poacher --, party]])#
NIL
AND p.enabled THEN party ← p;
partyID ← Reseal[party];
};
EraseAsObj:
INTERNAL
PROC[obj:
REF, attributes:
LIST
OF
ATOM] = {
FOR attr:
LIST
OF
ATOM ← attributes, attr.rest
WHILE attr#
NIL
DO
Triples.Erase[attr.first, obj, Any];
ENDLOOP;
};
Initialization
ReportSystem: VoiceUtils.WhereProc = { s←
NIL; };
ReportParty: VoiceUtils.WhereProc = {
party: PartyData = NARROW[whereData];
smarts: SmartsData;
IF party=
NIL
OR
( smarts ← NARROW[Triples.Select[$VoiceTerminal, party, Any]] ) = NIL THEN RETURN;
SELECT smarts.properties.role
FROM
$voiceTerminal => s←Nice.LarkConLogStream[smarts.properties.machine]; ENDCASE;
IF s=NIL OR s=Nice.LarkConLogStream[[[0],[0]]] THEN s←VoiceUtils.FindWhere[$System, NIL];
};
WhitePagesInit: Commander.CommandProc = {
treeName, intExtName: ROPE;
IF wpState#NIL AND ThNet.CloseWhitePagesDatabase[wpState] THEN wpState←NIL;
treeName ← CommandTool.NextArgument[cmd];
intExtName ← CommandTool.NextArgument[cmd];
IF wpState=
NIL
THEN wpState ← ThNet.InitWhitePagesDatabase[
treeName, -- Optional, defaults supplied by WP impl.,
intExtName, -- so NILs are OK here
$write];
};
serverInterfaceName: ThPartyRpcControl.InterfaceName;
serverPassword: RPC.EncryptionKey;
ThPartyInit: Commander.CommandProc = {
ENABLE
RPC.ExportFailed => { VoiceUtils.Problem["ThParty export failed", $System]; GOTO Failed; };
serverInterfaceName ← [
type: "ThParty.Lark",
instance: VoiceUtils.CmdOrToken[cmd: cmd, key: "ThrushServerInstance", default: "Morley.Lark"],
version: ThVersions.ThrushVR];
serverPassword ← VoiceUtils.CurrentPasskey[VoiceUtils.CmdOrToken[
cmd: cmd, key: "ThrushServerPassword", default: "MFLFLX"]];
IF thPartyExported THEN RETURN;
VoiceUtils.RegisterWhereToReport[ReportSystem, $System];
VoiceUtils.RegisterWhereToReport[ReportParty, $Party];
ThPartyRpcControl.ExportInterface[
interfaceName: serverInterfaceName,
user: serverInterfaceName.instance,
password: serverPassword];
ExplicitExport.ExportExplicitly["ThParty.Lark", serverInterfaceName.instance, ThVersions.ThrushVR, ThPartyRpcControl.LupineProtocolVersion, ThPartyRpcServerImpl.ServerDispatcher];
VoiceUtils.ReportFR["Export[ThParty.Lark, %s]", $System, NIL, rope[serverInterfaceName.instance]];
thPartyExported ← TRUE;
EXITS
Failed => ThPartyRpcControl.UnexportInterface[!LupineRuntime.BindingError=>CONTINUE];
};
Commander.Register["WhitePages", WhitePagesInit, "WhitePages <TreeName (opt.) <IntExtMapFileName (opt)>> -- Initialize and Open White Pages Database"];
Commander.Register["ThParty", ThPartyInit,
"ThParty <ExportInstance(opt.) <ServerPassword (opt)>> -- Initialize and Export ThParty"];
}.
Log
Swinehart, May 15, 1985 10:24:49 am PDT
Cedar 6.0
changes to: larkRegistry, GetParty, GetActiveParty, GeIdleParty, CreateParty, NewParty
Swinehart, May 16, 1985 9:18:28 am PDT
CommandToolExtras zapped.
Swinehart, May 22, 1985 12:01:41 pm PDT
ServiceName changes
recording => service
Jay => serviceName, to generalize
individual and service treated similarly in places
changes to: GetIdleParty, CreateParty, NewParty, DoDescribeParty, MakeServiceRname
changes to: CreateParty, ExistingParty, NewParty, DoDescribeParty
changes to: GetIdleParty
changes to: CreateParty, ExistingParty, NewParty
Swinehart, October 25, 1985 6:45:23 pm PDT
Handle => ID, NamesAndLog => VoiceUtils
changes to: DIRECTORY, ThPartyInitImpl, GetActiveParty, GetIdleParty, CreateParty, ExistingParty, DoRegister, RegisterClone, Deregister, EnterSmarts, MakeServiceRname, GetStdRingInfo, ReportSystem, ReportParty, ThPartyInit, ConversationID, PartyID, SmartsID, nullID, Reseal, GetParty, GetPartyFromFeepNum, GetPartyFromNumber, GetPartyFromNumberInt, GetTrunkParty, GetRname, Register, RegisterLocal, EnterSmartsE (local of EnterSmarts), Enable, Disable, DescribeParty, DoDescribeParty, GetCurrentParty, GetPartySmarts, SetStdRingInfo, SetRingEnable, NewParty
Swinehart, October 29, 1985 5:55:37 pm PST
Major revisions for visiting and poaching. See design document.
changes to: CreateParty, Register, RegisterLocal, DoRegister, EnterSmarts, Able, Deregister, PrepareRingTune, GetPartyFromNumber, GetRname, DescribeParty, GetActiveParty, GetIdleParty, GetPartyFromNumberInt, GetTrunkParty, Deregister, Deregister, EraseAsObj, Deregister