|
private CreateOrUpdateContext ( |
||
| metadata | ||
| functionAssembly | ||
| metadataResolver | IFunctionMetadataResolver | |
| traceWriter | Microsoft.Azure.WebJobs.Host.TraceWriter | |
| return | ||
private async Task <MethodInfo> CreateFunctionTarget(CancellationToken cancellationToken)
{
try
{
await VerifyPackageReferencesAsync();
string eventName = string.Format(MetricEventNames.FunctionCompileLatencyByLanguageFormat, _compilationService.Language);
using (_metricsLogger.LatencyEvent(eventName))
{
IDotNetCompilation compilation = await _compilationService.GetFunctionCompilationAsync(Metadata);
Assembly assembly = compilation.Emit(cancellationToken);
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter, Host.ScriptConfig.HostConfig.LoggerFactory);
FunctionSignature functionSignature = compilation.GetEntryPointSignature(_functionEntryPointResolver);
ImmutableArray <Diagnostic> bindingDiagnostics = ValidateFunctionBindingArguments(functionSignature, _triggerInputName, _inputBindings, _outputBindings, throwIfFailed: true);
TraceCompilationDiagnostics(bindingDiagnostics);
// Set our function entry point signature
_functionSignature = functionSignature;
return(_functionSignature.GetMethod(assembly));
}
}
catch (CompilationErrorException exc)
{
ImmutableArray <Diagnostic> diagnostics = AddFunctionDiagnostics(exc.Diagnostics);
// Here we only need to trace to system logs
TraceCompilationDiagnostics(diagnostics, LogTargets.System);
throw new CompilationErrorException(exc.Message, diagnostics);
}
}
private async Task <MethodInfo> CreateFunctionTarget(CancellationToken cancellationToken)
{
try
{
await VerifyPackageReferencesAsync();
ICompilation compilation = _compilationService.GetFunctionCompilation(Metadata);
FunctionSignature functionSignature = compilation.GetEntryPointSignature(_functionEntryPointResolver);
ImmutableArray <Diagnostic> bindingDiagnostics = ValidateFunctionBindingArguments(functionSignature, _triggerInputName, _inputBindings, _outputBindings, throwIfFailed: true);
TraceCompilationDiagnostics(bindingDiagnostics);
Assembly assembly = compilation.EmitAndLoad(cancellationToken);
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
// Get our function entry point
_functionSignature = functionSignature;
System.Reflection.TypeInfo scriptType = assembly.DefinedTypes
.FirstOrDefault(t => string.Compare(t.Name, functionSignature.ParentTypeName, StringComparison.Ordinal) == 0);
return(_functionEntryPointResolver.GetFunctionEntryPoint(scriptType.DeclaredMethods.ToList()));
}
catch (CompilationErrorException ex)
{
TraceOnPrimaryHost("Function compilation error", TraceLevel.Error);
TraceCompilationDiagnostics(ex.Diagnostics);
throw;
}
}
public void ResolveAssembly_WithIndirectPrivateDependency_IsResolved()
{
var resolver = new FunctionAssemblyLoader("c:\\");
var metadata1 = new FunctionMetadata { Name = "Test1", Source = @"c:\testroot\test1\test.tst" };
var metadata2 = new FunctionMetadata { Name = "Test2", Source = @"c:\testroot\test2\test.tst" };
var traceWriter = new TestTraceWriter(TraceLevel.Verbose);
var mockResolver = new Mock<IFunctionMetadataResolver>();
mockResolver.Setup(m => m.ResolveAssembly("MyTestAssembly.dll"))
.Returns(new TestAssembly(new AssemblyName("MyTestAssembly")));
resolver.CreateOrUpdateContext(metadata1, this.GetType().Assembly, new FunctionMetadataResolver(metadata1, traceWriter), traceWriter);
resolver.CreateOrUpdateContext(metadata2, this.GetType().Assembly, mockResolver.Object, traceWriter);
Assembly result = resolver.ResolveAssembly(null, new System.ResolveEventArgs("MyTestAssembly.dll",
new TestAssembly(new AssemblyName("MyDirectReference"), @"file:///c:/testroot/test2/bin/MyDirectReference.dll")));
Assert.NotNull(result);
}
public void ResolveAssembly_WithIndirectPrivateDependency_LogsIfResolutionFails()
{
var resolver = new FunctionAssemblyLoader("c:\\");
var metadata1 = new FunctionMetadata { Name = "Test1", ScriptFile = @"c:\testroot\test1\test.tst" };
var metadata2 = new FunctionMetadata { Name = "Test2", ScriptFile = @"c:\testroot\test2\test.tst" };
var traceWriter = new TestTraceWriter(TraceLevel.Verbose);
var mockResolver = new Mock<IFunctionMetadataResolver>();
mockResolver.Setup(m => m.ResolveAssembly("MyTestAssembly.dll"))
.Returns<Assembly>(null);
resolver.CreateOrUpdateContext(metadata1, this.GetType().Assembly, new FunctionMetadataResolver(metadata1, new Collection<ScriptBindingProvider>(), traceWriter), traceWriter);
resolver.CreateOrUpdateContext(metadata2, this.GetType().Assembly, mockResolver.Object, traceWriter);
Assembly result = resolver.ResolveAssembly(AppDomain.CurrentDomain, new System.ResolveEventArgs("MyTestAssembly.dll",
new TestAssembly(new AssemblyName("MyDirectReference"), @"file:///c:/testroot/test2/bin/MyDirectReference.dll")));
Assert.Null(result);
Assert.Equal(1, traceWriter.Traces.Count);
Assert.Contains("MyTestAssembly.dll", traceWriter.Traces[0].Message);
}
private MethodInfo CreateFunctionTarget(CancellationToken cancellationToken)
{
// TODO:Get this from some context set in/by the host.
bool debug = true;
MemoryStream assemblyStream = null;
MemoryStream pdbStream = null;
try
{
Script <object> script = CreateScript();
Compilation compilation = GetScriptCompilation(script, debug);
CSharpFunctionSignature functionSignature = CSharpFunctionSignature.FromCompilation(compilation, _functionEntryPointResolver);
ValidateFunctionBindingArguments(functionSignature, throwIfFailed: true);
using (assemblyStream = new MemoryStream())
{
using (pdbStream = new MemoryStream())
{
var result = compilation.Emit(assemblyStream, pdbStream);
// Check if cancellation was requested while we were compiling,
// and if so quit here.
cancellationToken.ThrowIfCancellationRequested();
if (!result.Success)
{
throw new CompilationErrorException("Script compilation failed.", result.Diagnostics);
}
Assembly assembly = Assembly.Load(assemblyStream.GetBuffer(), pdbStream.GetBuffer());
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
// Get our function entry point
System.Reflection.TypeInfo scriptType = assembly.DefinedTypes.FirstOrDefault(t => string.Compare(t.Name, ScriptClassName, StringComparison.Ordinal) == 0);
_functionSignature = functionSignature;
return(_functionEntryPointResolver.GetFunctionEntryPoint(scriptType.DeclaredMethods.ToList()));
}
}
}
catch (CompilationErrorException ex)
{
TraceWriter.Error("Function compilation error");
TraceCompilationDiagnostics(ex.Diagnostics);
throw;
}
}
private MethodInfo CreateFunctionTarget(CancellationToken cancellationToken)
{
MemoryStream assemblyStream = null;
MemoryStream pdbStream = null;
try
{
ICompilation compilation = _compilationService.GetFunctionCompilation(Metadata);
FunctionSignature functionSignature = compilation.GetEntryPointSignature(_functionEntryPointResolver);
ImmutableArray <Diagnostic> bindingDiagnostics = ValidateFunctionBindingArguments(functionSignature, throwIfFailed: true);
TraceCompilationDiagnostics(bindingDiagnostics);
using (assemblyStream = new MemoryStream())
{
using (pdbStream = new MemoryStream())
{
compilation.Emit(assemblyStream, pdbStream, cancellationToken);
// Check if cancellation was requested while we were compiling,
// and if so quit here.
cancellationToken.ThrowIfCancellationRequested();
Assembly assembly = Assembly.Load(assemblyStream.GetBuffer(), pdbStream.GetBuffer());
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
// Get our function entry point
_functionSignature = functionSignature;
System.Reflection.TypeInfo scriptType = assembly.DefinedTypes
.FirstOrDefault(t => string.Compare(t.Name, functionSignature.ParentTypeName, StringComparison.Ordinal) == 0);
return(_functionEntryPointResolver.GetFunctionEntryPoint(scriptType.DeclaredMethods.ToList()));
}
}
}
catch (CompilationErrorException ex)
{
TraceWriter.Error("Function compilation error");
TraceCompilationDiagnostics(ex.Diagnostics);
throw;
}
}
private async Task <MethodInfo> CreateFunctionTarget(CancellationToken cancellationToken)
{
try
{
await VerifyPackageReferencesAsync();
string eventName = string.Format(MetricEventNames.FunctionCompileLatencyByLanguageFormat, _compilationService.Language);
using (_metricsLogger.LatencyEvent(eventName))
{
ICompilation compilation = _compilationService.GetFunctionCompilation(Metadata);
Assembly assembly = compilation.EmitAndLoad(cancellationToken);
_assemblyLoader.CreateOrUpdateContext(Metadata, assembly, _metadataResolver, TraceWriter);
FunctionSignature functionSignature = compilation.GetEntryPointSignature(_functionEntryPointResolver);
ImmutableArray <Diagnostic> bindingDiagnostics = ValidateFunctionBindingArguments(functionSignature, _triggerInputName, _inputBindings, _outputBindings, throwIfFailed: true);
TraceCompilationDiagnostics(bindingDiagnostics);
// Set our function entry point signature
_functionSignature = functionSignature;
System.Reflection.TypeInfo scriptType = assembly.DefinedTypes
.FirstOrDefault(t => string.Compare(t.Name, functionSignature.ParentTypeName, StringComparison.Ordinal) == 0);
return(_functionEntryPointResolver.GetFunctionEntryPoint(scriptType.DeclaredMethods.ToList()));
}
}
catch (CompilationErrorException exc)
{
ImmutableArray <Diagnostic> diagnostics = AddFunctionDiagnostics(exc.Diagnostics);
// Here we only need to trace to system logs
TraceCompilationDiagnostics(diagnostics, LogTargets.System);
throw new CompilationErrorException(exc.Message, diagnostics);
}
}
