-- AlpTransactionImpl.mesa
-- Last edited by
--   Kolling on August 12, 1983 11:34 am

DIRECTORY

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


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

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


-- 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.


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

CreateWithTransID: PUBLIC PROCEDURE [instHandle: AlpI.Handle, transID: AE.TransID,
 createLocalWorker: BOOLEAN] 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
      ! RPC.CallFailed => IF why = unbound OR why = timeout THEN
         AlpPrivate.NoticeUnboundInstance[instHandle]];
   END;


CreateWorker: PUBLIC PROCEDURE[handle: AlpT.Handle, coordinator: AE.FileStore] =
   TRUSTED BEGIN handle.inst.trans.CreateWorker[handle.inst.conversation, handle.transID,
     coordinator
      ! 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 [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]];
   END;

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;

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.