DIRECTORY
BasicTime USING [ Now ],
Convert USING [ IntFromRope ],
IO,
LoganBerry USING [ AttributeType, AttributeValue, DeleteEntry, Entry, Error, ErrorCode, Open, OpenDB, ReadEntry, WriteEntry ],
LoganBerryRpcControl USING [ ImportInterface, UnimportInterface ],
LupineRuntime USING [ BindingError ],
RefID USING [ nullID ],
Rope USING [ Concat, Equal, ROPE ],
RPC USING [ CallFailed, CallFailure, ImportFailed ],
Thrush USING [EncryptionKey, nullKey, Tune, VoiceInterval],
VoiceDB USING [ ErrorCode ],
VoiceUtils USING [ CurrentRName ]
;

VoiceDBImpl: CEDAR PROGRAM
IMPORTS BasicTime, Convert, IO, LoganBerry, LoganBerryRpcControl, LupineRuntime, Rope, RPC, VoiceUtils EXPORTS VoiceDB = {
OPEN IO;

VoiceDBHandle: TYPE = REF VoiceDBHandleRec;
VoiceDBHandleRec: PUBLIC TYPE = RECORD [
tunesDB: LoganBerry.OpenDB_RefID.nullID,
tuneRefDB: LoganBerry.OpenDB_RefID.nullID,
tunesDBName: Rope.ROPE,
tuneRefDBName: Rope.ROPE,
instance: Rope.ROPE,
imported: BOOL_FALSE
];

nullKey: Thrush.EncryptionKey _ Thrush.nullKey;


Error: PUBLIC ERROR[ec: VoiceDB.ErrorCode, explanation: Rope.ROPE_NIL] = CODE;

Open: PUBLIC PROC[ dbName, instance, localName: Rope.ROPE ]
RETURNS [ handle: VoiceDBHandle_NIL, openEc: VoiceDB.ErrorCode_NIL, expl: Rope.ROPE ] = {
ENABLE {
RPC.CallFailed => []_PostRPCError[handle, why, TRUE];
Error => { openEc _ ec; expl _ explanation; GOTO ReturnAnyway; };
LoganBerry.Error => []_PostLBError[ec, explanation, TRUE, dbName];
};
handle _ NEW[VoiceDBHandleRec _ [
tunesDBName: dbName.Concat[".df"], tuneRefDBName: dbName.Concat["Refs.df"]]];
handle.instance _ instance;
dbName _ handle.tunesDBName;
handle.tunesDB _ OpenLB[handle: handle, dbName: handle.tunesDBName];
dbName _ handle.tuneRefDBName;
handle.tuneRefDB _ OpenLB[handle: handle, dbName: handle.tuneRefDBName];
EXITS
ReturnAnyway => NULL; -- return incomplete handle.
};

Create: PUBLIC PROC[
handle: VoiceDBHandle,
tune: INT,
creator: Rope.ROPE,
interval: Thrush.VoiceInterval,
key: Thrush.EncryptionKey,
otherAttributes: LoganBerry.Entry
]
RETURNS [voiceFileID: Rope.ROPE_NIL, entry: LoganBerry.Entry_NIL] = TRUSTED {
reopening: BOOL_FALSE; {
ENABLE {
RPC.CallFailed => IF (reopening _ PostRPCError[handle, why, reopening]) THEN RETRY;
LoganBerry.Error =>
IF (reopening _ PostLBError[ec, explanation, reopening, handle.tunesDBName])
THEN RETRY;
};
cardKey: LONG POINTER TO ARRAY[0..2) OF LONG CARDINAL=LOOPHOLE [LONG[@key]];
keyRope: Rope.ROPE = IO.PutFR["%bB %bB", IO.card[cardKey[0]], IO.card[cardKey[1]]]; 
voiceFileID _ IO.PutFR["%g %g", int[tune], time[BasicTime.Now[]]];
IF creator=NIL THEN creator _ VoiceUtils.CurrentRName[];
entry _ CONS[
[$vid, voiceFileID], CONS[
[$cre, creator], CONS[
[$sta, IO.PutFR["%g", int[interval.start]]], CONS[
[$num, IO.PutFR["%g", int[interval.length]]], CONS[
[$key, keyRope],
otherAttributes
]]]]];
IF reopening THEN handle.tunesDB _ OpenLB[handle:handle, dbName:handle.tunesDBName];
reopening _ FALSE;
LoganBerry.WriteEntry[ db: handle.tunesDB, entry: entry];
}; };

Retain: PUBLIC PROC[
handle: VoiceDBHandle,
voiceFileID: Rope.ROPE, 
refID: Rope.ROPE,
refIDType: Rope.ROPE,
creator: Rope.ROPE,
otherAttributes: LoganBerry.Entry
]
RETURNS [entry: LoganBerry.Entry_NIL] = {
reopening: BOOL_FALSE; {
ENABLE {
RPC.CallFailed => IF (reopening _ PostRPCError[handle, why, reopening]) THEN RETRY;
LoganBerry.Error => IF (reopening _ 
PostLBError[ec, explanation, reopening, handle.tuneRefDBName]) THEN RETRY;
};
newTim, newVid: BOOL_FALSE;
IF creator=NIL THEN creator _ VoiceUtils.CurrentRName[];
IF reopening THEN handle.tuneRefDB _
OpenLB[handle: handle, dbName: handle.tuneRefDBName];
reopening _ FALSE;
entry _ Query[handle, NIL, refID, refIDType].refEntry;
IF entry = NIL THEN
entry _ CONS[
[$rid, refID], CONS[
[$rtp, refIDType], CONS[
[$cre, creator],
otherAttributes
]]];
[entry, newTim] _ IncludeAttr[entry, $tim, IO.PutFR["%g", time[BasicTime.Now[]]], TRUE];
[entry, newVid] _ IncludeAttr[entry, $vid, voiceFileID, FALSE];
IF newTim OR newVid THEN Replace[handle.tuneRefDB, $rid, entry];
}; };

 IncludeAttr: PROC[
entry: LoganBerry.Entry,
key: LoganBerry.AttributeType,
value: LoganBerry.AttributeValue,
replace: BOOL
] RETURNS [newEntry: LoganBerry.Entry, isNew: BOOL_TRUE] = {
FOR e: LoganBerry.Entry _ entry, e.rest WHILE e#NIL DO
IF key=e.first.type THEN {
IF replace THEN { e.first.value _ value; RETURN[entry, TRUE]; };
IF value#NIL AND value.Equal[e.first.value, FALSE] THEN RETURN[entry, FALSE];
};
ENDLOOP;
newEntry _ CONS[ [key, value], entry];
};

Forget: PUBLIC PROC[
handle: VoiceDBHandle,
refID: Rope.ROPE,
refIDType: Rope.ROPE
] = {
reopening: BOOL_FALSE; {
ENABLE {
RPC.CallFailed => IF (reopening _ PostRPCError[handle, why, reopening]) THEN RETRY;
LoganBerry.Error => IF (reopening _
PostLBError[ec, explanation, reopening, handle.tuneRefDBName]) THEN RETRY;
};
IF reopening THEN handle.tuneRefDB _ OpenLB[handle: handle, dbName: handle.tuneRefDBName];
reopening _ FALSE;
LoganBerry.DeleteEntry[db: handle.tuneRefDB, key: $rid, value: refID!
LoganBerry.Error => IF ec=$NoIndex THEN CONTINUE];
}; };

Query: PUBLIC PROC [
handle: VoiceDBHandle,
voiceFileID: Rope.ROPE,
refID: Rope.ROPE,
refIDType: Rope.ROPE
] RETURNS [
tune: Thrush.Tune_-1, 
interval: Thrush.VoiceInterval,
key: Thrush.EncryptionKey_Thrush.nullKey,
voiceEntry: LoganBerry.Entry_NIL,
refEntry: LoganBerry.Entry_NIL
] = TRUSTED {
reopening: BOOL_FALSE; {
ENABLE {
RPC.CallFailed => IF (reopening _ PostRPCError[handle, why, reopening]) THEN RETRY;
LoganBerry.Error => IF (reopening _ 
PostLBError[ec, explanation, reopening, handle.tuneRefDBName]) THEN RETRY;
};
cardKey: LONG POINTER TO ARRAY[0..2) OF LONG CARDINAL=LOOPHOLE[LONG[@key]];
keyStream: IO.STREAM;
IF (refID#NIL AND refIDType=NIL) OR
((refID=NIL) = (voiceFileID=NIL)) THEN
Error[$clientError, "\nQuery specifies both refID and voiceFileID, or refIDType omitted."];
IF refID#NIL THEN {
IF reopening THEN handle.tuneRefDB _OpenLB[handle: handle, dbName:handle.tuneRefDBName];
reopening _ FALSE;
refEntry _ LoganBerry.ReadEntry[db: handle.tuneRefDB, key: $rid, value: refID!
LoganBerry.Error => IF ec=$NoIndex THEN CONTINUE].entry;
IF refEntry=NIL THEN RETURN;
IF ~GetAttr[refEntry, $rtp].Equal[refIDType] THEN
Error[$clientError, "\nWrong refIDType specified."];
voiceFileID _ GetAttr[refEntry, $vid];
};
{ -- Now refID scene is OK; separate LoganBerry error management for voiceFileID
ENABLE LoganBerry.Error => IF (reopening _ 
PostLBError[ec, explanation, reopening, handle.tunesDBName]) THEN RETRY;
IF voiceFileID=NIL THEN RETURN;
IF reopening THEN handle.tunesDB_OpenLB[handle: handle, dbName: handle.tunesDBName];
reopening _ FALSE;
voiceEntry _ LoganBerry.ReadEntry[db: handle.tunesDB, key: $vid, value: voiceFileID!
LoganBerry.Error => IF ec=$NoIndex THEN CONTINUE].entry;
IF voiceEntry=NIL THEN RETURN;
tune _ Convert.IntFromRope[voiceFileID];
interval _ [
Convert.IntFromRope[GetAttr[voiceEntry, $sta]],
Convert.IntFromRope[GetAttr[voiceEntry, $num]]];
keyStream _ IO.RIS[GetAttr[voiceEntry, $key]];  
cardKey[0] _ IO.GetCard[keyStream];
cardKey[1] _ IO.GetCard[keyStream];
};
}; };

Replace: PROC[
db: LoganBerry.OpenDB, key: LoganBerry.AttributeType, entry: LoganBerry.Entry] = {
LoganBerry.WriteEntry[ db: db, entry: entry!
LoganBerry.Error => IF ec=$ValueNotUnique THEN GOTO DeleteFirst];
EXITS
DeleteFirst => {
LoganBerry.DeleteEntry[db: db, key: key, value: GetAttr[entry, key]];
LoganBerry.WriteEntry[ db: db, entry: entry];
};
};

GetAttr: PROC[entry: LoganBerry.Entry, key: LoganBerry.AttributeType]
RETURNS[value: LoganBerry.AttributeValue_NIL] = {
FOR ls: LoganBerry.Entry _ entry, ls.rest WHILE ls # NIL DO
IF ls.first.type = key THEN RETURN[ls.first.value];
ENDLOOP;
};

PostLBError: PROC[
ec: LoganBerry.ErrorCode,
explanation: Rope.ROPE,
reopening: BOOL,
dbName: Rope.ROPE
]
RETURNS[retry: BOOL_FALSE] = {
SELECT ec FROM
$CantOpenSchema, $CantOpenLog, $CantOpenIndex=>
Error[$dbNotFound, IO.PutFR["\n%g: %g", rope[dbName], rope[explanation]]];
$BadSchema, $BadLogEntry, $BadIndex, $LogReadOnly => Error[$invalid,
IO.PutFR["%g: %g", rope[dbName], rope[explanation]]];
$DBNotAvailable => Error[$notAvailable,
IO.PutFR["\n%g: %g", rope[dbName], rope[explanation]]];
$DBClosed, $BadDBHandle =>
IF reopening THEN {
Error[$notAvailable,
IO.PutFR["\n%g: %g", rope[dbName], rope[explanation]]]
}
ELSE RETURN[retry: TRUE];
$ValueNotUnique => Error[$voiceIDNotUnique,
IO.PutFR["\n%g: %g", rope[dbName], rope[explanation]]];
$NoIndex => Error[$refIDNotFound,
IO.PutFR["\n%g: %g", rope[dbName], rope[explanation]]];
$NoPrimaryKey => Error[$clientError,
IO.PutFR["\n%g: %g", rope[dbName], rope[explanation]]] 
ENDCASE; -- All others expected to propagate as uncaught signals
};

PostRPCError: PROC[
handle: VoiceDBHandle,
why: RPC.CallFailure,
reopening: BOOL
]
RETURNS[retry: BOOL] = {
SELECT why FROM
$timeout, $busy =>
Error[$communications, IO.PutFR["\nNo response from voice message database %g", rope[handle.instance]]];
$runtimeProtocol, $stubProtocol => Error[$invalid,
"\nProtocol violation in communications with voice message database"];
$unbound =>
IF ~reopening THEN { -- Force reopening of all databases
handle.tunesDB _ handle.tuneRefDB _ RefID.nullID;
handle.imported _ FALSE;
RETURN[TRUE];
}
ELSE Error[$invalid,
IO.PutFR["\nCan't bind to voice message database instance %g", rope[handle.instance]]];
ENDCASE=>ERROR;
};

OpenLB: PROC[handle: VoiceDBHandle, dbName: Rope.ROPE]
RETURNS [db: LoganBerry.OpenDB] = {
IF ~handle.imported THEN ImportLoganberry[handle];
db _ LoganBerry.Open[dbName: dbName];
};

ImportLoganberry: PROC[handle: VoiceDBHandle] = {
ENABLE {
RPC.ImportFailed => Error[$NotFound,
IO.PutFR["Could not import Loganberry from %g", rope[handle.instance]]];
};
TRUSTED {
LoganBerryRpcControl.UnimportInterface[!LupineRuntime.BindingError => CONTINUE];};
LoganBerryRpcControl.ImportInterface[["Loganberry.Lark", handle.instance]];
handle.tunesDB _ handle.tuneRefDB _ RefID.nullID;
handle.imported _ TRUE;
};
}.

8VoiceDBImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Swinehart, May 19, 1986 9:21:00 am PDT
Definitions

Concrete implementation of VoiceDB.VoiceDBHandle
Interface procedures
{
openEc _ $communications;
expl _  IO.PutFR["No response from %g", rope[instance]];
GOTO ReturnAnyway;
};
VoiceDB errors raised in called routines propagate to client

 This version of VoiceDBImpl only knows how to open remote instances.  We get into binder fun and games to do the local/remote thing. 
Error[$communications,
IO.PutFR["No response from %g", rope[handle.instance]]];
RPC.CallFailed => Error[$communications,
IO.PutFR["No response from %g", rope[handle.instance]]];
VoiceDB errors raised in called routines also propagate to client
TRUE means change value associated with (secondary) key, FALSE means add new value unless this value already exists.
RPC.CallFailed => Error[$communications,
IO.PutFR["No response from %g", rope[handle.instance]]];
VoiceDB errors raised in called routines also propagate to client
RPC.CallFailed => Error[$communications,
IO.PutFR["No response from %g", rope[handle.instance]]];
VoiceDB errors raised in called routines also propagate to client
All errors managed higher-up
Swinehart, May 19, 1986 9:20:57 am PDT
Cedar 6.1
changes to: DIRECTORY, VoiceDBImpl, Create, Retain

ΚΛ˜š
œ™Icodešœ
Οm
œ7™BK™&—J˜š
Οk	˜	Jšœ
žœ	˜J˜Jšžœ
˜Jšœžœn˜~Jšœžœ(˜BJšœžœ˜%Jšœžœ˜Jšœžœžœ˜#Jšžœ
žœ+˜4Jšœžœ/˜;Jš
œ˜Jš
œ!˜!Jš
œ
˜
J˜—šœ
žœ
ž˜Jšžœžœ9žœ
žœ˜zJšžœ
žœ
˜—J˜™J™Jšœžœžœ˜+šœžœ
žœžœ˜(Kš
œ0™0Kš
œ(˜(Kš
œ*˜*Kšœžœ
˜Kšœžœ
˜Kšœž˜Kšœ
žœ
ž˜K˜K˜—J˜/J˜—™J˜Jšœžœ
žœ*žœ
žœžœ
˜NJ˜šΟnœžœ
žœ$žœ˜;Jšžœžœžœ
žœ˜Yšžœ˜Jšžœ,žœ˜5š
œ
™
Jš
œ™Jšœžœ.™8Jšžœ™Jš
œ™—Jšœ,žœ˜AJšœ4žœ
˜BJ™<J˜—šœ	žœ˜!Jš
œM˜M—˜J™ˆ
—Jš
œ˜Jš
œD˜DJš
œ˜Jš
œH˜Hš
ž˜JšœžœΟc˜2—J˜—J˜šŸœžœ
žœ
˜Jš
œ˜Jšœžœ
˜
Jšœžœ
˜J˜Jš
œ˜Jš
œ!˜!J˜
Jš
žœžœ
žœžœžœ˜MJšœžœ
žœΟb
˜šžœ˜šžœžœ4žœ
žœ
˜SJš
œ™Jšžœ6™8—š
œ˜šžœJ˜LJšžœ
žœ
˜——Jš
œ˜—Jšœ	žœ
žœ
žœ
žœžœ
žœ
žœ
žœžœ˜LJš	œžœžœžœžœ˜TJšœžœ2˜BJšžœ	žœ
žœ%˜8šœžœ
˜
Jšœžœ
˜Jšœžœ
˜Jšœžœ#žœ
˜2Jšœžœ$žœ
˜3Jš
œ˜Jš
œ˜Jš
œ˜—JšžœžœC˜TJšœžœ
˜Jš
œ9˜9š‘œ˜J˜——šŸœžœ
žœ
˜Jš
œ˜Jšœžœ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jš
œ!˜!Jš
œ
˜
Jšžœžœ˜)Jšœžœ
žœ‘
˜šžœ˜Jšžœžœ4žœ
žœ
˜Sšžœ%™(Jšžœ6™8—šœžœ˜$Jšœ?žœ
žœ
˜J—J™AJš
œ˜—Jšœžœ
žœ
˜Jšžœ	žœ
žœ%˜8šžœžœ˜$Jš
œ5˜5—Jšœžœ
˜Jšœžœ˜6šžœ	žœ
ž˜šœžœ
˜
Jšœžœ
˜Jšœžœ
˜Jš
œ˜J˜J˜——Jšœ+žœ%žœ˜XJšœ8žœ˜?Jšžœžœžœ(˜@Jš‘œ˜J˜—šŸœžœ
˜Jš
œ˜Jš
œ˜Jš
œ!˜!šœ	ž˜
Jš
œt™t—Jšœžœ%žœ
žœ˜<šžœ%žœžœ
ž˜6šžœžœ˜Jšžœ	žœžœžœ˜@Jšžœžœ
žœžœžœ
žœžœ˜MJ˜—Jšžœ
˜—Jšœžœ˜&J˜J˜—šŸœžœ
žœ
˜Jš
œ˜Jšœžœ
˜Jšœž˜Jš
œ˜Jšœžœ
žœ‘
˜šžœ˜Jšžœžœ4žœ
žœ
˜Sšžœ%™(Jšžœ6™8—šœžœ	ž˜#Jšœ?žœ
žœ
˜J—J™AJš
œ˜—JšžœžœI˜ZJšœžœ
˜š
œE˜EJšœžœ
žœ
žœ˜2—Jš‘œ˜J˜—šŸœžœ
žœ˜Jš
œ˜Jšœžœ
˜Jšœžœ
˜Jšœž˜Jšœžœ˜J˜J˜J˜)Jšœžœ
˜!Jšœž˜Jšœžœ˜
Jšœžœ
žœ‘
˜šžœ˜Jšžœžœ4žœ
žœ
˜Sšžœ%™(Jšžœ6™8—šœžœ	ž˜$Jšœ?žœ
žœ
˜J—J™AJš
œ˜—Jšœ	žœ
žœ
žœ
žœžœ
žœ
žœ
žœ
žœ˜KJšœžœ
žœ
˜šžœ
ž
œžœ
žœžœ
ž˜#šœžœžœž˜&Jš
œ[˜[——šžœžœ
žœ˜JšžœžœG˜XJšœžœ
˜š
œN˜NJšœžœ
žœ
žœ˜8—Jšžœ
žœ
žœ
žœ
˜šžœ+ž˜1Jš
œ4˜4—Jš
œ&˜&J˜—š‘ N˜Pšžœžœ˜+Jšœ=žœ
žœ
˜H—Jšžœ
žœ
žœ
žœ
˜JšžœžœC˜TJšœžœ
˜š
œT˜TJšœžœ
žœ
žœ˜8—Jšžœžœ
žœ
žœ
˜J˜(˜J˜/J˜0—Jšœžœ
žœ˜0Jšœ
žœ˜#Jšœ
žœ˜#Jš
‘˜—Jš‘œ˜J˜—šŸœžœ
˜Jš
œR˜Rš
œ,˜,Jšœžœžœ
žœ˜A—š
ž˜˜J˜EJš
œ-˜-J˜——J˜J˜—šŸœžœ8˜EJšžœ"žœ˜1šžœ'žœžœ
ž˜;Jšžœžœ
žœž
˜3Jšžœ
˜—J˜J˜—šŸœžœ
˜Jš
œ˜Jšœžœ
˜Jšœž˜Jšœ
ž˜Jš
œ
˜
Jšžœžœ
žœ˜šžœž˜š
œ/˜/Jšœžœ5˜J—š
œD˜DJšžœ3˜5—š
œ'˜'Jšžœ5˜7—˜šžœžœ˜š
œ˜Jšžœ4˜6—J˜
—Jšžœ
žœžœ˜—š
œ+˜+Jšžœ5˜7—š
œ!˜!Jšžœ5˜7—š
œ$˜$Jšžœ5˜7—Jšžœ 7˜@—J˜—J˜šŸœžœ
˜J˜Jšœžœ
˜Jšœž˜Jš
œ
˜
Jšžœžœ˜šžœž˜š
œ˜JšœžœO˜h—š
œ2˜2Jš
œF˜F—š
œ˜šžœžœ #˜8J˜1Jšœžœ
˜Jšžœ
žœ˜
J˜
—šžœ˜JšžœU˜W——Jšžœ
˜—J˜J˜—šŸœžœ%žœ
˜6Jšžœ˜#J™Jšžœžœ˜2J˜%J˜—J˜šŸœžœ˜1šžœ
ž
˜šžœ!˜$JšžœF˜H—J˜—šžœ˜	JšœFžœ˜R—Jš
œK˜KJ˜1Jšœžœ
˜J˜——Jš
œ˜J˜™&K™	KšœΟr&™2—K™—…—&Κ8Ν