DIRECTORY

AlpineEnvironment
USING[CommitOrAbort, FileStore, LockFailure, LockOption, NeededAccess,
OperationFailure, Outcome, OwnerName, OwnerPropertySet,
OwnerPropertyValuePair, PageCount, TransID, TransactionPriority, UnknownType, 
VolumeID, VolumeGroupID],
AlpineFile
USING[AccessFailed, LockFailed, OperationFailed, PossiblyDamaged,
StaticallyInvalid, Unknown],
AlpInstance
USING[Handle],
AlpTransaction
USING[Handle, Object, RequestedOutcome, BeforeFinishProc, AfterFinishProc, FinishInfos],
AlpPrivate
USING[NoticeUnboundInstance],
RPC
USING[CallFailed],
AlpineTransactionRpcControl, 
AlpineVolumeRpcControl, 
AlpineOwnerRpcControl;


AlpTransactionImpl: CEDAR PROGRAM 
IMPORTS AF: AlpineFile, AlpPrivate, RPC, AlpineTransactionRpcControl, AlpineVolumeRpcControl, AlpineOwnerRpcControl  
EXPORTS AlpTransaction =

BEGIN OPEN AE: AlpineEnvironment, AlpI: AlpInstance, AlpT: AlpTransaction;




Priority: TYPE = AlpineEnvironment.TransactionPriority;

Create: PUBLIC PROCEDURE 
[instHandle: AlpI.Handle, createLocalWorker: BOOLEAN, priority: Priority _ normal] 
RETURNS [handle: AlpT.Handle] 
= TRUSTED BEGIN
RETURN[NEW[AlpT.Object _ [inst: instHandle, transID:
instHandle.trans.Create[instHandle.conversation, createLocalWorker, priority
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[instHandle]]]]];
END;

CreateWithTransID: PUBLIC PROCEDURE 
[instHandle: AlpI.Handle, transID: AE.TransID, createLocalWorker: BOOLEAN, priority: Priority _ normal] 
RETURNS [handle: AlpT.Handle] 
= TRUSTED BEGIN
handle _ NEW[AlpT.Object _ [inst: instHandle, transID: transID]];
IF createLocalWorker THEN instHandle.trans.CreateWorker[instHandle.conversation, transID,
instHandle.fileStore, priority
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[instHandle]];
END;


CreateWorker: PUBLIC PROCEDURE
[handle: AlpT.Handle, coordinator: AE.FileStore, priority: Priority _ normal] 
= TRUSTED BEGIN 
handle.inst.trans.CreateWorker[handle.inst.conversation, handle.transID, coordinator, priority
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];
END;

Finish:  PUBLIC PROCEDURE
[handle: AlpT.Handle, requestedOutcome: AlpT.RequestedOutcome, continue: BOOLEAN] 
RETURNS[outcome: AE.Outcome] 
= TRUSTED BEGIN
FOR l: AlpT.FinishInfos _ handle.finishInfos, l.rest WHILE l # NIL DO
IF l.first.beforeFinish # NIL THEN l.first.beforeFinish[handle, l.first.clientData, requestedOutcome, continue];
ENDLOOP; 
[outcome, handle.transID] _ handle.inst.trans.Finish[handle.inst.conversation, handle.transID, requestedOutcome, continue 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];
FOR l: AlpT.FinishInfos _ handle.finishInfos, l.rest WHILE l # NIL DO
IF l.first.afterFinish # NIL THEN l.first.afterFinish[handle, l.first.clientData, outcome];
ENDLOOP; 
END;

RegisterInterest: PUBLIC PROC [handle: AlpT.Handle, clientData: REF ANY _ NIL, beforeFinish: AlpT.BeforeFinishProc _ NIL , afterFinish: AlpT.AfterFinishProc _ NIL] ~ {
handle.finishInfos _ CONS[[beforeFinish, afterFinish, clientData], handle.finishInfos];
};

AssertAlpineWheel: PUBLIC PROCEDURE
[handle: AlpT.Handle, enable: BOOLEAN] 
= TRUSTED BEGIN
handle.inst.trans.AssertAlpineWheel[handle.inst.conversation, handle.transID, enable
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];
END;

GetVolumeGroup: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, lock: AE.LockOption]
RETURNS[volumes: LIST OF AE.VolumeID] 
= TRUSTED BEGIN
RETURN[handle.inst.volume.GetGroup[handle.inst.conversation, handle.transID, volumeGroupID, lock
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]]];
END;

GetNextVolumeGroup: PUBLIC PROCEDURE
[handle: AlpT.Handle, previousGroup: AE.VolumeGroupID, lock: AE.LockOption] 
RETURNS[volumeGroupID: AE.VolumeGroupID] 
= TRUSTED BEGIN
RETURN[handle.inst.volume.GetNextGroup[handle.inst.conversation,
handle.transID, previousGroup, lock
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]]];
END;

GetEnclosingVolumeGroup: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeID: AE.VolumeID, lock: AE.LockOption] 
RETURNS[volumeGroupID: AE.VolumeGroupID] 
= TRUSTED BEGIN 
RETURN[handle.inst.volume.GetEnclosingGroup[handle.inst.conversation, handle.transID, volumeID, lock
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]]];
END;

CreateOwner: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, owner: AE.OwnerName, properties: LIST OF AE.OwnerPropertyValuePair, enforceTotalQuota: BOOLEAN] 
RETURNS[spaceLeftOnVolumeGroup: AE.PageCount] 
= TRUSTED BEGIN 
RETURN[handle.inst.owner.Create[handle.inst.conversation, handle.transID, volumeGroupID, owner, properties, enforceTotalQuota
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]]];
END;

DestroyOwner: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, owner: AE.OwnerName] 
= TRUSTED BEGIN 
handle.inst.owner.Destroy[handle.inst.conversation, handle.transID,
volumeGroupID, owner
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];
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] 
= TRUSTED BEGIN
[owner, properties] _ handle.inst.owner.ReadNext[handle.inst.conversation,
handle.transID, volumeGroupID, previousOwner, desiredProperties
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];
END;

ReadOwnerProperties: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, owner: AE.OwnerName, desiredProperties: AE.OwnerPropertySet] 
RETURNS[properties: LIST OF AE.OwnerPropertyValuePair] 
= TRUSTED BEGIN
RETURN[handle.inst.owner.ReadProperties[handle.inst.conversation,
handle.transID,
volumeGroupID, owner, desiredProperties
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]]];
END;

WriteOwnerProperties: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, owner: AE.OwnerName, overCommitQuotasIfNeeded: BOOLEAN, properties:  LIST OF AE.OwnerPropertyValuePair] 
= TRUSTED BEGIN
handle.inst.owner.WriteProperties[handle.inst.conversation, handle.transID,
volumeGroupID, owner, properties, (NOT overCommitQuotasIfNeeded)
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];
END;

ReadOwnerDBProperties: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID] 
RETURNS[nOwners, nEntriesUsed, nEntries: NAT, totalQuota, totalSpaceInUse, volumeGroupSize: AE.PageCount] 
= TRUSTED BEGIN
[nOwners: nOwners, nEntriesUsed: nEntriesUsed, nEntries: nEntries,
totalQuota: totalQuota, totalSpaceInUse: totalSpaceInUse, volumeGroupSize:
volumeGroupSize] _ handle.inst.owner.ReadDBProperties[handle.inst.conversation,
handle.transID, volumeGroupID
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];   
END;

ReorganizeOwnerDB: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID, nEntries: NAT] 
= TRUSTED BEGIN
handle.inst.owner.ReorganizeDB[handle.inst.conversation, handle.transID,
volumeGroupID, nEntries
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];   
END;

UnlockOwnerDB: PUBLIC PROCEDURE
[handle: AlpT.Handle, volumeGroupID: AE.VolumeGroupID] 
= TRUSTED BEGIN
handle.inst.owner.Unlock[handle.inst.conversation, handle.transID,
volumeGroupID
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpPrivate.NoticeUnboundInstance[handle.inst]];   
END;

AccessFailed: PUBLIC ERROR [missingAccess: AE.NeededAccess] _ AF.AccessFailed;
LockFailed: PUBLIC ERROR [why: AE.LockFailure] _ AF.LockFailed;
OperationFailed: PUBLIC ERROR [why: AE.OperationFailure] _ AF.OperationFailed;
StaticallyInvalid: PUBLIC ERROR _ AF.StaticallyInvalid;
Unknown: PUBLIC ERROR [what: AE.UnknownType] _ AF.Unknown;
PossiblyDamaged: PUBLIC SIGNAL _ LOOPHOLE[AF.PossiblyDamaged];



END.
Edit Log

Initial: Kolling:  February 14, 1983 3:56 pm:  package to aid clients, in conjunction with AlpInstance and AlpFile.



μAlpTransactionImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last edited by
Kolling on August 12, 1983 11:34 am
Carl Hauser, June 18, 1986 10:54:56 am PDT
in addition to the errors documented for the corresponding Alpine procedures, all of the procedures defined in this interface can also error RPC.CallFailed[RPC.CallFailure].  At the moment, Alpine ignores the transID and lock parameters for GetVolumeGroup, GetNextVolumeGroup, and GetEnclosingVolumeGroup.
Κ	+˜š
œ™Icodešœ
Οm
œ1™<—š
œ™Jš
œ#™#K™*—J˜Jš
Οk	˜	˜˜šžœA˜FJ˜7J˜NJ˜——˜
šžœ<˜AJ˜——˜Jšžœ	˜—˜JšžœS˜X—˜
Jšžœ˜—š
ž˜Jšžœ
˜—J˜J˜J˜—J˜J˜šΟnœžœ
žœ
˜"Jšžœ
žœžœN˜uJšžœ˜—J˜Jš
žœ
žœ
žœŸœŸœ˜JJ˜J˜Jš
œ±™±J˜J˜Jšœ
žœ)˜7J˜šŸœžœ
ž	œ
˜Jšœ-žœ˜SJšžœ˜šœžœ
ž˜šžœ
žœ*˜4J˜Lšœžœžœžœž˜:J˜1——Jšžœ
˜——J˜šŸœžœ
ž	œ
˜$Jšœ#žœžœ˜hJšžœ˜šœžœ
ž˜Jšœ	žœ5˜Ašžœžœ@˜YJ˜šœžœžœžœž˜:J˜.——Jšžœ
˜——J˜J˜šŸœžœ
ž	˜Jšœ#žœ)˜Nšœžœ
žœ
˜š
œ^˜^šœžœžœžœž˜:J˜/——Jšžœ
˜——J˜šŸœžœ
ž	˜JšœIžœ˜RJšžœ
žœ
˜šœžœ
ž˜šžœ2žœžœ
ž˜EKšžœžœ
žœN˜pKšžœ˜	—š
œz˜zšœžœžœžœž˜:J˜/——šžœ2žœžœ
ž˜EKšžœžœ
žœ:˜[Kšžœ˜	—Jšžœ
˜J˜——šŸœžœ
žœ#žœ
žœžœ(žœ'žœ˜§
Kšœžœ>˜WK˜—J˜šŸœžœ
ž	˜#Jšœžœ˜'šœžœ
ž˜š
œT˜Tšœžœžœžœž˜:J˜/——Jšžœ
˜—J˜—šŸœžœ
ž	˜ Jšœ$žœžœ˜KJšžœ
žœ
žœ
žœ˜&šœžœ
ž˜šžœZ˜`šœžœžœžœž˜:J˜0——Jšžœ
˜——J˜šŸœžœ
ž	˜$Jšœ$žœžœ
˜LJšžœžœ˜)šœžœ
ž˜šžœ:˜@˜#šœžœžœžœž˜:J˜0———Jšžœ
˜——J˜šŸœžœ
ž	˜)Jšœžœžœ
˜BJšžœžœ˜)šœžœ
žœ
˜šžœ^˜dšœžœžœžœž˜:J˜0——Jšžœ
˜——J˜šŸœžœ
ž	˜Kš
œ%žœžœžœ
žœ
žœ+žœ˜—
Kšžœžœ˜.šœžœ
žœ
˜šžœw˜}šœžœžœžœž˜:J˜0——Jšžœ
˜——J˜šŸœžœ
ž	˜Jšœ%žœžœ˜Lšœžœ
žœ
˜š
œC˜C˜šœžœžœžœž˜:J˜/———Jšžœ˜——J˜šŸ
œžœ
ž	˜Kšœ$žœžœžœ˜|Jš
žœžœžœ
žœ
žœ˜Lšœžœ
ž˜š
œJ˜JJ˜?šœžœžœžœž˜:J˜/——Jšžœ
˜——J˜šŸœžœ
ž	˜%Kšœ$žœžœžœ˜tJšžœ
žœ
žœ
žœ˜7šœžœ
ž˜šžœ;˜A˜J˜'šœžœžœžœž˜:J˜0———Jšžœ
˜——J˜šŸœžœ
ž	˜&Kš
œ$žœžœ&žœžœ
žœ
žœ˜Ÿ
šœžœ
ž˜š
œK˜KJšœ#žœ˜@šœžœžœžœž˜:J˜/——Jšžœ
˜——J˜šŸœžœ
ž	˜'Jšœ$žœ˜7Kšžœ"žœ0žœ˜jšœžœ
ž˜š
œB˜BJ˜JJ˜O˜šœžœžœžœž˜:J˜2———Jšžœ
˜——J˜šŸœžœ
ž	˜#Jšœ$žœžœ˜Fšœžœ
ž˜š
œH˜HJ˜šœžœžœžœž˜:J˜2——Jšžœ
˜——J˜šŸ
œžœ
ž	˜Jšœ$žœ˜7šœžœ
ž˜š
œB˜BJ˜
šœžœžœžœž˜:J˜2——Jšžœ
˜—J˜—Jš
Ÿœžœ
žœžœžœ˜NJš
Ÿ
œžœ
žœžœžœ˜?Jš
Ÿœžœ
žœžœžœ˜NJšŸœžœ
žœžœ˜7Jš
Ÿœžœ
žœžœžœ	˜:Jš
Ÿœžœ
žœžœ
žœ˜>J˜J˜J˜šžœ
˜J˜—J˜JšŸœl˜sJ˜J˜—…—!Ζ,έ