CompileRequest from frontend works

Author: adwinwhite

ui/frontend/actions.ts

@@ -135,8 +135,14 @@ export enum ActionType {
   WebSocketConnected = 'WEBSOCKET_CONNECTED',
   WebSocketDisconnected = 'WEBSOCKET_DISCONNECTED',
   WebSocketFeatureFlagEnabled = 'WEBSOCKET_FEATURE_FLAG_ENABLED',
+  WSRequest = 'WS_REQUEST',
+  WSResponse = 'WS_RESPONSE',
+  WSStdoutPacket = 'WS_STDOUT_PACKET',
+  WSStderrPacket = 'WS_STDERR_PACKET',
   WSExecuteRequest = 'WS_EXECUTE_REQUEST',
   WSExecuteResponse = 'WS_EXECUTE_RESPONSE',
+  WSCompileRequest = 'WS_COMPILE_REQUEST',
+  WSCompileResponse = 'WS_COMPILE_RESPONSE',
 }
 
 export const WebSocketError = z.object({
@@ -159,6 +165,16 @@ export const WSExecuteResponse = z.object({
 });
 export type WSExecuteResponse = z.infer<typeof WSExecuteResponse>;
 
+export const WSCompileResponse = z.object({
+  type: z.literal(ActionType.WSCompileResponse),
+  success: z.boolean(),
+  code: z.string(),
+  stdout: z.string(),
+  stderr: z.string(),
+  extra: ExecuteExtra,
+});
+export type WSCompileResponse = z.infer<typeof WSCompileResponse>;
+
 export const initializeApplication = () => createAction(ActionType.InitializeApplication);
 
 export const disableSyncChangesToStorage = () => createAction(ActionType.DisableSyncChangesToStorage);
@@ -363,8 +379,6 @@ function performCompileShow(
   }): ThunkAction {
   // TODO: Check a cache
   return function(dispatch, getState) {
-    dispatch(request());
-
     const state = getState();
     const code = codeSelector(state);
     const { configuration: {
@@ -378,23 +392,29 @@ function performCompileShow(
     const crateType = getCrateType(state);
     const tests = runAsTest(state);
     const backtrace = state.configuration.backtrace === Backtrace.Enabled;
-    const body: CompileRequestBody = {
-      channel,
-      mode,
-      edition,
-      crateType,
-      tests,
-      code,
-      target,
-      assemblyFlavor,
-      demangleAssembly,
-      processAssembly,
-      backtrace,
-    };
 
-    return jsonPost<CompileResponseBody>(routes.compile, body)
-      .then(json => dispatch(success(json)))
-      .catch(json => dispatch(failure(json)));
+    if (useWebsocketSelector(state)) {
+      return dispatch(wsCompileRequest(channel, mode, edition, crateType, tests, code, target, assemblyFlavor, demangleAssembly, processAssembly, backtrace));
+    } else {
+      dispatch(request());
+      const body: CompileRequestBody = {
+        channel,
+        mode,
+        edition,
+        crateType,
+        tests,
+        code,
+        target,
+        assemblyFlavor,
+        demangleAssembly,
+        processAssembly,
+        backtrace,
+      };
+
+      return jsonPost<CompileResponseBody>(routes.compile, body)
+        .then(json => dispatch(success(json)))
+        .catch(json => dispatch(failure(json)));
+    }
   };
 }
 
@@ -526,6 +546,34 @@ const wsExecuteRequest = (
     extra: makeExtra(),
   });
 
+const wsCompileRequest = (
+  channel: Channel,
+  mode: Mode,
+  edition: Edition,
+  crateType: string,
+  tests: boolean,
+  code: string,
+  target: string,
+  assemblyFlavor: AssemblyFlavor,
+  demangleAssembly: DemangleAssembly,
+  processAssembly: ProcessAssembly,
+  backtrace: boolean
+) =>
+  createAction(ActionType.WSCompileRequest, {
+    channel,
+    mode,
+    edition,
+    crateType,
+    tests,
+    code,
+    target,
+    assemblyFlavor,
+    demangleAssembly,
+    processAssembly,
+    backtrace,
+    extra: makeExtra(),
+  });
+
 export const performPrimaryAction = (): ThunkAction => (dispatch, getState) => {
   const state = getState();
   const primaryAction = PRIMARY_ACTIONS[state.configuration.primaryAction];
@@ -1036,5 +1084,7 @@ export type Action =
   | ReturnType<typeof websocketDisconnected>
   | ReturnType<typeof websocketFeatureFlagEnabled>
   | ReturnType<typeof wsExecuteRequest>
+  | ReturnType<typeof wsCompileRequest>
   | WSExecuteResponse
+  | WSCompileResponse
   ;

ui/frontend/reducers/output/mir.ts

@@ -6,6 +6,7 @@ const DEFAULT: State = {
 };
 
 interface State {
+  sequenceNumber?: number;
   requestsInProgress: number;
   code?: string;
   stdout?: string;
@@ -23,6 +24,26 @@ export default function mir(state = DEFAULT, action: Action) {
     }
     case ActionType.CompileMirFailed:
       return finish(state, { error: action.error });
+    case ActionType.WSCompileRequest: {
+      const { extra: { sequenceNumber } } = action;
+      if (sequenceNumber >= (state.sequenceNumber ?? 0)) {
+        const requestsInProgress = 1; // Only tracking one request
+        return {...state, sequenceNumber, requestsInProgress };
+      } else {
+        return state;
+      }
+    }
+    case ActionType.WSCompileResponse: {
+      const { code, stdout, stderr, extra: { sequenceNumber } } = action;
+
+      if (sequenceNumber >= (state.sequenceNumber ?? 0)) {
+        const requestsInProgress = 0; // Only tracking one request
+        return { ...state, code, stdout, stderr, requestsInProgress };
+      } else {
+        return state;
+      }
+    }
+
     default:
       return state;
   }

ui/frontend/websocketMiddleware.ts

@@ -4,13 +4,26 @@ import { z } from 'zod';
 import {
   ActionType,
   WSExecuteResponse,
+  WSCompileResponse,
   WebSocketError,
   websocketConnected,
   websocketDisconnected,
   websocketError,
 } from './actions';
 
-const WSMessageResponse = z.discriminatedUnion('type', [WebSocketError, WSExecuteResponse]);
+const WSResponse = z.object({ 
+  type: z.literal(ActionType.WSResponse),
+  response: z.discriminatedUnion('type', [WSExecuteResponse, WSCompileResponse]) 
+});
+const WSStdoutPacket = z.object({ 
+  type: z.literal(ActionType.WSStdoutPacket),
+  stdout_packet: z.string() 
+});
+const WSStderrPacket = z.object({ 
+  type: z.literal(ActionType.WSStderrPacket),
+  stderr_packet: z.string() 
+});
+const WSServerMessage = z.discriminatedUnion('type', [WSResponse, WSStdoutPacket, WSStderrPacket]);
 
 const reportWebSocketError = async (error: string) => {
   try {
@@ -75,6 +88,14 @@ export const websocketMiddleware =
 
         socket.addEventListener('open', () => {
           store.dispatch(websocketConnected());
+          // const params = new URLSearchParams(window.location.search);
+          if (socket != null) {
+            // if (params.has("pool")) {
+              socket.send("use container pool");
+            // } else {
+              // socket.send("use no pool");
+            // }
+          }
 
           wasConnected = true;
         });
@@ -101,8 +122,10 @@ export const websocketMiddleware =
         socket.addEventListener('message', (event) => {
           try {
             const rawMessage = JSON.parse(event.data);
-            const message = WSMessageResponse.parse(rawMessage);
-            store.dispatch(message);
+            const message = WSServerMessage.parse(rawMessage);
+            if (message.type == ActionType.WSResponse) {
+              store.dispatch(message.response);
+            }
             resetTimeout();
           } catch (e) {
             console.log('Unable to parse WebSocket message', event.data, e);
@@ -127,7 +150,11 @@ export const websocketMiddleware =
 
     return (next) => (action) => {
       if (socket && socket.readyState == socket.OPEN && sendActionOnWebsocket(action)) {
-        const message = JSON.stringify(action);
+        console.log(action);
+        const request = {
+          Request: action
+        };
+        const message = JSON.stringify(request);
         socket.send(message);
         resetTimeout();
       }
@@ -136,4 +163,4 @@ export const websocketMiddleware =
     };
   };
 
-const sendActionOnWebsocket = (action: any): boolean => action.type === ActionType.WSExecuteRequest;
+const sendActionOnWebsocket = (action: any): boolean => action.type === ActionType.WSExecuteRequest || action.type === ActionType.WSCompileRequest;