<> <> <> <> <> <> <> <> <> <> <> <<>> <> <<1. Version numbers should be retained in order to keep the validity of the hints in DF files. This requires using STP (unfortunately).>> <<2. Don't clutter the local disk with cached copies of transferred files.>> <<3. Don't move files that are already there.>> <<4. Support running this program in background to allow periodic updating of one directory from another. This is particularly useful for CedarChest.>> DIRECTORY BasicTime USING [GMT, Now, nullGMT], CedarProcess USING [DoWithPriority, Priority], Commander USING [CommandProc, Handle, Register], CommandTool USING [ArgumentVector, Failed, Parse], DFUtilities USING [DirectoryItem, FileItem, IncludeItem, ParseFromStream, ProcessItemProc], FS USING [Copy, defaultStreamOptions, EnumerateForInfo, Error, ExpandName, FileInfo, InfoProc, StreamOpen, StreamOptions], FSBackdoor USING [EnumerateCacheForInfo, InfoProc], FSPseudoServers USING [TranslateForWrite], GVBasics USING [Connect], GVNames USING [ConnectInfo, GetConnect], IO USING [Close, PutChar, PutF, PutF1, PutFR1, PutRope, STREAM], List USING [CompareProc], PrincOpsUtils USING [], Process USING [CheckForAbort, GetPriority, Pause, Priority, SecondsToTicks], RedBlackTree USING [Compare, Create, Delete, DestroyTable, EachNode, EnumerateIncreasing, GetKey, Insert, Lookup, Table], Rope USING [Cat, Compare, Concat, Equal, Fetch, Find, Flatten, Length, Match, Replace, ROPE, Run, SkipTo, Substr], STP USING [Close, Connect, Create, Error, Handle, IsOpen, Login, Open, Store], Tempus USING [Now, PackedSeconds, PackedToSeconds, Parse], UserCredentials USING [Get]; TrickleChargeServerImpl: CEDAR PROGRAM IMPORTS BasicTime, CedarProcess, Commander, CommandTool, DFUtilities, FS, FSBackdoor, FSPseudoServers, GVNames, IO, Process, RedBlackTree, Rope, STP, Tempus, UserCredentials = BEGIN <> GMT: TYPE = BasicTime.GMT; ROPE: TYPE = Rope.ROPE; STREAM: TYPE = IO.STREAM; Switches: TYPE = PACKED ARRAY CHAR['a..'z] OF BOOL; PairList: TYPE = LIST OF Pair; Pair: TYPE = RECORD [ src: ROPE, <> dst: ROPE, <> switches: Switches, <> timeRestriction: ROPE <> ]; FileEntry: TYPE = REF FileEntryRep; FileEntryRep: TYPE = RECORD [ name: ROPE, <> short: ROPE, <> date: GMT, <> len: INT, <> state: FileEntryState <> ]; FileEntryState: TYPE = {init, fetching, storing, moved}; <> doc: ROPE = "{srcDir dstDir}* moves files from srcDir (or DF) to dstDir -c: connect (to destination host) -d: debug (inhibits file transfer) -r: repeat (keep doing the transfer forever) -v: verify (no transfers, messages only for missing files) -q: quick (enumerate only the df files) See documentation for specification of time restrictions. "; <> maxRetries: NAT _ 10; <<# of times to retry connectionRejected from STP>> retrySeconds: NAT _ 20; <<# of seconds between retry attemps>> repeatSeconds: NAT _ 1800; <<# of seconds between repeats (when using the R switch)>> secondsBetweenMoves: NAT _ 0; <<# of seconds to wait after a file transfer (to keep IFS load down)>> bytesPerIFSPage: NAT = 2048; maxPauseTime: NAT = 1800; <> DoIt: PROC [table: RedBlackTree.Table, out: STREAM, srcPrefix: ROPE, dstPrefix: ROPE, switches: Switches] = { debug: BOOL _ switches['d]; verify: BOOL _ switches['v]; enumerateForDfFiles: BOOL _ switches['q]; dfList: LIST OF FileEntry _ NIL; EachInfo: FS.InfoProc = { <<[fullFName: ROPE, attachedTo: ROPE, created: GMT, bytes: INT, keep: CARDINAL] RETURNS [continue: BOOL]>> continue _ TRUE; Process.CheckForAbort[]; IF Rope.Run[fullFName, 0, srcPrefix, 0, FALSE] = srcPrefixLen THEN { new: FileEntry _ NIL; short: ROPE _ NIL; WITH RedBlackTree.Lookup[table, fullFName] SELECT FROM entry: FileEntry => { IF entry.date = created THEN RETURN; [] _ RedBlackTree.Delete[table, fullFName]; }; ENDCASE; short _ Rope.Substr[fullFName, srcPrefixLen]; IF Rope.Match["!*", short] THEN RETURN; <> <<(or it could just be a bogus file to be ignored)>> IF debug THEN IO.PutChar[out, '.]; new _ NEW[FileEntryRep _ [ name: fullFName, short: short, date: created, len: bytes, state: init]]; RedBlackTree.Insert[table, new, fullFName]; filesSeenDuringEnumeration _ filesSeenDuringEnumeration + 1; bytesSeenDuringEnumeration _ bytesSeenDuringEnumeration + bytes; ifsPagesDuringEnumeration _ ifsPagesDuringEnumeration + 1 + (bytes + bytesPerIFSPage-1) / bytesPerIFSPage; }; }; EachEntry: RedBlackTree.EachNode = { <<[data: RedBlackTree.UserData] RETURNS [stop: BOOL _ FALSE]>> WITH data SELECT FROM entry: FileEntry => { IF entry.state # moved THEN { IF Rope.Match["*.df!*", entry.short, FALSE] THEN dfList _ CONS[entry, dfList] ELSE MoveFile[entry]; }; RETURN; }; ENDCASE => ERROR; }; MoveFile: PROC [entry: FileEntry] = { fullDstName: ROPE _ Rope.Concat[dstPrefix, entry.short]; fullSrcName: ROPE _ entry.name; isInCache: BOOL _ IsInFileCache[fullSrcName, entry]; isOnDst: BOOL _ FALSE; dstBytes: INT _ 0; dstDate: GMT _ BasicTime.nullGMT; Process.CheckForAbort[]; [created: dstDate, bytes: dstBytes] _ FS.FileInfo[fullDstName ! FS.Error => CONTINUE ]; IF dstDate = entry.date AND dstBytes = entry.len THEN { isOnDst _ TRUE; filesAlreadyThere _ filesAlreadyThere + 1; }; SELECT TRUE FROM debug => { ShowEntry[out, entry]; IF isInCache THEN { filesInCache _ filesInCache + 1; IO.PutRope[out, " (in local file cache)\n"]; }; IF isOnDst THEN IO.PutRope[out, " (already on destination)\n"]; }; isOnDst => { <> entry.state _ moved; }; verify => { <> ShowEntry[out, entry]; IF isInCache THEN { filesInCache _ filesInCache + 1; IO.PutRope[out, " (in local file cache)"]; }; IO.PutRope[out, " (NOT on destination)\n"]; }; ENDCASE => { <> srcStream: STREAM _ NIL; retriedCount: NAT _ 0; openName: ROPE _ NIL; streamOptions: FS.StreamOptions _ FS.defaultStreamOptions; streamOptions[tiogaRead] _ FALSE; <> entry.state _ fetching; IF isInCache THEN { openName _ fullSrcName; filesInCache _ filesInCache + 1; } ELSE { openName _ FS.Copy[from: fullSrcName, to: "///Temp/TrickleCharge.Temp$", wantedCreatedTime: entry.date, setKeep: TRUE, keep: 4]; }; srcStream _ FS.StreamOpen[fileName: openName, streamOptions: streamOptions, wantedCreatedTime: entry.date, remoteCheck: FALSE]; entry.state _ storing; CopyStreamToRemote[srcStream, fullDstName, entry.date ! STP.Error => { IO.PutF[out, "STP.Error when storing %g\n %g\n", [rope[fullDstName]], [rope[error]] ]; SELECT code FROM connectionRejected => <> IF retriedCount < maxRetries THEN { retriedCount _ retriedCount + 1; Process.Pause[Process.SecondsToTicks[retrySeconds]]; RETRY; }; connectionClosed => <> IF retriedCount < maxRetries THEN { retriedCount _ retriedCount + 1; RETRY; }; ENDCASE; IO.Close[srcStream]; GO TO failed; }; UNWIND => IO.Close[srcStream]]; IO.Close[srcStream]; entry.state _ moved; IO.PutF[out, "Moved %g\n to %g\n", [rope[fullSrcName]], [rope[fullDstName]] ]; IF secondsBetweenMoves # 0 THEN Process.Pause[Process.SecondsToTicks[secondsBetweenMoves]]; EXITS failed => {}; }; }; CopyStreamToRemote: PROC [stream: STREAM, remoteName: ROPE, date: GMT] = { IF Rope.Match["[*]<*>*", remoteName] THEN { hostStop: INT _ Rope.SkipTo[remoteName, 1, "]"]; dirStart: INT _ Rope.SkipTo[remoteName, hostStop, "<"]+1; dirStop: INT _ Rope.SkipTo[remoteName, dirStart, ">"]; host: ROPE _ Rope.Flatten[remoteName, 1, hostStop-1]; dir: ROPE _ Rope.Flatten[remoteName, dirStart, dirStop-dirStart]; nameSansHost: ROPE _ Rope.Substr[remoteName, dirStart-1]; IF NOT STP.IsOpen[stp] THEN DO getServerPupName: PROC [server: ROPE] RETURNS [pupServer: ROPE] = { IF server.Find[".", 0, FALSE] > 0 THEN { <> info: GVNames.ConnectInfo; connect: GVBasics.Connect; [info: info, connect: connect ] _ GVNames.GetConnect[server]; <> IF info = group OR info = individual THEN RETURN[connect]; }; RETURN[server]; }; userName: ROPE _ NIL; userPassword: ROPE _ NIL; [userName, userPassword] _ UserCredentials.Get[]; [] _ STP.Open[stp, getServerPupName[host]]; STP.Login[stp, userName, userPassword]; IF switches['c] THEN STP.Connect[stp, dir, ""]; EXIT; ENDLOOP; { ENABLE UNWIND => STP.Close[stp ! STP.Error => CONTINUE; ]; STP.Store[stp: stp, file: nameSansHost, stream: stream, fileType: binary, creation: date]; }; filesMoved _ filesMoved + 1; }; }; VisitEntry: PROC [name: ROPE, date: GMT] = { <> RemoveAngles: PROC [name: ROPE] RETURNS [short: ROPE _ NIL] = { angleCount: INT _ 0; lastAngle: INT _ -1; IF enumerateForDfFiles AND Rope.Run[ s1: name, s2: srcPrefix, case: FALSE ] # Rope.Length[srcPrefix] THEN RETURN[NIL]; FOR i: INT IN [0..Rope.Length[name]) DO SELECT Rope.Fetch[name, i] FROM '>, '] => { lastAngle _ i; IF (angleCount_angleCount+1) = dstAngleCount THEN RETURN [Rope.Substr[name, i+1]]; }; '! => EXIT; ENDCASE; ENDLOOP; IF lastAngle >= 0 THEN RETURN [Rope.Substr[name, lastAngle+1]]; }; new: FileEntry _ NIL; bytes: INT _ 0; short: ROPE _ NIL; Process.CheckForAbort[]; WITH RedBlackTree.Lookup[table, name] SELECT FROM entry: FileEntry => IF entry.date = date THEN RETURN; ENDCASE; [fullFName: name, bytes: bytes, created: date] _ FS.FileInfo[name: name, wantedCreatedTime: date ! FS.Error => IF error.code = $unknownFile OR error.code = $unknownCreatedTime THEN { IO.PutF1[out, "FS.Error[%g]\n", [rope[error.explanation]]]; name _ NIL; CONTINUE; } ELSE REJECT]; short _ RemoveAngles[name]; IF short = NIL THEN RETURN; new _ NEW[FileEntryRep _ [ name: name, short: short, date: date, len: bytes, state: init]]; WITH RedBlackTree.Lookup[table, name] SELECT FROM entry: FileEntry => { IF entry.date = date THEN RETURN; [] _ RedBlackTree.Delete[table, name]; }; ENDCASE; RedBlackTree.Insert[table, new, name]; filesSeenDuringEnumeration _ filesSeenDuringEnumeration + 1; bytesSeenDuringEnumeration _ bytesSeenDuringEnumeration + bytes; ifsPagesDuringEnumeration _ ifsPagesDuringEnumeration + 1 + (bytes + bytesPerIFSPage-1) / bytesPerIFSPage; }; stp: STP.Handle _ STP.Create[]; srcPrefixLen: INT _ Rope.Length[srcPrefix _ TranslateHost[srcPrefix]]; dstPrefixLen: INT _ Rope.Length[dstPrefix]; dstAngleCount: INT _ 0; filesMoved: INT _ 0; filesInCache: INT _ 0; filesAlreadyThere: INT _ 0; filesSeenDuringEnumeration: INT _ 0; bytesSeenDuringEnumeration: INT _ 0; ifsPagesDuringEnumeration: INT _ 0; RedBlackTree.DestroyTable[table]; -- clear the table from the last run FOR i: INT IN [0..dstPrefixLen) DO SELECT Rope.Fetch[dstPrefix, i] FROM '>, '] => dstAngleCount _ dstAngleCount + 1; ENDCASE; ENDLOOP; IO.PutF[out, "Moving files from %g to %g\n", [rope[srcPrefix]], [rope[dstPrefix]] ]; <> IO.PutF1[out, "{Building file table at %g}\n", [time[BasicTime.Now[]]] ]; SELECT TRUE FROM ~Rope.Match["*>", srcPrefix] => VisitClosure[srcPrefix, BasicTime.nullGMT, VisitEntry]; --A df file enumerateForDfFiles => { --Enumerate source directory for df files EachFile: FS.InfoProc = { <<[fullFName: ROPE, attachedTo: ROPE, created: GMT, bytes: INT, keep: CARDINAL] RETURNS [continue: BOOL]>> doTheEnumerate: BOOL _ FALSE; Process.CheckForAbort[]; IF Rope.Run[s1: fullFName, s2: srcPrefix, case: FALSE]#srcPrefixLen THEN ERROR; [] _ FS.FileInfo[name: Rope.Substr[base: fullFName, start: srcPrefixLen], wantedCreatedTime: created, wDir: dstPrefix ! FS.Error => IF error.group=user THEN {doTheEnumerate _ TRUE; CONTINUE}]; IF doTheEnumerate THEN VisitClosure[dfName: fullFName, date: BasicTime.nullGMT, visitor: VisitEntry]; continue _ TRUE; }; FS.EnumerateForInfo[Rope.Concat[srcPrefix, "*.df!H"], EachFile]; }; ENDCASE => FS.EnumerateForInfo[Rope.Concat[srcPrefix, "*!h"], EachInfo]; IF debug THEN IO.PutChar[out, '\n]; IO.PutF[out, "Enumerated new files: %g, bytes: %g, IFS pages: %g\n", [integer[filesSeenDuringEnumeration]], [integer[bytesSeenDuringEnumeration]], [integer[ifsPagesDuringEnumeration]] ]; <> IO.PutF1[out, "{Moving files at %g}\n", [time[BasicTime.Now[]]] ]; RedBlackTree.EnumerateIncreasing[table, EachEntry]; <> FOR entryList: LIST OF FileEntry _ dfList, entryList.rest WHILE entryList # NIL DO MoveFile[entryList.first]; ENDLOOP; IF STP.IsOpen[stp] THEN STP.Close[stp]; IO.PutF1[out, "{Done at %g}\n", [time[BasicTime.Now[]]] ]; IO.PutF[out, "Files moved: %g, inCache: %g, alreadyRemote: %g\n\n", [integer[filesMoved]], [integer[filesInCache]], [integer[filesAlreadyThere]] ]; }; ShowTable: PROC [out: STREAM, table: RedBlackTree.Table] = { EachEntry: RedBlackTree.EachNode = { <<[data: RedBlackTree.UserData] RETURNS [stop: BOOL _ FALSE]>> WITH data SELECT FROM entry: FileEntry => ShowEntry[out, entry]; ENDCASE => ERROR; }; RedBlackTree.EnumerateIncreasing[table, EachEntry]; }; ShowEntry: PROC [out: STREAM, entry: FileEntry] = { IO.PutF[out, "[name: %g, date: %g, len: %g, state: ", [rope[entry.name]], [time[entry.date]], [integer[entry.len]] ]; SELECT entry.state FROM init => IO.PutRope[out, "init]\n"]; fetching => IO.PutRope[out, "fetching]\n"]; storing => IO.PutRope[out, "storing]\n"]; moved => IO.PutRope[out, "moved]\n"]; ENDCASE; }; IsInFileCache: PUBLIC PROC [fullName: ROPE, entry: FileEntry] RETURNS [inCache: BOOL _ FALSE] = { cacheChecker: FSBackdoor.InfoProc = { <<[fullGName: ROPE, created: BasicTime.GMT, bytes: INT, keep: CARDINAL]>> <> IF bytes = entry.len AND created = entry.date THEN GO TO found; IF bytes > 0 AND entry.date = BasicTime.nullGMT THEN GO TO found; RETURN [TRUE]; EXITS found => {inCache _ TRUE; RETURN [FALSE]}; }; FSBackdoor.EnumerateCacheForInfo[cacheChecker, NIL, fullName]; }; TranslateHost: PROC [name: ROPE] RETURNS [ROPE] = { IF Rope.Match["[*]*", name] THEN { rPos: INT _ Rope.SkipTo[name, 1, "]"]; host: ROPE _ Rope.Substr[name, 1, rPos-1]; IF Rope.Length[host] # 0 THEN { nHost: ROPE _ FSPseudoServers.TranslateForWrite[host]; IF Rope.Length[nHost] # 0 THEN IF NOT Rope.Equal[nHost, host, FALSE] THEN name _ Rope.Flatten[Rope.Replace[name, 1, rPos-1, nHost]]; }; }; RETURN [name]; }; GetKey: RedBlackTree.GetKey = { <<[data: RedBlackTree.UserData] RETURNS [RedBlackTree.Key]>> RETURN [data]; }; Compare: RedBlackTree.Compare = { <<[k: RedBlackTree.Key, data: RedBlackTree.UserData] RETURNS [Basics.Comparison]>> key: ROPE _ NIL; WITH k SELECT FROM ent: FileEntry => key _ ent.name; rope: ROPE => key _ rope; ENDCASE => ERROR; WITH data SELECT FROM ent: FileEntry => RETURN [Rope.Compare[key, ent.name, FALSE]]; ENDCASE; ERROR; }; CompareEntries: List.CompareProc = { <<[ref1: REF ANY, ref2: REF ANY] RETURNS [Basics.Comparison]>> WITH ref1 SELECT FROM ent1: FileEntry => WITH ref2 SELECT FROM ent2: FileEntry => RETURN [Rope.Compare[ent1.name, ent2.name, FALSE]]; ENDCASE; ENDCASE; ERROR; }; VisitClosure: PROC [dfName: ROPE, date: GMT, visitor: PROC [name: ROPE, date: GMT]] = { eachItem: DFUtilities.ProcessItemProc = { WITH item SELECT FROM dir: REF DFUtilities.DirectoryItem => prefix _ TranslateHost[dir.path1]; file: REF DFUtilities.FileItem => { name: ROPE _ Rope.Concat[prefix, file.name]; IF prefix = NIL THEN name _ TranslateHost[name]; visitor[name, file.date.gmt]; }; incl: REF DFUtilities.IncludeItem => { file: ROPE _ TranslateHost[incl.path1]; visitor[file, incl.date.gmt]; VisitClosure[file, incl.date.gmt, visitor]; }; ENDCASE; }; prefix: ROPE _ NIL; in: STREAM _ FS.StreamOpen[fileName: dfName _ TranslateHost[dfName], wantedCreatedTime: date]; DFUtilities.ParseFromStream[in, eachItem, [FALSE, all, all, defining] ! UNWIND => IO.Close[in]]; IO.Close[in]; }; ParseTimeReference: PROC [ref: ROPE] RETURNS [valid, inRange: BOOL _ TRUE] ~ { IF ref=NIL THEN RETURN [TRUE, TRUE]; { ENABLE ANY => GOTO Fail; pos1, pos2, pos3: INT; pos1 _ Rope.Find[s1: ref, s2: "("]; IF pos1=-1 THEN GOTO Fail; pos2 _ Rope.Find[s1: ref, s2: "..", pos1: pos1+1]; IF pos2=-1 THEN GOTO Fail; pos3 _ Rope.Find[s1: ref, s2: ")", pos1: pos2+2]; inRange _ Tempus.PackedToSeconds[Tempus.Parse[rope: Rope.Substr[base: ref, start: pos1+1, len: pos2-pos1-1], search: FALSE].time] > Tempus.PackedToSeconds[Tempus.Parse[rope: Rope.Substr[base: ref, start: pos2+2, len: pos3-pos2-2], search: FALSE].time]; EXITS Fail => RETURN [FALSE, FALSE] }; }; TrickleCommandProc: Commander.CommandProc = { <<[cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL]>> <> out: STREAM = cmd.out; switches: Switches _ ALL[FALSE]; timeRestriction: ROPE _ NIL; ProcessSwitches: PROC [arg: ROPE] = { sense: BOOL _ TRUE; FOR index: INT IN [0..Rope.Length[arg]) DO char: CHAR _ Rope.Fetch[arg, index]; SELECT char FROM '- => LOOP; '~ => {sense _ NOT sense; LOOP}; IN ['a..'z] => switches[char] _ sense; IN ['A..'Z] => switches[char + ('a-'A)] _ sense; ENDCASE; sense _ TRUE; ENDLOOP; }; oldPriority: Process.Priority _ Process.GetPriority[]; table: RedBlackTree.Table _ RedBlackTree.Create[getKey: GetKey, compare: Compare]; argv: CommandTool.ArgumentVector _ CommandTool.Parse[cmd: cmd, starExpand: FALSE ! CommandTool.Failed => {msg _ errorMsg; GO TO failed}]; <> pairList: PairList _ NIL; pairListTail: PairList _ NIL; FOR i: NAT IN [1..argv.argc) DO <> arg: ROPE _ argv[i]; Process.CheckForAbort[]; <> IF Rope.Length[arg] = 0 THEN LOOP; <> IF Rope.Fetch[arg, 0] = '- THEN { <> ProcessSwitches[arg]; LOOP; }; IF Rope.Fetch[arg, 0] = '( THEN { <> IF ~ParseTimeReference[arg].valid THEN { msg _ Rope.Cat["Invalid time restriction pair: \"", arg, "\""]; GO TO failed; }; timeRestriction _ arg; LOOP; }; { <> arg _ FS.ExpandName[arg, NIL ! FS.Error => { <> arg _ FS.ExpandName["$", arg ! FS.Error => { <> msg _ error.explanation; GO TO failed; }].fullFName; arg _ Rope.Flatten[arg, 0, Rope.Length[arg]-1]; GO TO ok; }; ].fullFName; EXITS ok => {}; }; IF pairListTail = NIL OR pairListTail.first.dst # NIL THEN { new: PairList _ LIST[[arg, NIL, switches, timeRestriction]]; IF pairListTail = NIL THEN pairList _ new ELSE pairListTail.rest _ new; pairListTail _ new; LOOP; }; IF NOT Rope.Match["*>", arg] AND NOT Rope.Match["*]", arg] THEN { msg _ IO.PutFR1["Destination not a directory (%g)", [rope[arg]] ]; GO TO failed; }; pairListTail.first.dst _ arg; pairListTail.first.switches _ switches; ENDLOOP; IF pairList = NIL THEN {msg _ "No arguments given.\n"; RETURN}; IF pairList.first.dst = NIL THEN {msg _ "Missing destination.\n"; RETURN}; { action: PROC = { DO FOR pair: PairList _ pairList, pair.rest WHILE pair # NIL DO IF ~ParseTimeReference[pair.first.timeRestriction].inRange THEN { IO.PutF[stream: out, format: "Not copying %g to %g this pass because %g is not in range %g.\n\n", v1: [rope[pair.first.src]], v2: [rope[pair.first.dst]], v3: [time[Tempus.Now[]]], v4: [rope[pair.first.timeRestriction]]]; LOOP; }; DoIt[table, out, pair.first.src, pair.first.dst, pair.first.switches ! FS.Error => { IO.PutF1[out, "FS.Error[%g], stopping this round.\n\n", [rope[error.explanation]]]; CONTINUE; }; ]; ENDLOOP; IF NOT switches['r] THEN EXIT; FOR timeLeft: INT _ repeatSeconds, timeLeft - maxPauseTime WHILE timeLeft > 0 DO Process.Pause[Process.SecondsToTicks[MIN[maxPauseTime, CARDINAL[timeLeft]]]]; ENDLOOP; ENDLOOP; }; CedarProcess.DoWithPriority[background, action]; }; EXITS failed => {result _ $Failure}; }; <> Commander.Register[ key: "///Commands/TrickleChargeServer", proc: TrickleCommandProc, doc: doc, clientData: NIL, interpreted: TRUE ]; END. <> <> <<>>