Yodel: User commands

YodelUser.mesa

Last Edited by: Hagmann, January 23, 1985 5:22:33 pm PST

DIRECTORY

AlpFile   USING[ FileID, GetSize, Handle, LockOption, Open, ReadProperties, ReadPages,

      SetSize, WritePages, WriteProperties],

AlpineEnvironment

    USING[ AccessList, ByteCount, bytesPerPage,

     NeededAccess, Outcome, OwnerName,

     PageCount, Principal, Property, PropertyValuePair, RName,

    UniversalFile, wordsPerPage],

AlpineFile  USING [ allProperties, PropertySet],

AlpineInterimDirectory

     USING[ CreateOptions, DeleteUnderTrans,

      EnumerateDirectoryUnderTrans, OpenUnderTrans],

AlpInstance  USING[ AccessFailed, Create, Handle, LockFailed ],

AlpTransaction USING[ AssertAlpineWheel, Create, Finish, Handle, Outcome],

BasicTime  USING[ GMT],

Basics    USING[ Comparison],

Buttons   USING[ Button, ButtonProc, SetDisplayStyle ],

FS     USING[ Close, ComponentPositions, Copy, Create, Delete,

      EnumerateForInfo, Error, ExpandName, GetInfo, GetName, InfoProc,

      Open, OpenFile, Read, SetByteCountAndCreatedTime, Write],

IO     USING[ int, PutF, PutFR, PutRope, rope, STREAM, text, time ],

List    USING[ Sort, Car, Cdr],

Menus   USING[ MouseButton],

RefText   USING[ TrustTextAsRope],

Rope,

RPC,

UserCredentials USING[ Get ],

ViewerClasses USING[ Viewer ],

ViewerTools  USING[ GetContents],

VM    USING[ AddressForPageNumber, Allocate, Free, Interval],

YodelData;

YodelUser: CEDAR PROGRAM

IMPORTS AlpineInterimDirectory, AlpFile, AlpInstance, AlpTransaction, Buttons, FS, IO, List, RefText, Rope, RPC, UserCredentials, ViewerTools, VM, YodelData

EXPORTS YodelData

=

BEGIN OPEN AE: AlpineEnvironment, YodelData;

ByteCount: TYPE = AE.ByteCount;

bytesPerPage: INT = AE.bytesPerPage;

PageCount: TYPE = AE.PageCount;

PropertyValuePair: TYPE = AE.PropertyValuePair;

UniversalFile: TYPE = AE.UniversalFile;

wordsPerPage: INT = AE.wordsPerPage;

PagesForBytes: PROC [byteLength: ByteCount] RETURNS [pageCount: PageCount] = {

BytesForPages: PROC [pageCount: PageCount] RETURNS [byteLength: ByteCount] = {

ROPE: TYPE = Rope.ROPE;

hasPattern: PUBLIC SAFE PROC [pattern: ROPE] RETURNS [BOOL] = {

CompareProc: SAFE PROC [ref1, ref2: REF ANY]
RETURNS [Basics.Comparison] = CHECKED {
RETURN [Rope.Compare[NARROW[ref1], NARROW[ref2], FALSE]];
};

makeSlashAWedge: Rope.TranslatorType = {
  IF old = '/ THEN RETURN['>] ELSE RETURN[old];
  };
 
ParseSArgs: PUBLIC PROC [ d: MyData]
RETURNS [user, password, srcServer, srcDir, srcFile: ROPE] = {

  srcFileTemp: ROPE ;
  srcServer ← ViewerTools.GetContents[d.srcServer];
 -- srcFile ← ViewerTools.GetContents[d.srcFile];
  srcFileTemp ← ViewerTools.GetContents[d.srcFile] ;
  IF (NOT srcFileTemp.IsEmpty[]) AND srcFileTemp.Fetch[0] = '/ THEN
  srcFileTemp ← Rope.Concat["<" ,
  srcFileTemp.Substr[start: 1, len: srcFileTemp.InlineLength[]-1]];
  srcFile ← Rope.Translate[base: srcFileTemp,
   translator: makeSlashAWedge ];
  user ← ViewerTools.GetContents[d.user];
  IF (Rope.Equal[user,""] OR Rope.Equal[user,NIL]) THEN
  [user] ← UserCredentials.Get[];
    password ← ViewerTools.GetContents[d.password];
  [srcDir] ← DecomposePattern[server: srcServer, pattern: srcFile, user: user];

};

ParseDArgs: PROC [user: ROPE, d: MyData]
RETURNS [destServer, destDir, destFile: ROPE] = {

  destFileTemp: ROPE ;
  destServer ← ViewerTools.GetContents[d.destServer];
  destFileTemp ← ViewerTools.GetContents[d.destFile];
  IF (NOT destFileTemp.IsEmpty[]) AND destFileTemp.Fetch[0] = '/ THEN
  destFileTemp ← Rope.Concat["<" ,
  destFileTemp.Substr[start: 1, len: destFileTemp.InlineLength[]-1]];
  destFile ← Rope.Translate[base: destFileTemp,
   translator: makeSlashAWedge ];
  [destDir] ← DecomposePattern[server: destServer, pattern: destFile, user: user];

};

listFiles: PROC [trans: AlpTransaction.Handle, server: ROPE, pattern: ROPE,
user: ROPE ← NIL, password: ROPE ← NIL ,
displayProperties: AlpineFile.PropertySet ← AlpineFile.allProperties,
d: MyData]
RETURNS [LIST OF REF ANY] = {
directory, restOfPattern: ROPE;
resultList: LIST OF REF ANY ← NIL;

resultRope: ROPE ← NIL;

outcome: AlpTransaction.Outcome;

failureName: ROPE ← "" ;

{

DecomposePattern: PUBLIC PROC [server: ROPE, pattern: ROPE, user: ROPE]

RETURNS [directory, restOfPattern: ROPE] = {
rightAngleBracket: INT;
dir: ROPE ;
isAlpine: BOOL ;
IF Rope.Match[pattern: "*.alpine", object: server, case: FALSE] THEN {
 isAlpine ← TRUE;
 dir ← user;
 }
ELSE {
 isAlpine ← FALSE;
 IF server.IsEmpty[] THEN dir ← NIL
  ELSE {
   IF Rope.Match[pattern: "*.*", object: user, case: FALSE] THEN
    dir ← user.Substr[start: 0, len: user.SkipTo[1, "."]]
   ELSE dir ← user;
  };
 };
IF NOT Rope.Match[pattern: "<*>*", object: pattern, case: FALSE] THEN
BEGIN
directory ← Rope.Concat["<", dir] ;
  directory ← Rope.Concat[directory,">"];
restOfPattern ← pattern ;
IF restOfPattern.IsEmpty[] THEN restOfPattern ← "*";
END
ELSE BEGIN
rightAngleBracket ← pattern.SkipTo[1, ">"];
IF rightAngleBracket > 1
THEN directory ← pattern.Substr[start: 0, len: rightAngleBracket+1]
ELSE directory ← Rope.Concat["<>", dir] ;
  restOfPattern ← pattern.Substr[start: rightAngleBracket+1];
IF restOfPattern.IsEmpty[] THEN restOfPattern ← "*";
END
};


ListFilesProc: PUBLIC Buttons.ButtonProc=
BEGIN
  resultList: LIST OF REF ANY ← NIL;
  d: MyData = NARROW[clientData];
  server, user, file, password: ROPE;
  directory, restOfPattern: ROPE;
  printedSomething: BOOL ← FALSE;
 
  callList: YodelData.PerformProc = {

RETURN[listFiles[trans, server, file, user, password, d.displayProperties, d]];
};

 
  d.stopFlag ← FALSE;
 
  [user, password, server, directory, file] ← ParseSArgs[d];
 
  [directory, restOfPattern] ← DecomposePattern[server: server, pattern: file, user: user];
 
  d.out.PutF["\nList of [%g]%g%g\n",
  IO.rope[server], IO.rope[directory], IO.rope[restOfPattern]];
  resultList ← PerformOp[performProc: callList,
  server: server, user: user, password: password];
  DO
  nowRope: ROPE ← NARROW[List.Car[resultList]];
  IF resultList = NIL THEN EXIT;
  resultList ← List.Cdr[resultList];
  d.out.PutF[" %g\n", IO.rope[nowRope]];
  printedSomething ← TRUE ;
  ENDLOOP;
  IF NOT printedSomething THEN d.out.PutRope[" ** no files match the pattern **\n"];
END;



fileDelete: PROC [trans: AlpTransaction.Handle, server: ROPE, file: ROPE,
user: ROPE ← NIL, password: ROPE ← NIL, d: MyData]
RETURNS[resultList:LIST OF REF ANY ← NIL] = {
 directory, restOfPattern, directoryName: ROPE;
 
 AlpineDeleteEnumProc: PROC [fileName: REF TEXT,
universalFile: AlpineEnvironment.UniversalFile] RETURNS [quit: BOOL] = {
 IF d.stopFlag THEN {
 resultList ← CONS[first: NARROW[" ** Delete aborted **", ROPE], rest: NIL];
 RETURN [quit: TRUE];
  };
IF Rope.Match[pattern: restOfPattern,
object: RefText.TrustTextAsRope[fileName], case: FALSE] THEN {
 fileN: ROPE;
 fileN ← Rope.Concat[directoryName,Rope.FromRefText[fileName]];
 AlpineInterimDirectory.DeleteUnderTrans[transHandle: trans,
  fileName: fileN];
 resultRope ← IO.PutFR["%g deleted", IO.text[fileName]];
 resultList ← CONS[first: resultRope, rest: resultList];
 };
RETURN [quit: FALSE];
};
 
 FSDeleteEnumProc: FS.InfoProc = {
   -- PROC [fullFName, attachedTo: ROPE, created: BasicTime.GMT, bytes: INT,
  -- keep: CARDINAL] RETURNS [continue: BOOLEAN];
  IF d.stopFlag THEN {
 resultList ← CONS[first: NARROW[">> ** Delete aborted **", ROPE], rest: NIL];
 RETURN [continue: FALSE];
   };
  FS.Delete[ name: fullFName, wantedCreatedTime: created];
  resultRope ← IO.PutFR["%g deleted", IO.rope[fullFName]];
resultList ← CONS[first: resultRope, rest: resultList];
RETURN [continue: TRUE];
};

 resultRope: ROPE ← NIL;
 outcome: AlpTransaction.Outcome;
 failureName: ROPE ← "" ;
 {
  [directory, restOfPattern] ← DecomposePattern[server, file, user];
  IF trans # NIL THEN {
    -- alpine files to delete
  bangPos: INT ;
  IF d.assertWheel THEN trans.AssertAlpineWheel[TRUE];
  IF (bangPos ← Rope.Find[restOfPattern,"!"]) >= 0 THEN {
   IF bangPos = 0 THEN restOfPattern ← "*"
    ELSE restOfPattern ← Rope.Substr[base: restOfPattern, len: bangPos];
   };
  directoryName ← Rope.Concat["[",Rope.Concat[server,Rope.Concat["]",directory]]];
  AlpineInterimDirectory.EnumerateDirectoryUnderTrans[
  transHandle: trans,
  directoryName: directoryName,
  enumProc: AlpineDeleteEnumProc];
  outcome ← AlpTransaction.Finish[trans, commit];
  IF outcome # commit THEN {
 resultList ← CONS[
  first: Rope.Concat["Alpine transaction aborted -- deletes NOT done",
  IF resultList = NIL THEN NIL ELSE "; log before abort is:"],
  rest: resultList];
   };
  }
ELSE {
    -- FS or IFS files to delete
 pattern: ROPE;
 pattern ← Rope.Concat[Rope.Concat[Rope.Concat[Rope.Concat
  ["[", server], "]"], directory], restOfPattern];
 IF pattern.Find["!"] < 0 THEN pattern ← Rope.Concat[pattern, "!l"];
 FS.EnumerateForInfo[pattern: pattern, proc: FSDeleteEnumProc ];
 };
};

resultList ← List.Sort[resultList, CompareProc];
RETURN [resultList];
};



DeleteFilesProc: PUBLIC Buttons.ButtonProc=
BEGIN
  d: MyData = NARROW[clientData];
  resultList: LIST OF REF ANY ← NIL;
  srcServer, srcFile, srcDir: ROPE;
  user, password: ROPE;
  directory, restOfPattern: ROPE;
  printedSomething: BOOL ← FALSE;
 
  callDelete: YodelData.PerformProc = {

RETURN[fileDelete[trans: trans, server: srcServer, file: srcFile,
user: user, password: password, d: d]];
};

 
  d.stopFlag ← FALSE;
  [user, password, srcServer, srcDir, srcFile] ← ParseSArgs[d];
  [directory, restOfPattern] ← DecomposePattern[server: srcServer, pattern: srcFile,
  user: user];
 
 IF Rope.IsEmpty[srcFile] THEN {
  d.out.PutF["\nDelete of [%g]%g%g NOT done -- MUST have explicit pattern\n",
   IO.rope[srcServer], IO.rope[srcDir], IO.rope[restOfPattern]];
   RETURN;
  };
 d.out.PutF["\nDelete of [%g]%g%g\n",
  IO.rope[srcServer], IO.rope[srcDir], IO.rope[restOfPattern]];
 resultList ← PerformOp[performProc: callDelete,
  server: srcServer, user: user, password: password];
 DO
  nowRope: ROPE ← NARROW[List.Car[resultList]];
  IF resultList = NIL THEN EXIT;
  resultList ← List.Cdr[resultList];
  d.out.PutF[" %g\n", IO.rope[nowRope]];
  printedSomething ← TRUE ;
  ENDLOOP;
  IF NOT printedSomething THEN d.out.PutRope[" ** no files match the pattern **\n"];

END;

-- excessBytes is only used if expunging = TRUE.
fileCopy: PROC [trans: AlpTransaction.Handle, to: ROPE, from: ROPE,
fullCopy: BOOL, user: ROPE ← NIL, password: ROPE ← NIL ,
expunging: BOOLEAN ← FALSE, excessBytes: AlpineEnvironment.ByteCount ← 0,
caller: AlpineEnvironment.Principal, key: RPC.EncryptionKey,
d: MyData]
RETURNS [copyResult: LIST OF REF ANY ← NIL] =
{

FileStateObject: TYPE = RECORD [
SELECT type: {alpine, fs} FROM
alpine => [fileHandle: AlpFile.Handle],
fs => [openFile: FS.OpenFile],
ENDCASE];

AlpineFileStateObject: TYPE = FileStateObject.alpine;
FSFileStateObject: TYPE = FileStateObject.fs;
FileState: TYPE = REF FileStateObject;
AlpineFileState: TYPE = REF AlpineFileStateObject;
FSFileState: TYPE = REF FSFileStateObject;

CreateFileState: PROC [file: ROPE, createOptions: AlpineInterimDirectory.CreateOptions,
createLength: INT ← 0, trans: AlpTransaction.Handle ← transHandle]
RETURNS [FileState] = {
  -- test for alpine files
IF Rope.Match[pattern: "[*.alpine]*", object: file, case: FALSE] THEN {
universalFile: UniversalFile;
createdFile: BOOLEAN;
alpineFileState: AlpineFileState;
rightSquareBracket: INT ← file.Find["]", 1];
IF rightSquareBracket IN [-1..1]
THEN BEGIN IF expunging
THEN ERROR
ELSE ERROR ;
END;
[universalFile, createdFile] ← AlpineInterimDirectory.OpenUnderTrans[
trans, file, createOptions, createLength];
alpineFileState ← NEW[AlpineFileStateObject ← [alpine[fileHandle:
AlpFile.Open[trans, universalFile,
IF createOptions = oldOnly THEN readOnly ELSE readWrite,
[IF createOptions = oldOnly THEN read ELSE write, wait],
log, sequential].handle]]];
IF createOptions # oldOnly -- this is the "to" file.
THEN BEGIN
IF ((expunging) AND (NOT createdFile))
THEN BEGIN
alpineFileState.fileHandle.WriteProperties[LIST[[highWaterMark[0]]]];
IF (trans.Finish[requestedOutcome: commit, continue: TRUE] #
commit) THEN ERROR;
END;
alpineFileState.fileHandle.SetSize[PagesForBytes[createLength + (IF expunging
THEN excessBytes ELSE 0)]];
END;
RETURN [alpineFileState];
}
ELSE {
openFile: FS.OpenFile;
fsFileState: FSFileState;
IF createOptions = oldOnly THEN {
 openFile ← FS.Open[file];
 }
ELSE {
 openFile ← FS.Create[
  name: file,
  setPages: TRUE,
  pages: PagesForBytes[createLength]];
 };
fsFileState ← NEW[FSFileStateObject ←
[fs[openFile: openFile]]];
RETURN [fsFileState];
};
};


CleanupFileState: PROC [fileState: FileState] = {
 WITH fileState SELECT FROM
alpineFileState: AlpineFileState => {
};
fsFileState: FSFileState => {
 fsFileState.openFile.Close[];
 };
ENDCASE => ERROR;

 };

GetFileProperties: PROC [fileState: FileState]

SetFileProperties: PROC [fileState: FileState,
byteLength: AlpineEnvironment.ByteCount, createTime: BasicTime.GMT,
alpineProperties: LIST OF AlpineEnvironment.PropertyValuePair ← NIL] = {
WITH fileState SELECT FROM
alpineFileState: AlpineFileState => {
IF fullCopy THEN alpineFileState.fileHandle.WriteProperties[alpineProperties]
ELSE alpineFileState.fileHandle.WriteProperties[LIST[[byteLength[byteLength]],
[createTime[createTime]]]];
};
fsFileState: FSFileState => {
 fsFileState.openFile.SetByteCountAndCreatedTime[bytes: byteLength,
  created: createTime];
  };
ENDCASE => ERROR;
};

FillBuffer: PROC [fromFile: FileState, pagesToMove: CARDINAL] = {
WITH fromFile SELECT FROM
alpineFileState: AlpineFileState => {
TRUSTED BEGIN alpineFileState.fileHandle.ReadPages[
pageRun: [firstPage: pagesCopied, count: pagesToMove],
pageBuffer: DESCRIPTOR [
bufferPtr, pagesToMove*wordsPerPage]]; END;
};
fsFileState: FSFileState => {
TRUSTED BEGIN
 fsFileState.openFile.Read[from: pagesCopied, nPages: pagesToMove, to: bufferPtr];
 END;
};
ENDCASE => ERROR;
};

EmptyBuffer: PROC [toFile: FileState, pagesToMove: CARDINAL] = {
WITH toFile SELECT FROM
alpineFileState: AlpineFileState => {
TRUSTED BEGIN alpineFileState.fileHandle.WritePages[
pageRun: [firstPage: pagesCopied, count: pagesToMove],
pageBuffer: DESCRIPTOR [
bufferPtr, pagesToMove*wordsPerPage]]; END;
};
fsFileState: FSFileState => {
TRUSTED BEGIN
 fsFileState.openFile.Write[to: pagesCopied, nPages: pagesToMove, from: bufferPtr];
 END;
};
ENDCASE => ERROR;
};

moveTheBits: PROC [] RETURNS [aborted: BOOL ← FALSE]= {
pagesCopied ← 0;
UNTIL pagesCopied = pageCount DO
pagesLeft: CARDINAL ← pageCount-pagesCopied;
pagesToMove: CARDINAL ← MIN [bufferLen, pagesLeft];
IF d.stopFlag THEN {
 WITH toFile SELECT FROM
  alpineFileState: AlpineFileState => {
  [] ← transHandle.Finish[requestedOutcome: abort, continue: FALSE] ;
  IF secondTransHandle # NIL THEN
   [] ← secondTransHandle.Finish[requestedOutcome: abort, continue: FALSE] ;
  };
   fsFileState: FSFileState => {
   fullF: ROPE;
   created: BasicTime.GMT ;
   [fullFName: fullF] ← fsFileState.openFile.GetName[];
   [created: created] ← fsFileState.openFile.GetInfo[];
   fsFileState.openFile.Close[];
   FS.Delete[name: fullF, wantedCreatedTime: created];
   };
 ENDCASE => ERROR;
 RETURN[TRUE];
 };
FillBuffer[fromFile, pagesToMove];
EmptyBuffer[toFile, pagesToMove];
pagesCopied ← pagesCopied + pagesToMove;
ENDLOOP;
};


transHandle: AlpTransaction.Handle ← trans;
secondInst: AlpInstance.Handle ← NIL;
secondTransHandle: AlpTransaction.Handle ← NIL;
toFile, fromFile: FileState;
byteLength: AlpineEnvironment.ByteCount;
createTime: BasicTime.GMT;
bufferLen: CARDINAL = 12;
pageCount: PageCount ;
bufferInterval: VM.Interval ← TRASH;
bufferAllocated: BOOL ← FALSE ;
bufferPtr: LONG POINTER;
pagesCopied: INT;
cp: FS.ComponentPositions;
toServer, fromServer: ROPE ;
fullN: ROPE ;
IFSResult: BOOL ;
alpineSource: BOOL ;
alpineResult: BOOL ;
alpineSourceAndResult: BOOL;
twoDifferentAlpine: BOOL ← FALSE;
alpineProperties: LIST OF AlpineEnvironment.PropertyValuePair ← NIL;
highWaterMark: AlpineEnvironment.PageCount ← 0;
createLength: AlpineEnvironment.ByteCount;
alpineSize: INT;

{
ENABLE UNWIND => {
 IF transHandle # NIL THEN [] ← AlpTransaction.Finish[transHandle, abort
  ! RPC.CallFailed => CONTINUE];
 IF secondTransHandle # NIL THEN [] ← AlpTransaction.Finish[secondTransHandle, abort
  ! RPC.CallFailed => CONTINUE];
  IF bufferAllocated THEN TRUSTED {VM.Free[bufferInterval]};
 bufferAllocated ← FALSE;
 IF fromFile # NIL THEN CleanupFileState[fromFile ! FS.Error => CONTINUE];
 IF toFile # NIL THEN CleanupFileState[toFile ! FS.Error => CONTINUE];
 };

IF transHandle # NIL AND d.assertWheel THEN transHandle.AssertAlpineWheel[TRUE];
fromFile ← CreateFileState[file: from, createOptions: oldOnly];
[byteLength, createTime, alpineProperties, highWaterMark, alpineSize] ←
GetFileProperties[fromFile];

  [fullFName: fullN, cp: cp] ← FS.ExpandName[name: to];
  toServer ← Rope.Substr[fullN,cp.server.start, cp.server.length];
  alpineResult ← Rope.Match[pattern: "*.alpine", object: toServer, case: FALSE] ;
[fullFName: fullN, cp: cp] ← FS.ExpandName[name: from];
fromServer ← Rope.Substr[fullN,cp.server.start, cp.server.length];
alpineSource ← Rope.Match[pattern: "*.alpine", object: fromServer, case: FALSE] ;
alpineSourceAndResult ← alpineResult AND alpineSource ;

IF byteLength < 0 AND (~alpineSourceAndResult OR ~fullCopy) THEN RETURN[CONS[
NARROW["The source file has negative length. Copy aborted.",ROPE]
,NIL]];

IF alpineSourceAndResult AND fullCopy THEN {
 createLength ← MAX[byteLength, BytesForPages[highWaterMark], alpineSize];
 }
ELSE createLength ← byteLength;

IF Rope.IsEmpty[toServer] OR alpineResult THEN {
 IFSResult ← FALSE;
 IF alpineSourceAndResult AND
  ~Rope.Equal[ s1: fromServer, s2: toServer, case: FALSE] THEN {
  twoDifferentAlpine ← TRUE;
  secondInst ← AlpInstance.Create[fileStore: toServer, caller: caller, key: key];
  secondTransHandle ← AlpTransaction.Create[secondInst];
  IF d.assertWheel THEN secondTransHandle.AssertAlpineWheel[TRUE];
  toFile ← CreateFileState[file: to, createOptions: none, createLength: createLength,
   trans: secondTransHandle];
  }
  ELSE toFile ← CreateFileState[file: to, createOptions: none, createLength: createLength];
 }
ELSE {
 IFSResult ← TRUE;
 toFile ← CreateFileState[file: "///temp/qqqscratch.yodel", createOptions: none,
  createLength: createLength];
 };

-- toFile ← CreateFileState[file: to, createOptions: none, createLength: byteLength];

pageCount ← PagesForBytes[createLength];

TRUSTED BEGIN
 bufferInterval ← VM.Allocate[count: bufferLen];
 bufferAllocated ← TRUE ;
 bufferPtr ← VM.AddressForPageNumber[bufferInterval.page];
END;
IF moveTheBits[] THEN RETURN[CONS[
NARROW["Copy aborted ",ROPE]
,NIL]];
SetFileProperties[toFile, byteLength, createTime, alpineProperties];
CleanupFileState[fromFile];
CleanupFileState[toFile];
IF twoDifferentAlpine THEN {
 IF (secondTransHandle.Finish[requestedOutcome: commit, continue: FALSE] # commit)
 THEN RETURN[CONS[
 NARROW[
 "Transaction on destination server failed to commit - validity of copy is in question",
  ROPE]
 ,NIL]];
 }; TRUSTED BEGIN
   VM.Free[bufferInterval];
   bufferAllocated ← FALSE ;
  END;
IF IFSResult THEN {
 FS.Copy[from: "///temp/qqqscratch.yodel", to: to ];
 FS.Delete[name: "///temp/qqqscratch.yodel"];
 };
IF transHandle # NIL AND
(transHandle.Finish[requestedOutcome: commit, continue: FALSE] # commit)
THEN RETURN[CONS[
NARROW["Transaction on source server failed to commit - validity of copy is in question",ROPE]
,NIL]];
};
};

ChangeOptionsProc: PUBLIC Buttons.ButtonProc = BEGIN

END.