Allowing relative script file references

Author: fabiocav

WebJobs.Script.sln

@@ -425,6 +425,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "json", "json", "{3A4AF861-6
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebJobs.Extensibility.Tests", "test\WebJobs.Extensibility.Tests\WebJobs.Extensibility.Tests.csproj", "{9A8111D1-A7A1-4D60-98D1-705D1C849588}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "HttpTriggerShared", "HttpTriggerShared", "{EB76E1C8-C823-4707-BD83-20304425EFC4}"
+	ProjectSection(SolutionItems) = preProject
+		sample\HttpTriggerShared\function.json = sample\HttpTriggerShared\function.json
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SharedMSBuildProjectFiles) = preSolution
 		test\WebJobs.Script.Tests.Shared\WebJobs.Script.Tests.Shared.projitems*{35a2025d-f68a-4b57-83a2-ed4eb9c3894d}*SharedItemsImports = 4
@@ -546,5 +551,6 @@ Global
 		{35C9CCB7-D8B6-4161-BB0D-BCFA7C6DCFFB} = {FD93A1ED-5AC4-4F9B-9087-E1C24320F36E}
 		{3A4AF861-66F2-4C34-BB9E-69F0D392BB1A} = {67174433-2838-460C-9880-419476D02994}
 		{9A8111D1-A7A1-4D60-98D1-705D1C849588} = {FD93A1ED-5AC4-4F9B-9087-E1C24320F36E}
+		{EB76E1C8-C823-4707-BD83-20304425EFC4} = {FF9C0818-30D3-437A-A62D-7A61CA44F459}
 	EndGlobalSection
 EndGlobal

sample/HttpTriggerShared/function.json

@@ -0,0 +1,16 @@
+{
+    "scriptFile": "..\\HttpTrigger\\index.js",
+    "bindings": [
+        {
+            "type": "httpTrigger",
+            "name": "req",
+            "direction": "in",
+            "methods": [ "get" ]
+        },
+        {
+            "type": "http",
+            "name": "$return",
+            "direction": "out"
+        }
+    ]
+}

src/WebJobs.Script/Host/ScriptHost.cs

@@ -30,6 +30,8 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using System.Collections.Immutable;
+using System.Configuration;
+using System.IO.Abstractions;
 
 namespace Microsoft.Azure.WebJobs.Script
 {
@@ -42,7 +44,7 @@ public class ScriptHost : JobHost
         private Action<FileSystemEventArgs> _restart;
         private AutoRecoveringFileSystemWatcher _scriptFileWatcher;
         private AutoRecoveringFileSystemWatcher _debugModeFileWatcher;
-        private ImmutableArray<string> _directorySnapshot; 
+        private ImmutableArray<string> _directorySnapshot;
         private BlobLeaseManager _blobLeaseManager;
         private static readonly TimeSpan MinTimeout = TimeSpan.FromSeconds(1);
         private static readonly TimeSpan MaxTimeout = TimeSpan.FromMinutes(5);
@@ -270,7 +272,7 @@ protected virtual void Initialize()
 
                 _debugModeFileWatcher = new AutoRecoveringFileSystemWatcher(hostLogPath, ScriptConstants.DebugSentinelFileName,
                     includeSubdirectories: false, changeTypes: WatcherChangeTypes.Created | WatcherChangeTypes.Changed);
-                
+
                 _debugModeFileWatcher.Changed += OnDebugModeFileChanged;
 
                 var storageString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage);
@@ -624,11 +626,10 @@ public static Collection<FunctionMetadata> ReadFunctionMetadata(ScriptHostConfig
                     string json = File.ReadAllText(functionConfigPath);
                     JObject functionConfig = JObject.Parse(json);
 
-                    Lazy<string[]> functionFiles = new Lazy<string[]>(() => Directory.EnumerateFiles(scriptDir).Where(p => Path.GetFileName(p).ToLowerInvariant() != ScriptConstants.FunctionMetadataFileName).ToArray());
                     string functionError = null;
                     FunctionMetadata functionMetadata = null;
                     var mappedHttpFunctions = new Dictionary<string, HttpTriggerBindingMetadata>();
-                    if (!TryParseFunctionMetadata(functionName, functionConfig, mappedHttpFunctions, traceWriter, functionFiles, out functionMetadata, out functionError))
+                    if (!TryParseFunctionMetadata(functionName, functionConfig, mappedHttpFunctions, traceWriter, scriptDir, out functionMetadata, out functionError))
                     {
                         // for functions in error, log the error and don't
                         // add to the functions collection
@@ -650,8 +651,11 @@ public static Collection<FunctionMetadata> ReadFunctionMetadata(ScriptHostConfig
             return functions;
         }
 
-        internal static bool TryParseFunctionMetadata(string functionName, JObject functionConfig, Dictionary<string, HttpTriggerBindingMetadata> mappedHttpFunctions, TraceWriter traceWriter, Lazy<string[]> functionFilesProvider, out FunctionMetadata functionMetadata, out string error)
+        internal static bool TryParseFunctionMetadata(string functionName, JObject functionConfig, Dictionary<string, HttpTriggerBindingMetadata> mappedHttpFunctions,
+            TraceWriter traceWriter, string scriptDirectory, out FunctionMetadata functionMetadata, out string error, IFileSystem fileSystem = null)
         {
+            fileSystem = fileSystem ?? new FileSystem();
+
             error = null;
             functionMetadata = ParseFunctionMetadata(functionName, functionConfig);
 
@@ -667,22 +671,15 @@ internal static bool TryParseFunctionMetadata(string functionName, JObject funct
                 traceWriter.Info(string.Format("Function '{0}' is disabled", functionName));
             }
 
-            // determine the primary script
-            string[] functionFiles = functionFilesProvider.Value;
-            if (functionFiles.Length == 0)
+            try
             {
-                error = "No function script files present.";
-                return false;
+                functionMetadata.ScriptFile = DeterminePrimaryScriptFile(functionConfig, scriptDirectory, fileSystem);
             }
-            string scriptFile = DeterminePrimaryScriptFile(functionConfig, functionFiles);
-            if (string.IsNullOrEmpty(scriptFile))
+            catch (ConfigurationErrorsException exc)
             {
-                error =
-                    "Unable to determine the primary function script. Try renaming your entry point script to 'run' (or 'index' in the case of Node), " +
-                    "or alternatively you can specify the name of the entry point script explicitly by adding a 'scriptFile' property to your function metadata.";
+                error = exc.Message;
                 return false;
             }
-            functionMetadata.ScriptFile = scriptFile;
 
             // determine the script type based on the primary script file extension
             functionMetadata.ScriptType = ParseScriptType(functionMetadata.ScriptFile);
@@ -754,35 +751,59 @@ internal static void ValidateFunctionName(string functionName)
         /// <summary>
         /// Determines which script should be considered the "primary" entry point script.
         /// </summary>
-        internal static string DeterminePrimaryScriptFile(JObject functionConfig, string[] functionFiles)
+        /// <exception cref="ConfigurationErrorsException">Thrown if the function metadata points to an invalid script file, or no script files are present.</exception>
+        internal static string DeterminePrimaryScriptFile(JObject functionConfig, string scriptDirectory, IFileSystem fileSystem = null)
         {
-            if (functionFiles.Length == 1)
+            fileSystem = fileSystem ?? new FileSystem();
+
+            // First see if there is an explicit primary file indicated
+            // in config. If so use that.
+            string functionPrimary = null;
+            string scriptFile = (string)functionConfig["scriptFile"];
+
+            if (!string.IsNullOrEmpty(scriptFile))
             {
-                // if there is only a single file, that file is primary
-                return functionFiles[0];
+                string scriptPath = fileSystem.Path.Combine(scriptDirectory, scriptFile);
+                if (!fileSystem.File.Exists(scriptPath))
+                {
+                    throw new ConfigurationErrorsException("Invalid script file name configuration. The 'scriptFile' property is set to a file that does not exist.");
+                }
+
+                functionPrimary = scriptPath;
             }
             else
             {
-                // First see if there is an explicit primary file indicated
-                // in config. If so use that.
-                string functionPrimary = null;
-                string scriptFileName = (string)functionConfig["scriptFile"];
-                if (!string.IsNullOrEmpty(scriptFileName))
+                string[] functionFiles = fileSystem.Directory.EnumerateFiles(scriptDirectory)
+                    .Where(p => fileSystem.Path.GetFileName(p).ToLowerInvariant() != ScriptConstants.FunctionMetadataFileName)
+                    .ToArray();
+
+                if (functionFiles.Length == 0)
                 {
-                    functionPrimary = functionFiles.FirstOrDefault(p =>
-                        string.Compare(Path.GetFileName(p), scriptFileName, StringComparison.OrdinalIgnoreCase) == 0);
+                    throw new ConfigurationErrorsException("No function script files present.");
+                }
+
+                if (functionFiles.Length == 1)
+                {
+                    // if there is only a single file, that file is primary
+                    functionPrimary = functionFiles[0];
                 }
                 else
                 {
                     // if there is a "run" file, that file is primary,
                     // for Node, any index.js file is primary
                     functionPrimary = functionFiles.FirstOrDefault(p =>
-                        Path.GetFileNameWithoutExtension(p).ToLowerInvariant() == "run" ||
-                        Path.GetFileName(p).ToLowerInvariant() == "index.js");
+                        fileSystem.Path.GetFileNameWithoutExtension(p).ToLowerInvariant() == "run" ||
+                        fileSystem.Path.GetFileName(p).ToLowerInvariant() == "index.js");
                 }
+            }
 
-                return functionPrimary;
+            if (string.IsNullOrEmpty(functionPrimary))
+            {
+                throw new ConfigurationErrorsException("Unable to determine the primary function script. Try renaming your entry point script to 'run' (or 'index' in the case of Node), " +
+                    "or alternatively you can specify the name of the entry point script explicitly by adding a 'scriptFile' property to your function metadata.");
             }
+
+            return Path.GetFullPath(functionPrimary);
         }
 
         private static ScriptType ParseScriptType(string scriptFilePath)

src/WebJobs.Script/WebJobs.Script.csproj

@@ -289,6 +289,10 @@
       <HintPath>..\..\packages\System.Diagnostics.StackTrace.4.0.1\lib\net46\System.Diagnostics.StackTrace.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="System.IO.Abstractions, Version=2.0.0.140, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\System.IO.Abstractions.2.0.0.140\lib\net40\System.IO.Abstractions.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System.IO.FileSystem, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.IO.FileSystem.4.0.1\lib\net46\System.IO.FileSystem.dll</HintPath>
       <Private>True</Private>

src/WebJobs.Script/packages.config

@@ -59,6 +59,7 @@
   <package id="System.Dynamic.Runtime" version="4.0.11" targetFramework="net46" />
   <package id="System.Globalization" version="4.0.11" targetFramework="net46" />
   <package id="System.IO" version="4.1.0" targetFramework="net46" />
+  <package id="System.IO.Abstractions" version="2.0.0.140" targetFramework="net46" />
   <package id="System.IO.FileSystem" version="4.0.1" targetFramework="net46" />
   <package id="System.IO.FileSystem.Primitives" version="4.0.1" targetFramework="net46" />
   <package id="System.Linq" version="4.1.0" targetFramework="net46" />

test/WebJobs.Script.Tests.Integration/NodeEndToEndTests.cs

@@ -334,12 +334,14 @@ public async Task SingleNamedExport()
             Assert.True(logs[1].Contains("Exports: IsObject=true, Count=1"));
         }
 
-        [Fact]
-        public async Task HttpTrigger_Get()
+        [Theory]
+        [InlineData("httptrigger")]
+        [InlineData("httptriggershared")]
+        public async Task HttpTrigger_Get(string functionName)
         {
             HttpRequestMessage request = new HttpRequestMessage
             {
-                RequestUri = new Uri(string.Format("http://localhost/api/httptrigger?name=Mathew%20Charles&location=Seattle")),
+                RequestUri = new Uri($"http://localhost/api/{functionName}?name=Mathew%20Charles&location=Seattle"),
                 Method = HttpMethod.Get,
             };
             request.SetConfiguration(Fixture.RequestConfiguration);

test/WebJobs.Script.Tests.Integration/Properties/Resources.Designer.cs

@@ -149,23 +149,23 @@
 }</value>
   </data>
   <data name="DotNetFunctionJson" xml:space="preserve">
-    <value>{
-    "scriptFile":"DotNetFunctionAssembly.dll",
+    <value>{{
+    "scriptFile":"{0}",
     "entryPoint": "TestFunction.Function.Run",
     "bindings": [
-        {
+        {{
             "type": "httpTrigger",
             "name": "req",
             "direction": "in",
             "methods": [ "get" ]
-        },
-        {
+        }},
+        {{
             "type": "http",
             "name": "$return",
             "direction": "out"
-        }
+        }}
     ]
-}</value>
+}}</value>
   </data>
   <data name="DotNetFunctionSource" xml:space="preserve">
     <value>using System.Net;

test/WebJobs.Script.Tests.Integration/Properties/Resources.resx

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -23,14 +24,25 @@ public RawAssemblyEndToEndTests(TestFixture fixture) : base(fixture)
 
         [Fact]
         public async Task Invoking_DotNetFunction()
+        {
+            await InvokeDotNetFunction("DotNetFunction");
+        }
+
+        [Fact]
+        public async Task Invoking_DotNetFunctionShared()
+        {
+            await InvokeDotNetFunction("DotNetFunctionShared");
+        }
+
+        public async Task InvokeDotNetFunction(string functionName)
         {
             var request = new HttpRequestMessage(HttpMethod.Get, "http://functions/myfunc");
             Dictionary<string, object> arguments = new Dictionary<string, object>()
             {
                 { "req", request }
             };
 
-            await Fixture.Host.CallAsync("DotNetFunction", arguments);
+            await Fixture.Host.CallAsync(functionName, arguments);
 
             HttpResponseMessage response = (HttpResponseMessage)request.Properties[ScriptConstants.AzureFunctionsHttpResponseKey];
 
@@ -41,10 +53,14 @@ public class TestFixture : EndToEndTestFixture
         {
             private const string ScriptRoot = @"TestScripts\DotNet";
             private static readonly string FunctionPath;
+            private static readonly string FunctionSharedPath;
+            private static readonly string FunctionSharedBinPath;
 
             static TestFixture()
             {
                 FunctionPath = Path.Combine(ScriptRoot, "DotNetFunction");
+                FunctionSharedPath = Path.Combine(ScriptRoot, "DotNetFunctionShared");
+                FunctionSharedBinPath = Path.Combine(ScriptRoot, "DotNetFunctionSharedBin");
                 CreateFunctionAssembly();
             }
 
@@ -56,15 +72,17 @@ public override void Dispose()
             {
                 base.Dispose();
 
-                if (Directory.Exists(FunctionPath))
-                {
-                    Directory.Delete(FunctionPath, true);
-                }
+                Task.WaitAll(
+                    FileUtility.DeleteIfExistsAsync(FunctionPath),
+                    FileUtility.DeleteIfExistsAsync(FunctionSharedPath),
+                    FileUtility.DeleteIfExistsAsync(FunctionSharedBinPath));
             }
 
             private static void CreateFunctionAssembly()
             {
                 Directory.CreateDirectory(FunctionPath);
+                Directory.CreateDirectory(FunctionSharedBinPath);
+                Directory.CreateDirectory(FunctionSharedPath);
 
                 var syntaxTree = CSharpSyntaxTree.ParseText(Resources.DotNetFunctionSource);
                 Compilation compilation = CSharpCompilation.Create("DotNetFunctionAssembly", new[] { syntaxTree })
@@ -75,10 +93,18 @@ private static void CreateFunctionAssembly()
                     MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
                     MetadataReference.CreateFromFile(typeof(object).Assembly.Location));
 
-                var result = compilation.Emit(Path.Combine(FunctionPath, "DotNetFunctionAssembly.dll"));
+                compilation.Emit(Path.Combine(FunctionPath, "DotNetFunctionAssembly.dll"));
+                compilation.Emit(Path.Combine(FunctionSharedBinPath, "DotNetFunctionSharedAssembly.dll"));
 
+                CreateFunctionMetadata(FunctionPath, "DotNetFunctionAssembly.dll");
+                CreateFunctionMetadata(FunctionSharedPath, $@"..\\{Path.GetFileName(FunctionSharedBinPath)}\\DotNetFunctionSharedAssembly.dll");
                 // Create function metadata
-                File.WriteAllText(Path.Combine(FunctionPath, "function.json"), Resources.DotNetFunctionJson);
+            }
+
+            private static void CreateFunctionMetadata(string path, string scriptFilePath)
+            {
+                File.WriteAllText(Path.Combine(path, "function.json"),
+                     string.Format(Resources.DotNetFunctionJson, scriptFilePath));
             }
         }
     }

test/WebJobs.Script.Tests.Integration/RawAssemblyEndToEndTests.cs

@@ -0,0 +1,16 @@
+{
+    "scriptFile": "../HttpTrigger/index.js",
+    "bindings": [
+        {
+            "type": "httpTrigger",
+            "name": "request",
+            "direction": "in",
+            "methods": [ "get", "post" ]
+        },
+        {
+            "type": "http",
+            "name": "response",
+            "direction": "out"
+        }
+    ]
+}