DIRECTORY

AEToCrAE,
CrAEToAE,
CrRPC,
AlpTransaction,
AlpFile,
AlpineFile,
AlpineEnvironment,
AlpineP2202V1,
AlpineEnvironmentP2201V1,
AlpInstanceCourier,
AlpInstance,
RPC,
XNSAuth;


AlpTransactionCourierImpl: CEDAR MONITOR
LOCKS inst^ USING inst: AlpInstanceCourier.Instance 
IMPORTS AEToCrAE, CrAEToAE, AlpineP2202V1, AlpineFile, CrRPC, RPC  
EXPORTS AlpTransaction, AlpInstanceCourier 
=

BEGIN OPEN ATC: AEToCrAE, CTA: CrAEToAE, AlpT: AlpTransaction, AlpF: AlpFile, AlpI: AlpInstance, AE: AlpineEnvironment;


TransWorkProc: TYPE = AlpInstanceCourier.TransWorkProc;

DoTransWork: PUBLIC ENTRY PROC [inst: AlpInstanceCourier.Instance, transHandle: AlpTransaction.Handle, work: TransWorkProc] ~ {
ENABLE UNWIND => NULL;
accessReason: AlpineEnvironmentP2201V1.NeededAccess;
lockReason: AlpineEnvironmentP2201V1.LockFailure;
operationReason: AlpineEnvironmentP2201V1.OperationFailure;
unknownReason: AlpineEnvironmentP2201V1.UnknownType;
crReason: CrRPC.ErrorReason;
{
ENABLE {
AlpineP2202V1.AccessFailed => {accessReason _ missingAccess; GOTO accessFailed};
AlpineP2202V1.LockFailed => {lockReason _ why; GOTO lockFailed};
AlpineP2202V1.OperationFailed => {operationReason _ why; GOTO operationFailed};
AlpineP2202V1.PossiblyDamaged => {GOTO possiblyDamaged};
AlpineP2202V1.StaticallyInvalid => {GOTO staticallyInvalid};
AlpineP2202V1.Unknown => {unknownReason _ what; GOTO unknown};
AlpineP2202V1.AuthenticationError => { GOTO auth };
CrRPC.Error => SELECT errorReason FROM
unknown, unknownClass, argsError, resultsError, bulkDataError, notImplemented, unknownOperation, notServerHandle, notClientHandle, addressInappropriateForClass, other => REJECT;
ENDCASE => { crReason _ errorReason; GOTO rpcErr};
};
work[inst.courierHandle, inst.session, transHandle.transID]
EXITS
accessFailed => ERROR AlpineFile.AccessFailed[CTA.NeededAccess[accessReason]];
lockFailed => ERROR AlpineFile.LockFailed[CTA.LockFailure[lockReason]];
operationFailed => ERROR AlpineFile.OperationFailed[CTA.OperationFailure[operationReason]];
possiblyDamaged => TRUSTED {ERROR AlpineFile.PossiblyDamaged};
staticallyInvalid => ERROR AlpineFile.StaticallyInvalid;
unknown => ERROR AlpineFile.Unknown[CTA.UnknownType[unknownReason]];
auth => {SIGNAL RPC.CallFailed[runtimeProtocol]; ERROR};
rpcErr => SELECT crReason FROM 
courierVersionMismatch => {SIGNAL RPC.CallFailed[stubProtocol]; ERROR};
rejectedNoSuchProgram, rejectedNoSuchVersion, rejectedNoSuchProcedure, communicationFailure, remoteClose => {SIGNAL RPC.CallFailed[unbound]; ERROR};
rejectedInvalidArgument, rejectedUnspecified, remoteError, cantConnectToRemote, protocolError => {SIGNAL RPC.CallFailed[runtimeProtocol]; ERROR};
ENDCASE => ERROR;
};
};

InstWorkProc: TYPE = PROC [rpc: CrRPC.Handle, session: AlpineP2202V1.Session];

DoInstWork: ENTRY PROC [inst: AlpInstanceCourier.Instance, work: InstWorkProc] ~ {
ENABLE UNWIND => NULL;
accessReason: AlpineEnvironmentP2201V1.NeededAccess;
lockReason: AlpineEnvironmentP2201V1.LockFailure;
operationReason: AlpineEnvironmentP2201V1.OperationFailure;
unknownReason: AlpineEnvironmentP2201V1.UnknownType;
crReason: CrRPC.ErrorReason;
{
ENABLE {
AlpineP2202V1.AccessFailed => {accessReason _ missingAccess; GOTO accessFailed};
AlpineP2202V1.LockFailed => {lockReason _ why; GOTO lockFailed};
AlpineP2202V1.OperationFailed => {operationReason _ why; GOTO operationFailed};
AlpineP2202V1.PossiblyDamaged => {GOTO possiblyDamaged};
AlpineP2202V1.StaticallyInvalid => {GOTO staticallyInvalid};
AlpineP2202V1.Unknown => {unknownReason _ what; GOTO unknown};
AlpineP2202V1.AuthenticationError => { GOTO auth };
CrRPC.Error => SELECT errorReason FROM
unknown, unknownClass, argsError, resultsError, bulkDataError, notImplemented, unknownOperation, notServerHandle, notClientHandle, addressInappropriateForClass, other => REJECT;
ENDCASE => { crReason _ errorReason; GOTO rpcErr};
};
work[inst.courierHandle, inst.session]
EXITS
accessFailed => ERROR AlpineFile.AccessFailed[CTA.NeededAccess[accessReason]];
lockFailed => ERROR AlpineFile.LockFailed[CTA.LockFailure[lockReason]];
operationFailed => ERROR AlpineFile.OperationFailed[CTA.OperationFailure[operationReason]];
possiblyDamaged => TRUSTED {ERROR AlpineFile.PossiblyDamaged};
staticallyInvalid => ERROR AlpineFile.StaticallyInvalid;
unknown => ERROR AlpineFile.Unknown[CTA.UnknownType[unknownReason]];
auth => {SIGNAL RPC.CallFailed[runtimeProtocol]; ERROR};
rpcErr => SELECT crReason FROM 
courierVersionMismatch => {SIGNAL RPC.CallFailed[stubProtocol]; ERROR};
rejectedNoSuchProgram, rejectedNoSuchVersion, rejectedNoSuchProcedure, communicationFailure, remoteClose => {SIGNAL RPC.CallFailed[unbound]; ERROR};
rejectedInvalidArgument, rejectedUnspecified, remoteError, cantConnectToRemote, protocolError => {SIGNAL RPC.CallFailed[runtimeProtocol]; ERROR};
ENDCASE => ERROR;
};
};

Create: PUBLIC PROCEDURE 
[instHandle: AlpI.Handle, createLocalWorker: BOOLEAN] 
RETURNS [handle: AlpT.Handle] 
= BEGIN
Work: InstWorkProc ~ {
transID: AlpineEnvironmentP2201V1.TransID;
verifier: XNSAuth.Verifier;
[transID, verifier] _ AlpineP2202V1.CreateTransaction[rpc, session, createLocalWorker]; 
handle _ NEW[AlpT.Object _ [inst: instHandle, transID: CTA.TransID[transID]]];
};
DoInstWork[NARROW[instHandle.otherInterfaces.first], Work];
END;

CreateWithTransID: PUBLIC PROCEDURE 
[instHandle: AlpI.Handle, transID: AE.TransID, createLocalWorker: BOOLEAN] 
RETURNS [handle: AlpT.Handle] 
= BEGIN
Work: InstWorkProc ~ {
verifier: XNSAuth.Verifier;
handle _ NEW[AlpT.Object _ [inst: instHandle, transID: transID]];
IF createLocalWorker THEN verifier _ AlpineP2202V1.CreateWorker[rpc, session, ATC.TransID[transID], ATC.FileStore[instHandle.fileStore]]; 
};
DoInstWork[NARROW[instHandle.otherInterfaces.first], Work];
END;

CreateWorker: PUBLIC PROCEDURE
[handle: AlpT.Handle, coordinator: AE.FileStore] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
verifier _ AlpineP2202V1.CreateWorker[rpc, session, ATC.TransID[transID], ATC.FileStore[coordinator]]; 
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

Finish:  PUBLIC PROCEDURE
[handle: AlpT.Handle, requestedOutcome: AlpT.RequestedOutcome, continue: BOOLEAN] 
RETURNS[outcome: AE.Outcome] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
crTransID: AlpineEnvironmentP2201V1.TransID;
crOutcome: AlpineEnvironmentP2201V1.Outcome;
[crOutcome, crTransID, verifier] _ AlpineP2202V1.FinishTransaction[rpc, session, ATC.TransID[transID], ATC.CommitOrAbort[requestedOutcome], continue];
outcome _ CTA.Outcome[crOutcome];
handle.transID _ CTA.TransID[crTransID]; 
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

AssertAlpineWheel: PUBLIC PROCEDURE
[handle: AlpT.Handle, enable: BOOLEAN] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
verifier _ AlpineP2202V1.AssertAlpineWheel[rpc, session, ATC.TransID[transID], enable];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

GetVolumeGroup: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, lock: AE.LockOption]
RETURNS[volumes: LIST OF AE.VolumeID] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
crVolumes: AlpineEnvironmentP2201V1.VolumeIDs;
[crVolumes, verifier] _ AlpineP2202V1.GetGroup[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID], ATC.LockOption[lock]];
volumes _ CTA.VolumeIDs[crVolumes];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

GetNextVolumeGroup: PUBLIC PROCEDURE
[handle: AlpT.Handle, previousGroup: AE.VolumeGroupID, lock: AE.LockOption] 
RETURNS[volumeGroupID: AE.VolumeGroupID] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
crVolumeGroupID: AlpineEnvironmentP2201V1.VolumeGroupID;
[crVolumeGroupID, verifier] _ AlpineP2202V1.GetNextGroup[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[previousGroup], ATC.LockOption[lock]];
volumeGroupID _ CTA.VolumeGroupID[crVolumeGroupID];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

GetEnclosingVolumeGroup: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeID: AE.VolumeID, lock: AE.LockOption] 
RETURNS[volumeGroupID: AE.VolumeGroupID] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
crVolumeGroupID: AlpineEnvironmentP2201V1.VolumeGroupID;
[crVolumeGroupID, verifier] _ AlpineP2202V1.GetEnclosingGroup[rpc, session, ATC.TransID[transID], ATC.VolumeID[volumeID], ATC.LockOption[lock]];
volumeGroupID _ CTA.VolumeGroupID[crVolumeGroupID];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

CreateOwner: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, owner: AE.OwnerName, properties: LIST OF AE.OwnerPropertyValuePair, enforceTotalQuota: BOOLEAN] 
RETURNS[spaceLeftOnVolumeGroup: AE.PageCount] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
crSpaceLeftOnVolumeGroup: AlpineEnvironmentP2201V1.PageCount;
[crSpaceLeftOnVolumeGroup, verifier] _ AlpineP2202V1.CreateOwner[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID], ATC.OwnerName[owner], ATC.OwnerProperties[properties], enforceTotalQuota];
spaceLeftOnVolumeGroup _ CTA.PageCount[crSpaceLeftOnVolumeGroup];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

DestroyOwner: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, owner: AE.OwnerName] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
verifier _ AlpineP2202V1.DestroyOwner[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID], ATC.OwnerName[owner]];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

ReadNextOwner: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, previousOwner: AE.OwnerName, desiredProperties: AE.OwnerPropertySet] 
RETURNS[owner: AE.OwnerName, properties: LIST OF AE.OwnerPropertyValuePair] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
crOwner: AlpineEnvironmentP2201V1.OwnerName;
crProperties: AlpineEnvironmentP2201V1.OwnerProperties;
[crOwner, crProperties, verifier] _ AlpineP2202V1.NextOwner[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID], ATC.OwnerName[previousOwner], ATC.OwnerPropertySet[desiredProperties]];
owner _ CTA.OwnerName[crOwner];
properties _ CTA.OwnerProperties[crProperties];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

ReadOwnerProperties: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, owner: AE.OwnerName, desiredProperties: AE.OwnerPropertySet] 
RETURNS[properties: LIST OF AE.OwnerPropertyValuePair] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
crProperties: AlpineEnvironmentP2201V1.OwnerProperties;
[crProperties, verifier] _ AlpineP2202V1.ReadOwnerProperties[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID], ATC.OwnerName[owner], ATC.OwnerPropertySet[desiredProperties]];
properties _ CTA.OwnerProperties[crProperties];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

WriteOwnerProperties: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, owner: AE.OwnerName, overCommitQuotasIfNeeded: BOOLEAN, properties:  LIST OF AE.OwnerPropertyValuePair] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
verifier _ AlpineP2202V1.WriteOwnerProperties[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID], ATC.OwnerName[owner], ATC.OwnerProperties[properties], NOT overCommitQuotasIfNeeded];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

ReadOwnerDBProperties: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID] 
RETURNS[nOwners, nEntriesUsed, nEntries: NAT, totalQuota, totalSpaceInUse, volumeGroupSize: AE.PageCount] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
crTotalQuota, crTotalSpaceInUse, crVolumeGroupSize: AlpineEnvironmentP2201V1.PageCount;
[nOwners, nEntriesUsed, nEntries, crTotalQuota, crTotalSpaceInUse, crVolumeGroupSize, verifier] _ AlpineP2202V1.ReadOwnerDBProperties[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID]];
totalQuota _ CTA.PageCount[crTotalQuota];
totalSpaceInUse _ CTA.PageCount[crTotalSpaceInUse];
volumeGroupSize _ CTA.PageCount[crVolumeGroupSize];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

ReorganizeOwnerDB: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, nEntries: NAT] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
verifier _ AlpineP2202V1.ReorganizeOwnerDB[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID], nEntries];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

UnlockOwnerDB: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID] 
= BEGIN
Work: TransWorkProc ~ {
verifier: XNSAuth.Verifier;
verifier _ AlpineP2202V1.UnlockOwnerDB[rpc, session, ATC.TransID[transID], ATC.VolumeGroupID[volumeGroupID]];
};
DoTransWork[NARROW[handle.inst.otherInterfaces.first], handle, Work];
END;

END.

vAlpTransactionCourierImpl.mesa
Carl Hauser, November 12, 1987 11:53:14 am PST

Exported to AlpInstanceCourier

ΚΧ˜š
œ™Icode™.—J™Jš
Οk	˜	˜Kš
œ	˜	Kš
œ	˜	K˜Kš
œ˜Kš
œ˜K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜Kš
œ˜—J˜J˜šΟnœœ
˜(Jšœœ#˜4Jšœ<˜CJšœ$˜+—Jš
œ
˜
J˜Jšœ
œ
œœžœžœžœœ˜wJ˜J˜Kšœœ$˜7K˜Kš
œ™šžœœ
œ
œa˜Kšœ
œœ
˜Kš
œ4˜4Kš
œ1˜1Kš
œ;˜;Kš
œ4˜4Kš
œ˜˜
šœ˜Kšœ=œ˜PKšœ.œ
˜@Kšœ9œ˜OKšœ"œ˜8Kšœ$œ˜<Kšœ0œ
˜>Kšœ'œ˜3šœœ˜&Kšœͺ
œ
˜±
Kšœœ	˜2—Kš
œ˜—K˜;š
˜Kšœœ9˜NKšœœ4˜GKšœœC˜[Kšœœœ˜>Kšœœ˜8Kšœœ4˜DKšœ	œ
œœ˜8šœ
œ
œ
˜Kšœœ
œœ˜GKšœmœ
œœ˜”
Kšœbœ
œœ˜‘
Kšœœ
˜——K˜—K˜—J˜Kšœœœ5˜NK˜šž
œ
œ<˜RKšœ
œœ
˜Kš
œ4˜4Kš
œ1˜1Kš
œ;˜;Kš
œ4˜4Kš
œ˜˜
šœ˜Kšœ=œ˜PKšœ.œ
˜@Kšœ9œ˜OKšœ"œ˜8Kšœ$œ˜<Kšœ0œ
˜>Kšœ'œ˜3šœœ˜&Kšœͺ
œ
˜±
Kšœœ	˜2—Kš
œ˜—K˜&š
˜Kšœœ9˜NKšœœ4˜GKšœœC˜[Kšœœœ˜>Kšœœ˜8Kšœœ4˜DKšœ	œ
œœ˜8šœ
œ
œ
˜Kšœœ
œœ˜GKšœmœ
œœ˜”
Kšœbœ
œœ˜‘
Kšœœ
˜——K˜—K˜—J˜šžœœ
	œ
˜Jšœ-œ˜6Jšœ˜šœ
˜šžœ˜Kš
œ*˜*K˜Kš
œX˜XKšœ	œB˜NK˜—Kšœœ*˜;Kšœ
˜——J˜šžœœ
	œ
˜$Jšœ#œœ˜KJšœ˜šœ
˜šžœ˜K˜Kšœ	œ5˜AKšœœq˜Š
K˜—Kšœœ*˜;Kšœ
˜——J˜šžœœ
	˜Jšœ#œ˜1šœ
˜šžœ˜K˜Kš
œg˜gK˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜JšœIœ˜RJšœ
œ
˜šœ
˜šžœ˜K˜Kš
œ,˜,Kš
œ,˜,KšœQœœ,˜–
Kš
œ!˜!Kš
œ)˜)K˜—Kšœœ3˜EKšœ
˜——K˜šžœœ
	˜#Jšœœ˜'šœ
˜šžœ˜K˜Kšœ9œ˜WK˜—Kšœœ3˜EKšœ
˜—J˜—šžœœ
	˜ Jšœ$œœ˜KJšœ
œ
œ
œ˜&šœ
˜šžœ˜K˜Kš
œ.˜.Kšœ=œœœ˜‹
Kš
œ#˜#K˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜$Jšœ$œœ
˜LJšœœ˜)šœ
˜šžœ˜K˜Kš
œ8˜8KšœGœœœ˜•
Kš
œ3˜3K˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜)Jšœœœ
˜BJšœœ˜)šœ
˜šžœ˜K˜Kš
œ8˜8KšœLœœœ˜
Kš
œ3˜3K˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜Kš
œ%œœœ
œ
œ+œ˜—
Kšœœ˜.šœ
˜šžœ˜K˜Kš
œ=˜=Kš	œOœœœœ1˜Ρ
Kš
œA˜AK˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜Jšœ%œœ˜Lšœ
˜šžœ˜K˜Kš	œžœœœœ˜‚
K˜—Kšœœ3˜EKšœ
˜——J˜šž
œœ
	˜Kšœ$œœœ˜|Jš
œœœ
œ
œ˜Lšœ
˜šžœ˜K˜Kš
œ,˜,Kš
œ7˜7Kš	œJœœœœ&˜Ι
Kš
œ˜Kš
œ/˜/Kš
œ˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜%Kšœ$œœœ˜tJšœ
œ
œ
œ˜7šœ
˜šžœ˜K˜Kš
œ7˜7Kš	œKœœœœ&˜Β
Kš
œ/˜/K˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜&Kš
œ$œœ&œœ
œ
œ˜Ÿ
šœ
˜šžœ˜K˜Kšœ<œœœœœ˜Ι
K˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜'Jšœ$œ˜7Kšœ"œ0œ˜jšœ
˜šžœ˜K˜Kš
œW˜WKšœ”
œœ˜Μ
Kš
œ)˜)Kš
œ3˜3Kš
œ3˜3K˜—Kšœœ3˜EKšœ
˜——J˜šžœœ
	˜#Jšœ$œœ˜Fšœ
˜šžœ˜K˜Kšœ9œœ)˜{K˜—Kšœœ3˜EKšœ
˜——J˜šž
œœ
	˜Jšœ$œ˜7šœ
˜šžœ˜K˜Kšœž
œœœ˜mK˜—Kšœœ3˜EKšœ
˜—J˜—Jšœ
˜J˜J™—…—3,?y