Camel case timer trigger (#261)

* updates to make 2.0 worker 1.0 compatible

* split validation logic so it's both v1 and v2 compatible

* hard-coded solution to camelCase timer trigger while proper fix is out of scope for timeline

* added test

* adding unit test

* testing both v1 behavior and v2 behavior

* dont code without intellisense

* remove e2e test until have better test on functions host v2 and v3

* re-add node 8 unit tests

Author: mhoeger

azure-pipelines.yml

@@ -1,5 +1,6 @@
 variables: {
   WORKER_VERSION: '2.0.0',
+  NODE_8: '8.x',
   NODE_10: '10.x',
   NODE_12: '12.x'
 }
@@ -14,18 +15,27 @@ jobs:
 - job: UnitTests
   strategy:
     matrix:
+      UBUNTU_NODE8:
+        IMAGE_TYPE: 'ubuntu-latest'
+        NODE_VERSION: $(NODE_8)
       UBUNTU_NODE10:
         IMAGE_TYPE: 'ubuntu-latest'
         NODE_VERSION: $(NODE_10)
       UBUNTU_NODE12:
         IMAGE_TYPE: 'ubuntu-latest'
         NODE_VERSION: $(NODE_12)
+      WINDOWS_NODE8:
+        IMAGE_TYPE: 'vs2017-win2016'
+        NODE_VERSION: $(NODE_8)
       WINDOWS_NODE10:
         IMAGE_TYPE: 'vs2017-win2016'
         NODE_VERSION: $(NODE_10)
       WINDOWS_NODE12:
         IMAGE_TYPE: 'vs2017-win2016'
         NODE_VERSION: $(NODE_12)
+      MAC_NODE8:
+        IMAGE_TYPE: 'macos-10.13'
+        NODE_VERSION: $(NODE_8)
       MAC_NODE10:
         IMAGE_TYPE: 'macos-10.13'
         NODE_VERSION: $(NODE_10)

package.ps1

@@ -24,6 +24,13 @@ copy-item ./dist/src/nodejsWorker.js ./pkg/dist/src/
 copy-item ./worker.config.json pkg
 ./node_modules/.bin/webpack
 StopOnFailedExecution # fail if error
+# Node 8 support
+./node_modules/.bin/node-pre-gyp install -C pkg/grpc --target_arch=ia32 --target=8.4.0 --target_platform=win32
+./node_modules/.bin/node-pre-gyp install -C pkg/grpc --target_arch=ia32 --target=8.4.0 --target_platform=darwin
+./node_modules/.bin/node-pre-gyp install -C pkg/grpc --target_arch=ia32 --target=8.4.0 --target_platform=linux --target_libc=glibc
+./node_modules/.bin/node-pre-gyp install -C pkg/grpc --target_arch=x64 --target=8.4.0 --target_platform=win32
+./node_modules/.bin/node-pre-gyp install -C pkg/grpc --target_arch=x64 --target=8.4.0 --target_platform=darwin
+./node_modules/.bin/node-pre-gyp install -C pkg/grpc --target_arch=x64 --target=8.4.0 --target_platform=linux --target_libc=glibc
 # Node 10 support
 ./node_modules/.bin/node-pre-gyp install -C pkg/grpc --target_arch=ia32 --target=10.1.0 --target_platform=win32
 ./node_modules/.bin/node-pre-gyp install -C pkg/grpc --target_arch=ia32 --target=10.1.0 --target_platform=darwin

src/Context.ts

@@ -1,25 +1,30 @@
 import { FunctionInfo } from './FunctionInfo';
-import { fromRpcHttp, fromTypedData, getNormalizedBindingData, getBindingDefinitions, fromRpcTraceContext } from './converters';
+import { fromRpcHttp, fromTypedData, getNormalizedBindingData, getBindingDefinitions, fromRpcTraceContext, convertKeysToCamelCase } from './converters';
 import { AzureFunctionsRpcMessages as rpc } from '../azure-functions-language-worker-protobuf/src/rpc';
 import { Request, RequestProperties } from './http/Request';
 import { Response } from './http/Response';
 import LogLevel = rpc.RpcLog.Level;
 import LogCategory = rpc.RpcLog.RpcLogCategory;
 import { Context, ExecutionContext, Logger, BindingDefinition, HttpRequest, TraceContext } from './public/Interfaces' 
 
-export function CreateContextAndInputs(info: FunctionInfo, request: rpc.IInvocationRequest, logCallback: LogCallback, callback: ResultCallback) {
+export function CreateContextAndInputs(info: FunctionInfo, request: rpc.IInvocationRequest, logCallback: LogCallback, callback: ResultCallback, v1WorkerBehavior: boolean) {
     let context = new InvocationContext(info, request, logCallback, callback);
 
     let bindings: Dict<any> = {};
-    let inputs: InputTypes[] = [];
+    let inputs: any[] = [];
     let httpInput: RequestProperties | undefined;
     for (let binding of <rpc.IParameterBinding[]>request.inputData) {
         if (binding.data && binding.name) {
-            let input: InputTypes;
+            let input;
             if (binding.data && binding.data.http) {
                 input = httpInput = fromRpcHttp(binding.data.http);
             } else {
-                input = fromTypedData(binding.data);
+                // TODO: Don't hard code fix for camelCase https://github.com/Azure/azure-functions-nodejs-worker/issues/188
+                if (v1WorkerBehavior && info.getTimerTriggerName() === binding.name) {
+                    input = convertKeysToCamelCase(binding)["data"];
+                } else {
+                    input = fromTypedData(binding.data);
+                }
             }
             bindings[binding.name] = input;
             inputs.push(input);
@@ -127,6 +132,3 @@ export type ResultCallback = (err?: any, result?: InvocationResult) => void;
 export interface Dict<T> {
     [key: string]: T
 }
-
-// Allowed input types
-export type InputTypes = HttpRequest | string | Buffer | null | undefined;

src/FunctionInfo.ts

@@ -44,4 +44,14 @@ export class FunctionInfo {
   public getReturnBinding() {
     return this.outputBindings[returnBindingKey];
   }
+
+  public getTimerTriggerName(): string | undefined {
+    for (let name in this.bindings) {
+      let type = this.bindings[name].type;
+      if (type && type.toLowerCase() === "timertrigger") {
+        return name;
+      }
+    }
+    return;
+  }
 }

src/WorkerChannel.ts

@@ -5,7 +5,7 @@ import { CreateContextAndInputs, LogCallback, ResultCallback } from './Context';
 import { IEventStream } from './GrpcService';
 import { toTypedData } from './converters';
 import { augmentTriggerMetadata } from './augmenters';
-import { systemError } from './utils/Logger';
+import { systemError, systemWarn } from './utils/Logger';
 import { InternalException } from './utils/InternalException';
 import LogCategory = rpc.RpcLog.RpcLogCategory;
 import LogLevel = rpc.RpcLog.Level;
@@ -34,14 +34,14 @@ export class WorkerChannel implements IWorkerChannel {
   private _eventStream: IEventStream;
   private _functionLoader: IFunctionLoader;
   private _workerId: string;
-  private _v2Compatible: boolean;
+  private _v1WorkerBehavior: boolean;
 
   constructor(workerId: string, eventStream: IEventStream, functionLoader: IFunctionLoader) {
     this._workerId = workerId;
     this._eventStream = eventStream;
     this._functionLoader = functionLoader;
     // default value
-    this._v2Compatible = false;
+    this._v1WorkerBehavior = false;
 
     // call the method with the matching 'event' name on this class, passing the requestId and event message
     eventStream.on('data', (msg) => {
@@ -92,13 +92,31 @@ export class WorkerChannel implements IWorkerChannel {
    */
   public workerInitRequest(requestId: string, msg: rpc.WorkerInitRequest) {
     // TODO: add capability from host to go to "non-breaking" mode
-    if (msg.hostVersion) {
-      this._v2Compatible = true;
+    if (msg.capabilities && msg.capabilities.V2Compatable) {
+      this._v1WorkerBehavior = true;
     }
+
+    // Validate version
+    let version = process.version;
+    if (this._v1WorkerBehavior) {
+      if (version.startsWith("v12."))
+      {
+        systemWarn("The Node.js version you are using (" + version + ") is not fully supported with Azure Functions V2. We recommend using one the following major versions: 8, 10.");
+      }
+    } else {
+      if (version.startsWith("v8."))
+      {
+        let msg = "Incompatible Node.js version. The version you are using (" + version + ") is not supported with Azure Functions V3. Please use one of the following major versions: 10, 12.";
+        systemError(msg);
+        throw msg;
+      }
+    }
+
     const workerCapabilities = {
       RpcHttpTriggerMetadataRemoved: "true",
       RpcHttpBodyOnly: "true"
     };
+
     this._eventStream.write({
       requestId: requestId,
       workerInitResponse: {
@@ -146,7 +164,7 @@ export class WorkerChannel implements IWorkerChannel {
    */
   public invocationRequest(requestId: string, msg: rpc.InvocationRequest) {
     // Repopulate triggerMetaData if http.
-    if (this._v2Compatible) {
+    if (this._v1WorkerBehavior) {
       augmentTriggerMetadata(msg);
     }
 
@@ -170,8 +188,7 @@ export class WorkerChannel implements IWorkerChannel {
       try {
         if (result) {
           if (result.return) {
-            // TODO: add capability from host to go to "non-breaking" mode
-            if (this._v2Compatible) {
+            if (this._v1WorkerBehavior) {
               response.returnValue = toTypedData(result.return);
             } else {
               let returnBinding = info.getReturnBinding();
@@ -197,7 +214,7 @@ export class WorkerChannel implements IWorkerChannel {
       });
     }
 
-    let { context, inputs } = CreateContextAndInputs(info, msg, logCallback, resultCallback);
+    let { context, inputs } = CreateContextAndInputs(info, msg, logCallback, resultCallback, this._v1WorkerBehavior);
     let userFunction = this._functionLoader.getFunc(<string>msg.functionId);
 
     // catch user errors from the same async context in the event loop and correlate with invocation

src/converters/BindingConverters.ts

@@ -43,7 +43,7 @@ function isBindingDirection(input: string | undefined): boolean {
 }
 
 // Recursively convert keys of objects to camel case
-function convertKeysToCamelCase(obj: any) {
+export function convertKeysToCamelCase(obj: any) {
   var output = {};
   for (var key in obj) {
       let value = fromTypedData(obj[key]) || obj[key];

src/nodejsWorker.ts

@@ -1,7 +1,7 @@
 var logPrefix = "LanguageWorkerConsoleLog";
 var errorPrefix = logPrefix + "[error] ";
 var warnPrefix = logPrefix + "[warn] ";
-var supportedVersions:string[] = ["v10", "v12"];
+var supportedVersions:string[] = ["v8", "v10", "v12"];
 var worker;
 
 // Try validating node version
@@ -17,12 +17,12 @@ function validateNodeVersion(version) {
             message = "Could not parse Node.js version: '" + version + "'";
         // Unsupported version note: Documentation about Node's stable versions here: https://github.com/nodejs/Release#release-plan and an explanation here: https://medium.com/swlh/understanding-how-node-releases-work-in-2018-6fd356816db4
         } else if (supportedVersions.indexOf(major) < 0) {
-            message = "Incompatible Node.js version. The version you are using is "
-                + version +
-                ", but the runtime requires an LTS-covered major version. LTS-covered versions have an even major version number (10.x, 12.x, etc.) as per https://github.com/nodejs/Release#release-plan. "
-                + "For deployed code, change WEBSITE_NODE_DEFAULT_VERSION to '~12' in App Settings. Locally, install or switch to a supported node version (make sure to quit and restart your code editor to pick up the changes).";
+            message = "Incompatible Node.js version. The version you are using (" 
+                + version 
+                + ") is not supported with Azure Functions. Please use one of the following major versions: 10, 12."
+                + "For deployed code on Windows, change WEBSITE_NODE_DEFAULT_VERSION to '~12' in App Settings."
+                + "Locally, install or switch to a supported node version (make sure to quit and restart your code editor to pick up the changes).";
         }
-        
     // Unknown error
     } catch(err) {
         var unknownError = "Error in validating Node.js version. ";

test/ContextTests.ts

@@ -3,6 +3,7 @@ import { Context } from "../src/public/Interfaces";
 import { FunctionInfo } from '../src/FunctionInfo';
 import { AzureFunctionsRpcMessages as rpc } from '../azure-functions-language-worker-protobuf/src/rpc';
 import * as sinon from 'sinon';
+import { expect } from 'chai';
 import 'mocha';
 import { isFunction } from 'util';
 
@@ -21,10 +22,60 @@ describe('Context', () => {
         _logger = sinon.spy();
         _resultCallback = sinon.spy();
 
-        let { context, inputs } = CreateContextAndInputs(info, msg, _logger, _resultCallback);
+        let { context, inputs } = CreateContextAndInputs(info, msg, _logger, _resultCallback, true);
         _context = context;
     });
 
+    it ('camelCases timer trigger input when appropriate', async () => {
+        var inputDataValue: rpc.IParameterBinding = {
+            name: "myTimer",
+            data: {
+                json: JSON.stringify({
+                    "Schedule":{
+                    },
+                    "ScheduleStatus": {
+                        "Last":"2016-10-04T10:15:00+00:00",
+                        "LastUpdated":"2016-10-04T10:16:00+00:00",
+                        "Next":"2016-10-04T10:20:00+00:00"
+                    },
+                    "IsPastDue":false
+                })
+            }
+        };
+        var msg: rpc.IInvocationRequest = <rpc.IInvocationRequest> {
+            functionId: 'id',
+            invocationId: '1',
+            inputData: [inputDataValue]
+        };
+
+        let info: FunctionInfo = new FunctionInfo({ 
+            name: 'test',
+            bindings: {
+                myTimer: {
+                    type: "timerTrigger",
+                    direction: 0,
+                    dataType: 0                    
+                }
+            }
+        });
+        // Node.js Worker V2 behavior
+        let workerV2Outputs = CreateContextAndInputs(info, msg, _logger, _resultCallback, true);
+        let myTimerWorkerV2 = workerV2Outputs.inputs[0];
+        expect(myTimerWorkerV2.schedule).to.be.empty;
+        expect(myTimerWorkerV2.scheduleStatus.last).to.equal("2016-10-04T10:15:00+00:00");
+        expect(myTimerWorkerV2.scheduleStatus.lastUpdated).to.equal("2016-10-04T10:16:00+00:00");
+        expect(myTimerWorkerV2.scheduleStatus.next).to.equal("2016-10-04T10:20:00+00:00");
+        expect(myTimerWorkerV2.isPastDue).to.equal(false);
+
+        let workerV1Outputs = CreateContextAndInputs(info, msg, _logger, _resultCallback, false);
+        let myTimerWorkerV1 = workerV1Outputs.inputs[0];
+        expect(myTimerWorkerV1.Schedule).to.be.empty;
+        expect(myTimerWorkerV1.ScheduleStatus.Last).to.equal("2016-10-04T10:15:00+00:00");
+        expect(myTimerWorkerV1.ScheduleStatus.LastUpdated).to.equal("2016-10-04T10:16:00+00:00");
+        expect(myTimerWorkerV1.ScheduleStatus.Next).to.equal("2016-10-04T10:20:00+00:00");
+        expect(myTimerWorkerV1.IsPastDue).to.equal(false);
+    });
+
     it ('async function logs error on calling context.done', async () => {
         await callUserFunc(BasicAsync.asyncAndCallback, _context);
         sinon.assert.calledOnce(_logger);

test/FunctionInfoTests.ts

@@ -24,7 +24,6 @@ describe('FunctionInfo', () => {
     };
 
     let funcInfo = new FunctionInfo(metadata);
-    console.log(funcInfo);
     expect(funcInfo.getReturnBinding().converter.name).to.equal("toRpcHttp");
   });
 
@@ -45,7 +44,6 @@ describe('FunctionInfo', () => {
     };
 
     let funcInfo = new FunctionInfo(metadata);
-    console.log(funcInfo);
     expect(funcInfo.getReturnBinding().converter.name).to.equal("toTypedData");
   });
 })

test/WorkerChannelTests.ts

@@ -20,10 +20,18 @@ describe('WorkerChannel', () => {
   });
 
   it('responds to init', () => {
-    stream.addTestMessage({
+    let initMessage = {
       requestId: 'id',
-      workerInitRequest: {  }
-    });
+      workerInitRequest: {
+        capabilities: {}
+      }
+    };
+
+    if (process.version.startsWith("v8")) {
+      initMessage.workerInitRequest.capabilities["V2Compatable"] = "true";
+    }
+    
+    stream.addTestMessage(initMessage);
     sinon.assert.calledWith(stream.written, <rpc.IStreamingMessage>{
       requestId: 'id',
       workerInitResponse: {
@@ -258,7 +266,10 @@ describe('WorkerChannel', () => {
 
     stream.addTestMessage({
       workerInitRequest: {
-        hostVersion: "2.0"
+        hostVersion: "3.0.0000",
+        capabilities: {
+          V2Compatable: "true"
+        }
       }
     })