DIRECTORY Commander, CommanderBackdoor, CommanderOps, IO, PFS, Process, Rope, RopeList, SymTab, InstallationComforts, InstallationSupportPrivate, MesaLoadState;

CommanderInstallCommandsImpl: CEDAR MONITOR
IMPORTS Commander, CommanderBackdoor, CommanderOps, IO, PFS, Process, Rope, RopeList, SymTab, InstallationComforts, MesaLoadState
EXPORTS MesaLoadState -- Opaque type
~ BEGIN

PATH: TYPE ~ PFS.PATH;
ROPE: TYPE ~ Rope.ROPE;

ConfigRep: PUBLIC TYPE ~ InstallationSupportPrivate.ConfigRep;
IsExported: PROC [qualifiedName: ROPE] RETURNS [BOOL] ~ {
global: REF ConfigRep = MesaLoadState.GlobalConfig[];
dot: INT ~ Rope.Find[qualifiedName, "."];
IF dot >= 0
THEN {
interface: ROPE ~ Rope.Substr[qualifiedName, 0, dot];
item: ROPE ~ Rope.Substr[qualifiedName, dot+1];
a: PROCEDURE ANY RETURNS ANY ~ InstallationComforts.ProcFromNamedInterface[interface, item, global];
RETURN [a # NIL]
}
ELSE {
RETURN [FALSE] -- might want to test for existence of the interface record
};
};

InstallData: TYPE = REF InstallDataPrivate;
InstallDataPrivate: TYPE = RECORD [
statuses: SymTab.Ref,
change: CONDITION
];

InstallStatus: TYPE = REF InstallStatusPrivate;
InstallStatusPrivate: TYPE = RECORD [
state: InstallState ฌ notDone,
foundFile: BOOL ฌ FALSE,
failed: BOOL ฌ TRUE
];

InstallState: TYPE = {notDone, inProgress, done};

installData: InstallData ฌ InitInstallData[];
InitInstallData: PROC RETURNS [installData: InstallData] ~ {
installData ฌ NEW [InstallDataPrivate ฌ [
statuses: SymTab.Create[case: FALSE]
]];
TRUSTED {
Process.InitializeCondition[@installData.change, Process.SecondsToTicks[60]];
Process.EnableAborts[@installData.change];
};
};

ForgetInstallationCommand: Commander.CommandProc = {
from: IO.STREAM = IO.RIS[cmd.commandLine];
FOR i: INT ฌ from.SkipWhitespace[], from.SkipWhitespace[] WHILE NOT from.EndOf[] DO
packageName: ROPE = from.GetTokenRope[IO.IDProc].token;
ForgetInstallation[packageName];
ENDLOOP;
};

ForgetInstallation: PUBLIC PROC [packageName: ROPE] = {
SetInstallState[installData, AcquireInstallStatus[installData, packageName], notDone];
};

Installed: PUBLIC PROC [packageName: ROPE] = {
status: InstallStatus ~ AcquireInstallStatus[installData, packageName];
status.failed ฌ FALSE;
SetInstallState[installData, status, done];
};

GetInstalled: PUBLIC ENTRY PROC RETURNS [LIST OF ROPE] = {
list: LIST OF ROPE ฌ NIL;
EachPair: PROC [key: ROPE, val: REF] RETURNS [quit: BOOL ฌ FALSE] ~ {
WITH val SELECT FROM
status: InstallStatus => {
IF status.state = done THEN list ฌ CONS[key, list];
};
ENDCASE => NULL;
};
[] ฌ SymTab.Pairs[installData.statuses, EachPair];
RETURN [RopeList.Sort[list, RopeList.IgnoreCase]]
};

IsInstalled: PUBLIC ENTRY PROC [key: ROPE] RETURNS [BOOL] = {
ENABLE UNWIND => NULL;
sought: InstallStatus ฌ NARROW[installData.statuses.Fetch[key].val];
RETURN [IF sought = NIL OR sought.state = notDone THEN FALSE ELSE TRUE];
};

IfInstalledCommand: Commander.CommandProc = {
ris: IO.STREAM ~ IO.RIS[cmd.commandLine];
resource: ROPE ~ CommanderOps.GetCmdToken[ris].value;
IF resource = NIL THEN CommanderOps.Failed[cmd.procData.doc];
IF (cmd.procData.clientData=$NOT) # IsInstalled[resource] THEN RETURN CommanderOps.ExecuteCommand[cmd, IO.GetRope[ris]];
};

IfProcExportedCommand: Commander.CommandProc = {
ris: IO.STREAM ~ IO.RIS[cmd.commandLine];
resource: ROPE ~ CommanderOps.GetCmdToken[ris].value;
IF resource = NIL THEN CommanderOps.Failed[cmd.procData.doc];
IF (cmd.procData.clientData=$NOT) # IsExported[resource] THEN RETURN CommanderOps.ExecuteCommand[cmd, IO.GetRope[ris]];
};

whenInstalled: SymTab.Ref ฌ SymTab.Create[case: FALSE];
WhenInstalled: PUBLIC ENTRY PROC [key: ROPE, commandLine: ROPE] RETURNS [doItNow: BOOL ฌ FALSE] = {
ENABLE UNWIND => NULL;
sought: InstallStatus ฌ NARROW[installData.statuses.Fetch[key].val];
doItNow ฌ NOT (sought = NIL OR sought.state = notDone);
IF NOT doItNow THEN {
Update: SymTab.UpdateAction ~ {
actions: LIST OF ROPE ฌ NARROW[val];
IF actions = NIL
THEN actions ฌ LIST[commandLine]
ELSE FOR tail: LIST OF ROPE ฌ actions, tail.rest DO
IF tail.rest = NIL THEN {tail.rest ฌ LIST[commandLine]; EXIT};
ENDLOOP;
RETURN [op: store, new: actions];
};
SymTab.Update[whenInstalled, key, Update];
};
};

WhenInstalledCommand: Commander.CommandProc = {
ris: IO.STREAM ~ IO.RIS[cmd.commandLine];
resource: ROPE ~ CommanderOps.GetCmdToken[ris].value;
IF resource = NIL
THEN {
PrintEachPair: SymTab.EachPairAction ~ {
FOR tail: LIST OF ROPE ฌ NARROW[val], tail.rest UNTIL tail = NIL DO
IO.PutRope[cmd.out, "WhenInstalled "];
IO.PutRope[cmd.out, key];
IO.PutRope[cmd.out, " "];
IO.PutRope[cmd.out, tail.first];
ENDLOOP;
};
[] ฌ SymTab.Pairs[whenInstalled, PrintEachPair];
}
ELSE {
commandLine: ROPE ~ Rope.Cat["From ", PFS.RopeFromPath[PFS.GetWDir[]], IO.GetRope[ris]];
doItNow: BOOL ~ WhenInstalled[resource, commandLine];
IF doItNow THEN RETURN CommanderOps.ExecuteCommand[cmd, commandLine];
};
};

RequireCommand: Commander.CommandProc = {
ENABLE PFS.Error => { IF error.group=user THEN ERROR CommanderOps.Failed[error.explanation] };
world: ROPE ~ CommanderOps.NextArgument[cmd];
component: ROPE ~ CommanderOps.NextArgument[cmd];
resource: ROPE ~ CommanderOps.NextArgument[cmd];
found, failed: BOOL;
IF CommanderOps.NextArgument[cmd] # NIL OR resource = NIL THEN CommanderOps.Failed[cmd.procData.doc];
[found, failed] ฌ Require[world: world, component: component, resource: resource, parent: cmd];
SELECT TRUE FROM
NOT failed => { NULL };
NOT found => {
result ฌ $Failure;
msg ฌ msg.Cat["Failed to find ", resource, ".require file.\n"];
};
ENDCASE => {
result ฌ $Failure;
msg ฌ msg.Cat[resource, ".require file ", " failed.\n"];
};
};

InstallCommand: Commander.CommandProc = {
ENABLE PFS.Error => { IF error.group=user THEN ERROR CommanderOps.Failed[error.explanation] };
again: BOOL ฌ FALSE;
n: NAT ฌ 0;
FOR resource: ROPE ฌ CommanderOps.NextArgument[cmd], CommanderOps.NextArgument[cmd] UNTIL resource = NIL DO
n ฌ n + 1;
SELECT TRUE FROM
resource.Equal["-a", FALSE] => again ฌ TRUE;
resource.Equal["-~a", FALSE] => again ฌ FALSE;
ENDCASE => {
found, failed: BOOL;
IF again THEN ForgetInstallation[resource];
[found, failed] ฌ Install[resource, cmd];
SELECT TRUE FROM
NOT failed => { NULL };
NOT found => {
result ฌ $Failure;
msg ฌ msg.Cat["Failed to find ", resource, ".require file.\n"];
};
ENDCASE => {
result ฌ $Failure;
msg ฌ msg.Cat[resource, ".require file ", " failed.\n"];
};
};
ENDLOOP;
IF n = 0 THEN RETURN [$Failure, "Install (-a|-~a|packageName)* - Ensure the installation of one or more packages. -a => install again, even if already installed"];
};

InstalledCommand: Commander.CommandProc = {
n: NAT ฌ 0;
FOR arg: ROPE ฌ CommanderOps.NextArgument[cmd], CommanderOps.NextArgument[cmd] UNTIL arg = NIL DO
Installed[arg];
n ฌ n + 1;
ENDLOOP;
IF n = 0 THEN {
FOR tail: LIST OF ROPE ฌ GetInstalled[], tail.rest UNTIL tail = NIL DO
IO.PutRope[cmd.out, tail.first];
IO.PutRope[cmd.out, IF tail.rest = NIL THEN "\n" ELSE " "];
ENDLOOP;
};
};

SecondSource: PUBLIC PROC
[fileName: ROPE, parent: Commander.Handle, stopOnFailure: BOOL ฌ FALSE]
RETURNS [allOK: BOOL ฌ FALSE] = {
fileStream: IO.STREAM ~ PFS.StreamOpen[PFS.PathFromRope[fileName]];
BEGIN ENABLE UNWIND => { IO.Close[fileStream, TRUE] };
child: Commander.Handle ~ CommanderOps.CreateFromStreams[in: fileStream, parentCommander: parent];
data: CommanderBackdoor.CommandToolData ~ CommanderBackdoor.GetCommandToolData[child];
data.stopOnFailure ฌ stopOnFailure;
allOK ฌ NOT CommanderOps.ReadEvalPrintLoop[child].hadFailure;
END;
IO.Close[fileStream, TRUE];
};

Install: PUBLIC PROC [packageName: ROPE, parent: Commander.Handle]
RETURNS [foundFile, failed: BOOL] = {
status: InstallStatus = AcquireInstallStatus[installData, packageName];
SELECT status.state FROM
notDone => ERROR;
inProgress => {
finalState: InstallState ฌ done;
{ ENABLE UNWIND => { SetInstallState[installData, status, notDone] };
installFileName: ROPE = packageName.Concat[".require"];
foundFile ฌ TRUE;
[] ฌ PFS.FileInfo[PFS.PathFromRope[installFileName] ! PFS.Error => IF error.group = user THEN { foundFile ฌ FALSE; CONTINUE } ];
SELECT status.foundFile ฌ foundFile FROM
FALSE => { finalState ฌ notDone; failed ฌ TRUE };
TRUE => {
status.failed ฌ failed ฌ NOT SecondSource[installFileName, parent, stopOnFailureDuringInstall];
IF failed THEN finalState ฌ notDone;
};
ENDCASE => ERROR;
};
SetInstallState[installData, status, finalState];
};
done => { foundFile ฌ status.foundFile; failed ฌ status.failed };
ENDCASE => ERROR;
IF NOT failed THEN {
commandLines: LIST OF ROPE ฌ NIL;
Update: SymTab.UpdateAction ~ {
IF found THEN { commandLines ฌ NARROW[val]; RETURN [op: delete] };
};
SymTab.Update[whenInstalled, packageName, Update];
FOR tail: LIST OF ROPE ฌ commandLines, tail.rest UNTIL tail = NIL DO
[] ฌ CommanderOps.DoCommand[tail.first, parent];
ENDLOOP;
};
};
stopOnFailureDuringInstall: BOOL ฌ TRUE;

Require: --PUBLIC-- PROC [world, component, resource: ROPE, parent: Commander.Handle]
RETURNS [foundFile, failed: BOOL ฌ FALSE] = {
RequireInner: PROC ~ {
[foundFile, failed] ฌ Install[resource, parent];
};
path: PATH ~ PFS.PathFromRope[Rope.Cat["/", world, "/", component, "/"]];
PFS.DoInWDir[path, RequireInner];
};

AcquireInstallStatus: ENTRY PROC [d: InstallData, packageName: ROPE]
RETURNS [sought: InstallStatus] = {
ENABLE UNWIND => {};
sought ฌ NARROW[d.statuses.Fetch[packageName].val];
IF sought = NIL THEN {
sought ฌ NEW [InstallStatusPrivate ฌ []];
IF NOT d.statuses.Insert[packageName, sought] THEN ERROR;
};
WHILE sought.state = inProgress DO WAIT d.change ENDLOOP;
IF sought.state = notDone THEN sought.state ฌ inProgress;
};

SetInstallState: ENTRY PROC [d: InstallData, status: InstallStatus, state: InstallState] = {
ENABLE UNWIND => {};
status.state ฌ state;
BROADCAST d.change;
};
Commander.Register[key: "ForgetInstallation", proc: ForgetInstallationCommand, doc: "ForgetInstallation packageName* - Forget that one or more packages are installed", clientData: NIL];
Commander.Register[key: "IfInstalled", proc: IfInstalledCommand, doc: "packageName commandLine\ndo the commandLine if the named package has been installed", clientData: NIL];
Commander.Register[key: "IfNotInstalled", proc: IfInstalledCommand, doc: "packageName commandLine\ndo the commandLine if the named package has not been installed", clientData: $NOT];
Commander.Register[key: "IfProcExported", proc: IfProcExportedCommand, doc: "interface.procedure commandLine\ndo the commandLine if the named procedure is exported", clientData: NIL];
Commander.Register[key: "IfProcNotExported", proc: IfProcExportedCommand, doc: "interface.procedure commandLine\ndo the commandLine if the named procedure is not exported", clientData: $NOT];
Commander.Register[key: "Install", proc: InstallCommand, doc: "Install (-a|-~a|packageName)* - Ensure the installation of one or more packages. -a => install again, even if already installed", clientData: NIL];
Commander.Register[key: "Installed", proc: InstalledCommand, doc: "packageName ... - Record the named packages as having been installed\n  (no args tells you what has been installed)", clientData: NIL];
Commander.Register[key: "Require", proc: RequireCommand, doc: "Usage: Require <world> <component> <resource> - Ensure the installation of a resource", clientData: NIL];
Commander.Register[key: "WhenInstalled", proc: WhenInstalledCommand, doc: "packageName commandLine\ndo the commandLine as soon as the named package becomes installed\n(no arguments => print the pending commands)", clientData: $NOT];
Installed["BasicCedar"];
Installed["CedarCore"];
Installed["Commander"];
IF IsExported["BootTime.Get"]
THEN Installed["DebugNubCedarParts"];
IF IsExported["Feedback.Append"]
THEN Installed["Feedback"];
IF IsExported["LocalRegistryAgent.MaintainService"]
THEN Installed["LocalRegistryAgent"];
IF IsExported["LocalRegistryClient.Register"]
THEN Installed["LocalRegistryClient"];
IF IsExported["PFS.FileInfo"]
THEN Installed["PFS"];
IF IsExported["SunPMapClient.CallWithMultipleReplies"]
THEN Installed["SunPMapClient"];
IF IsExported["SunRPC.StartCall"]
THEN Installed["SunRPCRuntime"];
IF IsExported["SystemNames.UserName"]
THEN Installed["SystemNames"];

END.
l
CommanderInstallCommandsImpl.mesa
Copyright ำ 1989, 1990, 1991 by Xerox Corporation.  All rights reserved.
Michael Plass, January 14, 1992 10:25 am PST
Chauser, July 31, 1990 1:26 pm PDT
Willie-s, July 23, 1991 10:23 am PDT
Christian Jacobi, July 21, 1992 5:20 pm PDT

Load state inquiry
Install Commands
Returns TRUE if it needs to be done right away.
PROC [found: BOOL, val: Val]  RETURNS [op: UpdateOperation _ none, new: Val _ NIL]
PROC [key: Key, val: Val] RETURNS [quit: BOOL _ FALSE]
PROC [found: BOOL, val: Val]  RETURNS [op: UpdateOperation _ none, new: Val _ NIL]
Registration
What's already running...
ส•NewlineDelimiter

–
(cedarcode) style™
codeš
œ!™!Kšœ
ฯe
œ=™HK™,K™"K™$K™+K™—šฯk	œ-žœžœc˜ 
K˜—Kšฯnœžœ
ž˜+Kšžœ-žœžœF˜
Kšžœฯc˜$šœž˜K˜Kšžœžœžœ
žœ
˜Kšžœžœžœ
˜—
head™K˜Kšœžœ
žœ(˜>š
Ÿ
œžœžœžœžœ˜9Kšœžœ*˜5Kšœžœ!˜)šžœ	˜šžœ˜Kšœžœ&˜5Kšœžœ%˜/Kš	œž	œ
žœ
žœ
žœH˜dKšžœžœ
˜Kš
œ
˜
—šžœ˜Kšžœžœ ;˜JKš
œ˜——Kš
œ˜—K˜—™Kšœ
žœžœ˜+šœžœžœ˜#K˜Kšœž	˜K˜—K˜Kšœžœžœ˜/šœžœžœ˜%Kš
œ˜Kšœžœžœ
˜Kšœžœž˜K˜—K˜Kšœžœ˜1K˜š
œ-˜-šŸœžœ
žœ˜<šœžœ˜)Kšœžœ
˜$K˜—šžœ˜	Kš
œM˜MKš
œ*˜*K˜—K˜K˜——šŸœ˜4Kš	œžœ
žœžœ
žœ˜*š	žœžœ0žœ
žœž˜SKšœ
žœžœ˜7Kš
œ ˜ Kšžœ
˜—K˜—K˜šŸœžœ
žœžœ˜7Kš
œV˜VK˜—K˜šŸ	œžœ
žœžœ˜.Kš
œG˜GKšœžœ
˜Kš
œ+˜+K˜K˜—šŸœžœ
žœ
žœ
žœžœ
žœ
žœ˜:Kš	œžœ
žœ
žœžœ
˜šŸœžœžœžœžœžœžœ˜Ešžœžœ
ž˜š
œ˜Kšžœžœžœ˜3Kš
œ˜—Kšžœžœ
˜—Kš
œ˜—Kš
œ2˜2Kšžœ+˜1K˜K˜—šŸœžœ
žœ
žœžœžœžœ˜=Kšžœ
žœžœ
˜Kšœžœ&˜DKšžœžœ
žœ
žœžœ
žœ
žœ
žœ˜HK˜K˜—šŸœ˜-Kš	œžœ
žœžœ
žœ˜)Kšœ
žœ'˜5Kšžœžœ
žœ'˜=Kšžœ8žœ
žœ"žœ˜xKš
œ˜K˜—šŸœ˜0Kš	œžœ
žœžœ
žœ˜)Kšœ
žœ'˜5Kšžœžœ
žœ'˜=Kšžœ7žœ
žœ"žœ˜wKš
œ˜K˜—Kšœ0žœ˜7šŸ
œžœ
žœ
žœžœžœžœžœžœ˜cJ™/Kšžœ
žœžœ
˜Kšœžœ&˜DKšœ
žœžœ
žœ˜7šžœ
žœ	žœ˜šŸœ˜Kšžœ	žœ
žœ)žœ
™RKš	œ	žœ
žœ
žœžœ˜$šžœž˜Kšžœžœ
˜ šžœ
žœžœ
žœ
žœž˜3Kš
žœ
žœ
žœžœžœ˜>Kšžœ
˜——Kšžœ˜!Kš
œ˜—Kš
œ*˜*Kš
œ˜—Kš
œ˜K˜—šŸœ˜/Kš	œžœ
žœžœ
žœ˜)Kšœ
žœ'˜5šžœž˜šžœ˜šŸ
œ˜(Kšžœžœžœžœ
™6šžœžœ
žœ
žœžœžœžœ
ž˜CKšžœ$˜&Kšžœ˜Kšžœ˜Kšžœ˜ Kšžœ
˜—Kš
œ˜—Kš
œ0˜0Kš
œ
˜
—šžœ˜Kš	œ
žœžœžœ
žœ˜XKšœ	žœ(˜5Kšžœ	žœ
žœ/˜EKš
œ˜——Kš
œ˜K˜—šŸœ˜)Kš
žœ
žœžœžœ
žœ*˜^Kšœžœ"˜-Kšœžœ"˜1Kšœ
žœ"˜0Kšœžœ
˜Kš
žœ"žœ
žœžœ
žœ'˜eKš
œ_˜_šžœ
žœ
ž˜Kšžœ
žœ˜šžœ˜Kš
œ˜Kš
œ?˜?K˜—šžœ˜K˜Kš
œ8˜8K˜——K˜K˜—šŸœ˜)Kš
žœ
žœžœžœ
žœ*˜^Kšœžœžœ
˜Kšœžœ˜š	žœžœBžœžœ
ž˜kK˜
šžœ
žœ
ž˜Kšœžœ
žœ
˜,Kšœžœ
žœ
˜.šžœ˜Kšœžœ
˜Kšžœžœ˜+Kš
œ)˜)šžœ
žœ
ž˜Kšžœ
žœ˜šžœ˜Kš
œ˜Kš
œ?˜?K˜—šžœ˜K˜Kš
œ8˜8K˜——Kš
œ˜——Kšžœ
˜—Kšžœžœ
žœ
˜ฃ
K˜K˜—šŸœ˜+Kšœžœ˜š	žœžœBžœžœ
ž˜aKš
œ˜K˜
Kšžœ
˜—šžœžœ˜š
žœžœ
žœ
žœžœžœ
ž˜FKšžœ˜ Kš
žœžœ
žœ
žœžœ˜;Kšžœ
˜—Kš
œ˜—K˜—K˜šŸœžœ
žœžœ+žœžœžœ	žœžœ˜ƒ
Kš	œžœ
žœžœžœ˜Cš
žœ
žœ
žœžœžœ˜6Kš
œb˜bKš
œV˜VKš
œ#˜#Kšœžœ2˜=Kšžœ
˜—Kšžœžœ˜K˜K˜—šŸœžœ
žœžœžœžœ˜hKš
œG˜Gšžœž˜Kšœžœ
˜˜K˜ šœžœ
žœ6˜EKšœžœ"˜7Kšœžœ
˜Kšœžœ
žœ!žœ
žœžœžœžœ˜€
šžœž˜(Kšžœž
œžœ˜1šžœ˜	KšœžœC˜_Kšžœžœ˜$K˜—Kšžœžœ
˜—K˜—Kš
œ1˜1K˜—Kš
œA˜AKšžœžœ
˜—šžœ
žœžœ˜Kšœžœžœ
˜!šŸœ˜Kšžœ	žœ
žœ)žœ
™RKšžœžœžœžœ˜BKš
œ˜—Kš
œ2˜2š
žœžœ
žœ
žœžœžœ
ž˜DKš
œ0˜0Kšžœ
˜—Kš
œ˜—K˜Kšœžœžœ
˜(—K˜šŸœ 
œ
žœžœžœžœ˜ƒ
šŸœžœ˜Kš
œ0˜0Kš
œ˜—Kšœžœžœ9˜IKšžœ˜!K˜K˜—š
Ÿœžœ
žœžœžœ˜hKšžœ
žœ˜Kšœ	žœ$˜3šžœ
žœ
žœ˜Kšœ	žœ˜)Kšžœ
žœ(žœ
žœ
˜9K˜—Kšžœžœ
žœ
žœ
˜9Kšžœžœ˜9K˜—K˜šŸœžœ
žœA˜\Kšžœ
žœ˜K˜Kšž	œ
˜K˜——™Kšœด
žœ˜น
Kšœฉ
žœ˜ฎ
Kšœฐ
žœ˜ถ
Kšœฒ
žœ˜ท
Kšœน
žœ˜ฟ
Kšœอ
žœ˜า
Kšœล
žœ˜ส
Kšœฃ
žœ˜จ
Kšœโ
žœ˜่
—™Kš
œ˜Kš
œ˜Kš
œ˜šžœ˜Kšžœ!˜%—šžœ˜ Kšžœ˜—šžœ1˜3Kšžœ!˜%—šžœ+˜-Kšžœ"˜&—šžœ˜Kšžœ˜—šžœ4˜6Kšžœ˜ —šžœ˜!Kšžœ˜ —šžœ#˜%Kšžœ˜——K˜Kšžœ
˜—…—/j@U