Add programming model info to worker metadata (#662)

And include worker metadata in reload response
Azure · Mar 3, 2023 · f6d3625 · f6d3625
1 parent 26f79ca
commit f6d3625
Show file tree

Hide file tree

Showing 10 changed files with 73 additions and 26 deletions.
diff --git a/src/eventHandlers/EventHandler.ts b/src/eventHandlers/EventHandler.ts
@@ -31,7 +31,7 @@ export abstract class EventHandler<
     /**
      * The default response with any properties unique to this request that should be set for both success & failure scenarios
      */
-    abstract getDefaultResponse(request: TRequest): TResponse;
+    abstract getDefaultResponse(channel: WorkerChannel, request: TRequest): TResponse;
 
     /**
      * Handles the event and returns the response

diff --git a/src/eventHandlers/FunctionEnvironmentReloadHandler.ts b/src/eventHandlers/FunctionEnvironmentReloadHandler.ts
@@ -5,6 +5,7 @@ import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language
 import { startApp } from '../startApp';
 import { WorkerChannel } from '../WorkerChannel';
 import { EventHandler } from './EventHandler';
+import { getWorkerMetadata } from './getWorkerMetadata';
 import LogCategory = rpc.RpcLog.RpcLogCategory;
 import LogLevel = rpc.RpcLog.Level;
 
@@ -17,15 +18,20 @@ export class FunctionEnvironmentReloadHandler extends EventHandler<
 > {
     readonly responseName = 'functionEnvironmentReloadResponse';
 
-    getDefaultResponse(_msg: rpc.IFunctionEnvironmentReloadRequest): rpc.IFunctionEnvironmentReloadResponse {
-        return {};
+    getDefaultResponse(
+        channel: WorkerChannel,
+        _msg: rpc.IFunctionEnvironmentReloadRequest
+    ): rpc.IFunctionEnvironmentReloadResponse {
+        return {
+            workerMetadata: getWorkerMetadata(channel),
+        };
     }
 
     async handleEvent(
         channel: WorkerChannel,
         msg: rpc.IFunctionEnvironmentReloadRequest
     ): Promise<rpc.IFunctionEnvironmentReloadResponse> {
-        const response = this.getDefaultResponse(msg);
+        const response = this.getDefaultResponse(channel, msg);
 
         // Add environment variables from incoming
         const numVariables = (msg.environmentVariables && Object.keys(msg.environmentVariables).length) || 0;
@@ -49,6 +55,8 @@ export class FunctionEnvironmentReloadHandler extends EventHandler<
             });
             process.chdir(msg.functionAppDirectory);
             await startApp(msg.functionAppDirectory, channel);
+            // model info may have changed, so we need to update this
+            response.workerMetadata = getWorkerMetadata(channel);
         }
 
         return response;

diff --git a/src/eventHandlers/FunctionLoadHandler.ts b/src/eventHandlers/FunctionLoadHandler.ts
@@ -15,14 +15,14 @@ import LogLevel = rpc.RpcLog.Level;
 export class FunctionLoadHandler extends EventHandler<'functionLoadRequest', 'functionLoadResponse'> {
     readonly responseName = 'functionLoadResponse';
 
-    getDefaultResponse(msg: rpc.IFunctionLoadRequest): rpc.IFunctionLoadResponse {
+    getDefaultResponse(_channel: WorkerChannel, msg: rpc.IFunctionLoadRequest): rpc.IFunctionLoadResponse {
         return { functionId: msg.functionId };
     }
 
     async handleEvent(channel: WorkerChannel, msg: rpc.IFunctionLoadRequest): Promise<rpc.IFunctionLoadResponse> {
         channel.workerIndexingLocked = true;
 
-        const response = this.getDefaultResponse(msg);
+        const response = this.getDefaultResponse(channel, msg);
 
         channel.log({
             message: `Worker ${channel.workerId} received FunctionLoadRequest`,

diff --git a/src/eventHandlers/FunctionsMetadataHandler.ts b/src/eventHandlers/FunctionsMetadataHandler.ts
@@ -10,7 +10,7 @@ import LogLevel = rpc.RpcLog.Level;
 export class FunctionsMetadataHandler extends EventHandler<'functionsMetadataRequest', 'functionMetadataResponse'> {
     readonly responseName = 'functionMetadataResponse';
 
-    getDefaultResponse(_msg: rpc.IFunctionsMetadataRequest): rpc.IFunctionMetadataResponse {
+    getDefaultResponse(_channel: WorkerChannel, _msg: rpc.IFunctionsMetadataRequest): rpc.IFunctionMetadataResponse {
         return {
             useDefaultMetadataIndexing: true,
         };
@@ -22,7 +22,7 @@ export class FunctionsMetadataHandler extends EventHandler<'functionsMetadataReq
     ): Promise<rpc.IFunctionMetadataResponse> {
         channel.workerIndexingLocked = true;
 
-        const response = this.getDefaultResponse(msg);
+        const response = this.getDefaultResponse(channel, msg);
 
         channel.log({
             message: `Worker ${channel.workerId} received FunctionsMetadataRequest`,

diff --git a/src/eventHandlers/InvocationHandler.ts b/src/eventHandlers/InvocationHandler.ts
@@ -29,7 +29,7 @@ import { EventHandler } from './EventHandler';
 export class InvocationHandler extends EventHandler<'invocationRequest', 'invocationResponse'> {
     readonly responseName = 'invocationResponse';
 
-    getDefaultResponse(msg: rpc.IInvocationRequest): rpc.IInvocationResponse {
+    getDefaultResponse(_channel: WorkerChannel, msg: rpc.IInvocationRequest): rpc.IInvocationResponse {
         return { invocationId: msg.invocationId };
     }
 

diff --git a/src/eventHandlers/WorkerInitHandler.ts b/src/eventHandlers/WorkerInitHandler.ts
@@ -4,12 +4,12 @@
 import { access, constants } from 'fs';
 import * as path from 'path';
 import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
-import { version as workerVersion } from '../constants';
 import { isError } from '../errors';
 import { startApp } from '../startApp';
 import { nonNullProp } from '../utils/nonNull';
 import { WorkerChannel } from '../WorkerChannel';
 import { EventHandler } from './EventHandler';
+import { getWorkerMetadata } from './getWorkerMetadata';
 import LogCategory = rpc.RpcLog.RpcLogCategory;
 import LogLevel = rpc.RpcLog.Level;
 
@@ -19,19 +19,14 @@ import LogLevel = rpc.RpcLog.Level;
 export class WorkerInitHandler extends EventHandler<'workerInitRequest', 'workerInitResponse'> {
     readonly responseName = 'workerInitResponse';
 
-    getDefaultResponse(_msg: rpc.IWorkerInitRequest): rpc.IWorkerInitResponse {
+    getDefaultResponse(channel: WorkerChannel, _msg: rpc.IWorkerInitRequest): rpc.IWorkerInitResponse {
         return {
-            workerMetadata: {
-                runtimeName: 'node',
-                runtimeVersion: process.versions.node,
-                workerBitness: process.arch,
-                workerVersion,
-            },
+            workerMetadata: getWorkerMetadata(channel),
         };
     }
 
     async handleEvent(channel: WorkerChannel, msg: rpc.IWorkerInitRequest): Promise<rpc.IWorkerInitResponse> {
-        const response = this.getDefaultResponse(msg);
+        const response = this.getDefaultResponse(channel, msg);
 
         channel.log({
             message: `Worker ${channel.workerId} received WorkerInitRequest`,
@@ -45,6 +40,8 @@ export class WorkerInitHandler extends EventHandler<'workerInitRequest', 'worker
 
         if (msg.functionAppDirectory) {
             await startApp(msg.functionAppDirectory, channel);
+            // model info may have changed, so we need to update this
+            response.workerMetadata = getWorkerMetadata(channel);
         }
 
         response.capabilities = {

diff --git a/src/eventHandlers/getWorkerMetadata.ts b/src/eventHandlers/getWorkerMetadata.ts
@@ -0,0 +1,22 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License.
+
+import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
+import { version as workerVersion } from '../constants';
+import { WorkerChannel } from '../WorkerChannel';
+
+export function getWorkerMetadata(channel: WorkerChannel): rpc.IWorkerMetadata {
+    const result: rpc.IWorkerMetadata = {
+        runtimeName: 'node',
+        runtimeVersion: process.versions.node,
+        workerBitness: process.arch,
+        workerVersion,
+    };
+    if (channel.programmingModel) {
+        result.customProperties = {
+            modelName: channel.programmingModel.name,
+            modelVersion: channel.programmingModel.version,
+        };
+    }
+    return result;
+}
diff --git a/src/setupEventStream.ts b/src/setupEventStream.ts
@@ -107,7 +107,7 @@ async function handleMessage(channel: WorkerChannel, inMsg: rpc.StreamingMessage
         }
 
         if (eventHandler && request) {
-            const response = eventHandler.getDefaultResponse(request);
+            const response = eventHandler.getDefaultResponse(channel, request);
             response.result = {
                 status: rpc.StatusResult.Status.Failure,
                 exception: {

diff --git a/test/eventHandlers/FunctionEnvironmentReloadHandler.test.ts b/test/eventHandlers/FunctionEnvironmentReloadHandler.test.ts
@@ -7,7 +7,7 @@ import * as mock from 'mock-fs';
 import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
 import { WorkerChannel } from '../../src/WorkerChannel';
 import { beforeEventHandlerSuite } from './beforeEventHandlerSuite';
-import { TestEventStream } from './TestEventStream';
+import { RegExpStreamingMessage, TestEventStream } from './TestEventStream';
 import { Msg as WorkerInitMsg } from './WorkerInitHandler.test';
 import path = require('path');
 import LogCategory = rpc.RpcLog.RpcLogCategory;
@@ -24,14 +24,30 @@ export namespace Msg {
         };
     }
 
-    export const reloadSuccess: rpc.IStreamingMessage = {
-        requestId: 'id',
-        functionEnvironmentReloadResponse: {
-            result: {
-                status: rpc.StatusResult.Status.Success,
+    const workerMetadataRegExps = {
+        'functionEnvironmentReloadResponse.workerMetadata.runtimeVersion': /^[0-9]+\.[0-9]+\.[0-9]+$/,
+        'functionEnvironmentReloadResponse.workerMetadata.workerBitness': /^(x64|ia32|arm64)$/,
+        'functionEnvironmentReloadResponse.workerMetadata.workerVersion': /^3\.[0-9]+\.[0-9]+$/,
+        'functionEnvironmentReloadResponse.workerMetadata.customProperties.modelVersion': /^3\.[0-9]+\.[0-9]+$/,
+    };
+
+    export const reloadSuccess = new RegExpStreamingMessage(
+        {
+            requestId: 'id',
+            functionEnvironmentReloadResponse: {
+                result: {
+                    status: rpc.StatusResult.Status.Success,
+                },
+                workerMetadata: {
+                    runtimeName: 'node',
+                    customProperties: {
+                        modelName: '@azure/functions',
+                    },
+                },
             },
         },
-    };
+        workerMetadataRegExps
+    );
 
     export const noHandlerRpcLog: rpc.IStreamingMessage = {
         rpcLog: {

diff --git a/test/eventHandlers/WorkerInitHandler.test.ts b/test/eventHandlers/WorkerInitHandler.test.ts
@@ -32,6 +32,7 @@ export namespace Msg {
         'workerInitResponse.workerMetadata.runtimeVersion': /^[0-9]+\.[0-9]+\.[0-9]+$/,
         'workerInitResponse.workerMetadata.workerBitness': /^(x64|ia32|arm64)$/,
         'workerInitResponse.workerMetadata.workerVersion': /^3\.[0-9]+\.[0-9]+$/,
+        'workerInitResponse.workerMetadata.customProperties.modelVersion': /^3\.[0-9]+\.[0-9]+$/,
     };
 
     export const response = new RegExpStreamingMessage(
@@ -53,6 +54,9 @@ export namespace Msg {
                 },
                 workerMetadata: {
                     runtimeName: 'node',
+                    customProperties: {
+                        modelName: '@azure/functions',
+                    },
                 },
             },
         },