
<<AlpineV2ServerAImpl.mesa>>
    <<Carl Hauser, November 16, 1987 2:04:06 pm PST>>
<<>>
    DIRECTORY
        CrAEToAE,
        AEToCrAE,
        AlpineP2202V2,
        AlpineV2ServerInternal,
        AlpineEnvironment,
        AlpineEnvironmentP2201V1,
        AlpineFile,
        AlpineOwner,
        AlpineTransaction,
        AlpineVolume,
        CountedVM,
        CrRPC,
        VMStreams;


    AlpineV2ServerAImpl: CEDAR PROGRAM
    IMPORTS AlpineFile, CrAEToAE, AEToCrAE, AlpineV2ServerInternal, AlpineTransaction, VMStreams, CountedVM
    EXPORTS AlpineP2202V2
    ~ BEGIN

    OPEN CTA: CrAEToAE, ATC: AEToCrAE, AE: AlpineEnvironment;

    DoWork: PROC [work: PROC] ~ AlpineV2ServerInternal.DoWork;

    Conversation: PROC [ session: AlpineP2202V2.Session ] 
    RETURNS [ conv:  AlpineEnvironment.Conversation] ~ AlpineV2ServerInternal.Conversation;

    <<Session Control>>
        Logon: PUBLIC AlpineP2202V2.LogonType ~ {
            session _ AlpineV2ServerInternal.CreateSession[service, credentials, gvCredentials];
            replyVerifier _ verifier;
            session.verifier _ replyVerifier;
            };

        Logoff: PUBLIC AlpineP2202V2.LogoffType ~ {
            AlpineV2ServerInternal.DestroySession[session];
            };

    <<Transaction Operations>>
        CreateTransaction: PUBLIC AlpineP2202V2.CreateTransactionType = {
        Work: PROC ~ TRUSTED {
        transID _ ATC.TransID[AlpineTransaction.Create[Conversation[session], createLocalWorker]];
        };
            DoWork[Work];
            replyVerifier _ session.verifier;
            };

        CreateWorker: PUBLIC AlpineP2202V2.CreateWorkerType ~ {
        Work: PROC ~ TRUSTED {
        AlpineTransaction.CreateWorker[Conversation[session], CTA.TransID[transID], CTA.FileStore[coordinator]];
        };
            DoWork[Work];
            replyVerifier _ session.verifier;
            };

        AssertAlpineWheel: PUBLIC AlpineP2202V2.AssertAlpineWheelType ~ {
        Work: PROC ~ TRUSTED {
        AlpineTransaction.AssertAlpineWheel[Conversation[session], CTA.TransID[transID], enable];
        };
            DoWork[Work];
            replyVerifier _ session.verifier;
            };

        FinishTransaction: PUBLIC AlpineP2202V2.FinishTransactionType ~ {
        Work: PROC ~ TRUSTED {
        aoutcome: AlpineEnvironment.Outcome;
        anewTrans: AlpineEnvironment.TransID;
        [aoutcome, anewTrans] _ AlpineTransaction.Finish[Conversation[session], CTA.TransID[transID], CTA.CommitOrAbort[requestedOutcome], 
        continue];
        outcome _ ATC.Outcome[aoutcome];
        newTrans _ ATC.TransID[anewTrans];
        };
            DoWork[Work];
            replyVerifier _ session.verifier;
            };

    <<File Operations>>
        Open: PUBLIC AlpineP2202V2.OpenType ~ {
            Work: PROC = TRUSTED {
                aopenFileID: AE.OpenFileID;
                afileID: AE.FileID;
                [aopenFileID, afileID] _ AlpineFile.Open[Conversation[session], CTA.TransID[transID], CTA.UniversalFile[universalFile], 
                CTA.AccessRights[access], CTA.LockOption[lock], CTA.RecoveryOption[recoveryOption], 
                CTA.ReferencePattern[referencePattern]];
                openFileID _ ATC.OpenFileID[aopenFileID];
                fileID _ ATC.FileID[afileID];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        Create: PUBLIC AlpineP2202V2.CreateType ~ {
            Work: PROC = TRUSTED {
                aopenFileID: AE.OpenFileID;
                afileID: AE.UniversalFile;
                [aopenFileID, afileID] _ AlpineFile.Create[Conversation[session], CTA.TransID[transID], CTA.VolOrVolGroupID[volumeID], 
                CTA.OwnerName[owner], CTA.PageCount[initialSize], CTA.RecoveryOption[recoveryOption], 
                CTA.ReferencePattern[referencePattern]];
                openFileID _ ATC.OpenFileID[aopenFileID];
                universalFile _ ATC.UniversalFile[afileID];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        Close: PUBLIC AlpineP2202V2.CloseType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.Close[Conversation[session], CTA.OpenFileID[openFileID]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        Delete: PUBLIC AlpineP2202V2.DeleteType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.Delete[Conversation[session], CTA.OpenFileID[openFileID]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        GetUniversalFile: PUBLIC AlpineP2202V2.GetUniversalFileType ~ {
            Work: PROC = TRUSTED {
                universalFile _ ATC.UniversalFile[AlpineFile.GetUniversalFile[Conversation[session], CTA.OpenFileID[openFileID]]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        GetTransID: PUBLIC AlpineP2202V2.GetTransIDType ~ {
            Work: PROC = TRUSTED {
                transID _ ATC.TransID[AlpineFile.GetTransID[Conversation[session], CTA.OpenFileID[openFileID]]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        GetAccessRights: PUBLIC AlpineP2202V2.GetAccessRightsType ~ {
            Work: PROC = TRUSTED {
                access _ ATC.AccessRights[AlpineFile.GetAccessRights[Conversation[session], CTA.OpenFileID[openFileID]]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        GetLockOption: PUBLIC AlpineP2202V2.GetLockOptionType ~ {
            Work: PROC = TRUSTED {
                lock _ ATC.LockOption[AlpineFile.GetLockOption[Conversation[session], CTA.OpenFileID[openFileID]]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        SetLockOption: PUBLIC AlpineP2202V2.SetLockOptionType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.SetLockOption[Conversation[session], CTA.OpenFileID[openFileID], CTA.LockOption[lock]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        GetRecoveryOption: PUBLIC AlpineP2202V2.GetRecoveryOptionType ~ {
            Work: PROC = TRUSTED {
                recoveryOption _ ATC.RecoveryOption[AlpineFile.GetRecoveryOption[Conversation[session], CTA.OpenFileID[openFileID]]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        GetReferencePattern: PUBLIC AlpineP2202V2.GetReferencePatternType ~ {
            Work: PROC = TRUSTED {
                referencePattern _ ATC.ReferencePattern[AlpineFile.GetReferencePattern[Conversation[session], CTA.OpenFileID[openFileID]]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        SetReferencePattern: PUBLIC AlpineP2202V2.SetReferencePatternType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.SetReferencePattern[Conversation[session], CTA.OpenFileID[openFileID], CTA.ReferencePattern[referencePattern]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        ReadPages: PUBLIC AlpineP2202V2.ReadPagesType = {
            <<[h: CrRPC.Handle, session: AlpineP2202V2.Session, openFileID: AlpineP2202V2.CARD32, pageRun: AlpineEnvironmentP2201V1.PageRun, 
            lock: AlpineEnvironmentP2201V1.LockOption, content: CrRPC.BulkDataSink] RETURNS [replyVerifier: 
            AuthenticationP14V2.SeqWords]>>
            Work: PROC = TRUSTED {
                buffer: CountedVM.Handle _ CountedVM.SimpleAllocate[pageRun.count*AlpineEnvironmentP2201V1.wordsPerPage];
                Never: CrRPC.BulkDataCheckAbortProc ~ CHECKED {RETURN[FALSE]};
                AlpineFile.ReadPages[Conversation[session], CTA.OpenFileID[openFileID], CTA.PageRun[pageRun], DESCRIPTOR[buffer.pointer, 
                buffer.words], CTA.LockOption[lock]];
                [] _ content[h, VMStreams.VMIS[buffer.interval], Never];
                TRUSTED {CountedVM.Free[buffer]};
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        WritePages: PUBLIC AlpineP2202V2.WritePagesType ~ {
            Work: PROC = TRUSTED {
                buffer: CountedVM.Handle _ CountedVM.SimpleAllocate[pageRun.count*AlpineEnvironmentP2201V1.wordsPerPage];
                Never: CrRPC.BulkDataCheckAbortProc ~ CHECKED {RETURN[FALSE]};
                [] _ content[h, VMStreams.VMOS[buffer.interval], Never];
                AlpineFile.WritePages[Conversation[session], CTA.OpenFileID[openFileID], CTA.PageRun[pageRun], DESCRIPTOR[buffer.pointer, 
                buffer.words], CTA.LockOption[lock]];
                TRUSTED {CountedVM.Free[buffer]};
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        LockPages: PUBLIC AlpineP2202V2.LockPagesType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.LockPages[Conversation[session], CTA.OpenFileID[openFileID], CTA.PageRun[pageRun], CTA.LockOption[lock]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        UnlockPages: PUBLIC AlpineP2202V2.UnlockPagesType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.UnlockPages[Conversation[session], CTA.OpenFileID[openFileID], CTA.PageRun[pageRun]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        ReadProperties: PUBLIC AlpineP2202V2.ReadPropertiesType ~ {
            Work: PROC = TRUSTED {
                properties _ ATC.Properties[AlpineFile.ReadProperties[Conversation[session], CTA.OpenFileID[openFileID], 
                CTA.PropertySet[desiredProperties], CTA.LockOption[lock]]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        WriteProperties: PUBLIC AlpineP2202V2.WritePropertiesType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.WriteProperties[Conversation[session], CTA.OpenFileID[openFileID], CTA.Properties[properties], CTA.LockOption[lock]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        UnlockVersion: PUBLIC AlpineP2202V2.UnlockVersionType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.UnlockVersion[Conversation[session], CTA.OpenFileID[openFileID]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        IncrementVersion: PUBLIC AlpineP2202V2.IncrementVersionType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.IncrementVersion[Conversation[session], CTA.OpenFileID[openFileID], increment];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        GetSize: PUBLIC AlpineP2202V2.GetSizeType ~ {
            Work: PROC = TRUSTED {
                size _ ATC.PageCount[AlpineFile.GetSize[Conversation[session], CTA.OpenFileID[openFileID], CTA.LockOption[lock]]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        SetSize: PUBLIC AlpineP2202V2.SetSizeType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.SetSize[Conversation[session], CTA.OpenFileID[openFileID], CTA.PageCount[size], CTA.LockOption[lock]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };

        UnlockFile: PUBLIC AlpineP2202V2.UnlockFileType ~ {
            Work: PROC = TRUSTED {
                AlpineFile.UnlockFile[Conversation[session], CTA.OpenFileID[openFileID]];
                };
        DoWork[Work];
            replyVerifier _ session.verifier;
            };


    END.