-- RPCTest.mesa
-- Andrew Birrell  January 27, 1983 10:40 am

DIRECTORY
Process, MesaRPC, RPCLupine, Runtime, SpyClient, System;

RPCTest: MONITOR
IMPORTS Process, MesaRPC, RPCLupine, Runtime, SpyClient, System =

BEGIN

-- ******** Test program ******** --

Finished: SIGNAL = CODE;
signalFinished: BOOLEAN _ TRUE;
extraArgPkts:   CARDINAL _ 0;
extraArgLength: RPCLupine.DataLength _ RPCLupine.maxDataLength-1;
argLength:      RPCLupine.DataLength _ 1;
extraResPkts:   CARDINAL _ 0;
extraResLength: RPCLupine.DataLength _ RPCLupine.maxDataLength;
resLength:      RPCLupine.DataLength _ 2;
callDelaySecs:  CARDINAL _ 0;
senderGapSecs:  CARDINAL _ 0;
receiverGapSecs:CARDINAL _ 0;
callGapSecs:    CARDINAL _ 0;
tries:          CARDINAL _ 1000;
quit:           BOOLEAN _ FALSE;
raiseSignal:    BOOLEAN _ FALSE;
resumeSignal:   BOOLEAN _ TRUE;
authenticate:   BOOLEAN _ TRUE;
gvExport:       BOOLEAN _ TRUE;
gvInstance:     STRING = "RPCRuntime.pa";
nongvInstance:  STRING = "Tokay";
callerName:     MesaRPC.Principal _ "Test.pa";
callerKey:      MesaRPC.EncryptionKey _ MesaRPC.MakeKey["Test"L];
exporterName:   MesaRPC.Principal _ "RPCRuntime.pa";
exporterKey:    MesaRPC.EncryptionKey _ MesaRPC.MakeKey["zzy"L];
userTest:       BOOLEAN _ TRUE;
spyWanted:      BOOLEAN _ FALSE;
minWanted:      BOOLEAN _ TRUE;
caller: PROCESS;

pktSpace: ARRAY[1..RPCLupine.pktOverhead+RPCLupine.maxDataLength] OF WORD;
pkt: RPCLupine.StubPkt = RPCLupine.GetStubPkt[@pktSpace];
import: RPCLupine.ImportHandle _ NIL;
conversation: MesaRPC.Conversation;


-- Test version of stub code --

RemoteSignal: SIGNAL = CODE;

SignalDispatcher: RPCLupine.Dispatcher =
  BEGIN
  UNTIL lastPkt
  DO [callLength,lastPkt] _ RPCLupine.ReceiveExtraPkt[pkt] ENDLOOP;
  SIGNAL RemoteSignal[];
  RETURN[0]
  END;

Send: PROC =
  BEGIN
  [] _ RPCLupine.StartCall[pkt, import, conversation];
  FOR p: CARDINAL IN [1..extraArgPkts]
  DO RPCLupine.SendPrelimPkt[pkt, extraArgLength];
     IF senderGapSecs > 0
     THEN Process.Pause[Process.SecondsToTicks[senderGapSecs]];
  ENDLOOP;
  BEGIN
    length: RPCLupine.DataLength;
    last: BOOLEAN;
    [length, last] _ RPCLupine.Call[pkt, argLength, RPCLupine.maxDataLength, SignalDispatcher];
    UNTIL last
    DO IF receiverGapSecs > 0
       THEN Process.Pause[Process.SecondsToTicks[receiverGapSecs]];
       [length, last] _ RPCLupine.ReceiveExtraPkt[pkt];
    ENDLOOP;
  END;
  END;

TestDispatcher: RPCLupine.Dispatcher =
  BEGIN
  -- Dummy dispatcher: consumes args and sends dummy result --
  UNTIL lastPkt
  DO IF receiverGapSecs > 0
     THEN Process.Pause[Process.SecondsToTicks[receiverGapSecs]];
     [callLength,lastPkt] _ RPCLupine.ReceiveExtraPkt[pkt];
  ENDLOOP;
  Client[ ! RemoteSignal =>
          BEGIN
	  RPCLupine.StartSignal[pkt];
	  [callLength,lastPkt] _ RPCLupine.Call[pkt, 0, RPCLupine.maxDataLength, NIL];
	  UNTIL lastPkt
	  DO [callLength,lastPkt] _ RPCLupine.ReceiveExtraPkt[pkt] ENDLOOP;
	  RESUME
	  END ];
  IF callDelaySecs > 0
  THEN Process.Pause[Process.SecondsToTicks[callDelaySecs]];
  FOR res: CARDINAL IN [1..extraResPkts]
  DO RPCLupine.SendPrelimPkt[pkt,extraResLength];
     IF senderGapSecs > 0
     THEN Process.Pause[Process.SecondsToTicks[senderGapSecs]];
  ENDLOOP;
  RETURN[resLength];
  END;


-- Test version of client code --

Client: PROC = { IF raiseSignal THEN SIGNAL RemoteSignal[] };
-- remote procedure being called! --

instance: STRING _ IF gvExport THEN gvInstance ELSE nongvInstance;

exported: BOOLEAN _ FALSE;
expHandle: RPCLupine.ExportHandle;

Work: PROC =
  BEGIN
  import _ RPCLupine.ImportInterface[["RPC-Test"L, instance], [0,0] !
     MesaRPC.ImportFailed =>
       IF why = unbound OR why = communications
       THEN BEGIN
            expHandle _ RPCLupine.ExportInterface[exporterName, exporterKey,
		                    ["RPC-Test"L, instance], TestDispatcher, [0,0]];
	    exported _ TRUE;
            import _ RPCLupine.ImportInterface[["RPC-Test"L, instance],[0,0]];
            CONTINUE
            END ];


   BEGIN
     spyAvailable: BOOLEAN = Runtime.IsBound[SpyClient.StartSpy];
     DO UNTIL userTest OR quit DO Process.Pause[Process.SecondsToTicks[5]] ENDLOOP;
	IF quit THEN EXIT;
        conversation _ IF authenticate
                       THEN MesaRPC.StartConversation[callerName, callerKey, exporterName, CBCCheck]
	               ELSE MesaRPC.unencrypted;
	Send[! RemoteSignal => IF resumeSignal THEN RESUME ELSE CONTINUE];
	Send[! RemoteSignal => IF resumeSignal THEN RESUME ELSE CONTINUE];
        IF spyWanted AND spyAvailable THEN SpyClient.StartSpy[];
        BEGIN
	    start:     System.Pulses = System.GetClockPulses[];
            end:       System.Pulses;
	    minPulses: LONG CARDINAL _ LAST[LONG CARDINAL];
            elapsed:   System.Microseconds;
	    minTime:   System.Microseconds;  
	    FOR call: CARDINAL IN [1..tries]
            DO thisStart: System.Pulses;
	       thisPulses:  LONG CARDINAL;
	       IF minWanted THEN thisStart _ System.GetClockPulses[];
	       Send[! RemoteSignal => IF resumeSignal THEN RESUME ELSE CONTINUE];
	       IF minWanted
	       THEN BEGIN
	            IF thisPulses < minPulses THEN minPulses _ thisPulses;
		    thisPulses _ System.GetClockPulses[] - thisStart;
		    END;
               IF callGapSecs > 0
               THEN Process.Pause[Process.SecondsToTicks[callGapSecs]];
            ENDLOOP;
            end _ System.GetClockPulses[];
	    IF spyWanted AND spyAvailable THEN SpyClient.StopSpy[];
            elapsed _ System.PulsesToMicroseconds[[end-start]];
	    minTime _ System.PulsesToMicroseconds[[minPulses]];
	    IF authenticate THEN MesaRPC.EndConversation[conversation];
            IF signalFinished THEN SIGNAL Finished[];
	  END;
       ENDLOOP;
     
  END;
  IF exported THEN [] _ RPCLupine.UnexportInterface[expHandle];
  END;

caller _ FORK Work[];

END.