internal DotNetFunctionInvoker(ScriptHost host,
FunctionMetadata functionMetadata,
Collection <FunctionBinding> inputBindings,
Collection <FunctionBinding> outputBindings,
IFunctionEntryPointResolver functionEntryPointResolver,
ICompilationServiceFactory <ICompilationService <IDotNetCompilation>, IFunctionMetadataResolver> compilationServiceFactory,
ILoggerFactory loggerFactory,
IMetricsLogger metricsLogger,
ICollection <IScriptBindingProvider> bindingProviders,
IFunctionMetadataResolver metadataResolver = null)
: base(host, functionMetadata, loggerFactory)
{
_metricsLogger = metricsLogger;
_functionEntryPointResolver = functionEntryPointResolver;
_metadataResolver = metadataResolver ?? CreateMetadataResolver(host, bindingProviders, functionMetadata, FunctionLogger);
_compilationService = compilationServiceFactory.CreateService(functionMetadata.Language, _metadataResolver);
_inputBindings = inputBindings;
_outputBindings = outputBindings;
_triggerInputName = functionMetadata.Bindings.FirstOrDefault(b => b.IsTrigger).Name;
_functionMetadata = functionMetadata;
InitializeFileWatcher();
_functionLoader = new FunctionLoader <MethodInfo>(CreateFunctionTarget);
_reloadScript = ReloadScriptAsync;
_reloadScript = _reloadScript.Debounce();
_onReferencesChanged = OnReferencesChanged;
_onReferencesChanged = _onReferencesChanged.Debounce();
_restorePackages = RestorePackages;
_restorePackages = _restorePackages.Debounce();
}
internal DotNetFunctionInvoker(ScriptHost host, FunctionMetadata functionMetadata,
Collection <FunctionBinding> inputBindings, Collection <FunctionBinding> outputBindings,
IFunctionEntryPointResolver functionEntryPointResolver, FunctionAssemblyLoader assemblyLoader,
ICompilationServiceFactory compilationServiceFactory)
: base(host, functionMetadata)
{
_functionEntryPointResolver = functionEntryPointResolver;
_assemblyLoader = assemblyLoader;
_metadataResolver = new FunctionMetadataResolver(functionMetadata, host.ScriptConfig.BindingProviders, TraceWriter);
_compilationService = compilationServiceFactory.CreateService(functionMetadata.ScriptType, _metadataResolver);
_inputBindings = inputBindings;
_outputBindings = outputBindings;
_triggerInputName = functionMetadata.Bindings.FirstOrDefault(b => b.IsTrigger).Name;
_metrics = host.ScriptConfig.HostConfig.GetService <IMetricsLogger>();
InitializeFileWatcher();
_resultProcessor = CreateResultProcessor();
_functionValueLoader = FunctionValueLoader.Create(CreateFunctionTarget);
_reloadScript = ReloadScript;
_reloadScript = _reloadScript.Debounce();
_restorePackages = RestorePackages;
_restorePackages = _restorePackages.Debounce();
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver, Assembly functionAssembly)
{
EnsureAssemblyOption(false);
// Scrape the compiled assembly for entry points
IList <MethodReference <MethodInfo> > methods =
functionAssembly.GetTypes().SelectMany(t =>
t.GetMethods().Select(m =>
new MethodReference <MethodInfo>(m.Name, m.IsPublic, m))).ToList();
MethodInfo entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
// For F#, this currently creates a malformed signautre with fewer parameter symbols than parameter names.
// For validation we only need the parameter names. The implementation of DotNetFunctionSignature copes with the
// lists having different lengths.
var parameters = entryPointReference.GetParameters().Select(x => new FunctionParameter(x.Name, x.ParameterType.FullName, x.IsOptional, GetParameterRefKind(x)));
// For F#, we always set this to true for now.
bool hasLocalTypeReference = true;
var signature = new FunctionSignature(entryPointReference.DeclaringType.FullName, entryPointReference.Name,
parameters.ToImmutableArray(), entryPointReference.ReturnType.Name, hasLocalTypeReference);
return(signature);
}
internal CSharpFunctionInvoker(ScriptHost host, FunctionMetadata functionMetadata,
Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings,
IFunctionEntryPointResolver functionEntryPointResolver, FunctionAssemblyLoader assemblyLoader)
: base(host, functionMetadata)
{
_host = host;
_functionEntryPointResolver = functionEntryPointResolver;
_assemblyLoader = assemblyLoader;
_metadataResolver = new FunctionMetadataResolver(functionMetadata, TraceWriter);
_inputBindings = inputBindings;
_outputBindings = outputBindings;
_triggerInputName = GetTriggerInputName(functionMetadata);
_metrics = host.ScriptConfig.HostConfig.GetService<IMetricsLogger>();
InitializeFileWatcherIfEnabled();
_resultProcessor = CreateResultProcessor();
_functionValueLoader = FunctionValueLoader.Create(CreateFunctionTarget);
_reloadScript = ReloadScript;
_reloadScript = _reloadScript.Debounce();
_restorePackages = RestorePackages;
_restorePackages = _restorePackages.Debounce();
}
internal DotNetFunctionInvoker(ScriptHost host, FunctionMetadata functionMetadata,
Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings,
IFunctionEntryPointResolver functionEntryPointResolver, FunctionAssemblyLoader assemblyLoader,
ICompilationServiceFactory compilationServiceFactory, ITraceWriterFactory traceWriterFactory = null)
: base(host, functionMetadata, traceWriterFactory)
{
_metricsLogger = Host.ScriptConfig.HostConfig.GetService<IMetricsLogger>();
_functionEntryPointResolver = functionEntryPointResolver;
_assemblyLoader = assemblyLoader;
_metadataResolver = new FunctionMetadataResolver(functionMetadata, host.ScriptConfig.BindingProviders, TraceWriter);
_compilationService = compilationServiceFactory.CreateService(functionMetadata.ScriptType, _metadataResolver);
_inputBindings = inputBindings;
_outputBindings = outputBindings;
_triggerInputName = functionMetadata.Bindings.FirstOrDefault(b => b.IsTrigger).Name;
InitializeFileWatcher();
_resultProcessor = CreateResultProcessor();
_functionLoader = new FunctionLoader<MethodInfo>(CreateFunctionTarget);
_reloadScript = ReloadScript;
_reloadScript = _reloadScript.Debounce();
_restorePackages = RestorePackages;
_restorePackages = _restorePackages.Debounce();
}
internal DotNetFunctionInvoker(ScriptHost host,
FunctionMetadata functionMetadata,
Collection <FunctionBinding> inputBindings,
Collection <FunctionBinding> outputBindings,
IFunctionEntryPointResolver functionEntryPointResolver,
FunctionAssemblyLoader assemblyLoader,
ICompilationServiceFactory <ICompilationService <IDotNetCompilation>, IFunctionMetadataResolver> compilationServiceFactory,
IFunctionMetadataResolver metadataResolver = null)
: base(host, functionMetadata)
{
_metricsLogger = Host.ScriptConfig.HostConfig.GetService <IMetricsLogger>();
_functionEntryPointResolver = functionEntryPointResolver;
_assemblyLoader = assemblyLoader;
_metadataResolver = metadataResolver ?? CreateMetadataResolver(host, functionMetadata, TraceWriter);
_compilationService = compilationServiceFactory.CreateService(functionMetadata.ScriptType, _metadataResolver);
_inputBindings = inputBindings;
_outputBindings = outputBindings;
_triggerInputName = functionMetadata.Bindings.FirstOrDefault(b => b.IsTrigger).Name;
InitializeFileWatcher();
_resultProcessor = CreateResultProcessor();
_functionLoader = new FunctionLoader <MethodInfo>(CreateFunctionTarget);
_reloadScript = ReloadScriptAsync;
_reloadScript = _reloadScript.Debounce();
_onReferencesChanged = OnReferencesChanged;
_onReferencesChanged = _onReferencesChanged.Debounce();
_restorePackages = RestorePackages;
_restorePackages = _restorePackages.Debounce();
}
internal CSharpFunctionInvoker(ScriptHost host, FunctionMetadata functionMetadata,
Collection <FunctionBinding> inputBindings, Collection <FunctionBinding> outputBindings,
IFunctionEntryPointResolver functionEntryPointResolver, FunctionAssemblyLoader assemblyLoader)
: base(host, functionMetadata)
{
_host = host;
_functionEntryPointResolver = functionEntryPointResolver;
_assemblyLoader = assemblyLoader;
_metadataResolver = new FunctionMetadataResolver(functionMetadata, TraceWriter);
_inputBindings = inputBindings;
_outputBindings = outputBindings;
_triggerInputName = GetTriggerInputName(functionMetadata);
_metrics = host.ScriptConfig.HostConfig.GetService <IMetricsLogger>();
InitializeFileWatcherIfEnabled();
_resultProcessor = CreateResultProcessor();
_functionValueLoader = FunctionValueLoader.Create(CreateFunctionTarget);
_reloadScript = ReloadScript;
_reloadScript = _reloadScript.Debounce();
_restorePackages = RestorePackages;
_restorePackages = _restorePackages.Debounce();
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
var entryPointMatch = _entryPointRegex.Match(_entryPointName);
if (!entryPointMatch.Success)
{
throw new InvalidOperationException("Invalid entry point configuration. The function entry point must be defined in the format <fulltypename>.<methodname>");
}
string typeName = entryPointMatch.Groups["typename"].Value;
string methodName = entryPointMatch.Groups["methodname"].Value;
Type functionType = FunctionAssembly.GetType(typeName);
if (functionType == null)
{
throw new InvalidOperationException($"The function type name '{typeName}' is invalid.");
}
MethodInfo method = functionType.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public);
if (method == null)
{
throw new InvalidOperationException($"The method '{methodName}' cannot be found.");
}
var functionParameters = method.GetParameters().Select(p => new FunctionParameter(p.Name, p.ParameterType.FullName, p.IsOptional, GetParameterRefKind(p)));
return(new FunctionSignature(method.ReflectedType.FullName, method.Name, ImmutableArray.CreateRange(functionParameters.ToArray()), method.ReturnType.Name, hasLocalTypeReference: false));
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
var entryPointMatch = _entryPointRegex.Match(_entryPointName);
if (!entryPointMatch.Success)
{
throw new InvalidOperationException("Invalid entry point configuration. The function entry point must be defined in the format <fulltypename>.<methodname>");
}
string typeName = entryPointMatch.Groups["typename"].Value;
string methodName = entryPointMatch.Groups["methodname"].Value;
Type functionType = FunctionAssembly.GetType(typeName);
if (functionType == null)
{
throw new InvalidOperationException($"The function type name '{typeName}' is invalid.");
}
MethodInfo method = functionType.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public);
if (method == null)
{
throw new InvalidOperationException($"The method '{methodName}' cannot be found.");
}
var functionParameters = method.GetParameters().Select(p => new FunctionParameter(p.Name, p.ParameterType.FullName, p.IsOptional, GetParameterRefKind(p)));
return new FunctionSignature(method.ReflectedType.Name, method.Name, ImmutableArray.CreateRange(functionParameters.ToArray()), method.ReturnType.Name, hasLocalTypeReference: false);
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
if (!_compilation.SyntaxTrees.Any())
{
throw new InvalidOperationException("The current compilation does not have a syntax tree.");
}
var methods = _compilation.ScriptClass
.GetMembers()
.OfType <IMethodSymbol>()
.Select(m => new MethodReference <IMethodSymbol>(m.Name, m.DeclaredAccessibility == Accessibility.Public, m));
IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
bool hasLocalTypeReferences = entryPointReference.Parameters.Any(p => IsOrUsesAssemblyType(p.Type, entryPointReference.ContainingAssembly));
return(new FunctionSignature(entryPointReference.ContainingType.Name, entryPointReference.Name, entryPointReference.Parameters, hasLocalTypeReferences));
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
if (!_compilation.SyntaxTrees.Any())
{
throw new InvalidOperationException("The current compilation does not have a syntax tree.");
}
var methods = _compilation.ScriptClass
.GetMembers()
.OfType <IMethodSymbol>()
.Select(m => new MethodReference <IMethodSymbol>(m.Name, m.DeclaredAccessibility == Accessibility.Public, m));
IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
bool hasLocalTypeReferences = HasLocalTypeReferences(entryPointReference);
var functionParameters = entryPointReference.Parameters.Select(p => new FunctionParameter(p.Name, GetFullTypeName(p.Type), p.IsOptional, p.RefKind));
return(new FunctionSignature(entryPointReference.ContainingType.Name, entryPointReference.Name,
ImmutableArray.CreateRange(functionParameters.ToArray()), GetFullTypeName(entryPointReference.ReturnType), hasLocalTypeReferences));
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
if (!_compilation.SyntaxTrees.Any())
{
throw new InvalidOperationException("The current compilation does not have a syntax tree.");
}
var methods = _compilation.ScriptClass
.GetMembers()
.OfType<IMethodSymbol>()
.Select(m => new MethodReference<IMethodSymbol>(m.Name, m.DeclaredAccessibility == Accessibility.Public, m));
IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
bool hasLocalTypeReferences = HasLocalTypeReferences(entryPointReference);
var functionParameters = entryPointReference.Parameters.Select(p => new FunctionParameter(p.Name, GetFullTypeName(p.Type), p.IsOptional, p.RefKind));
return new FunctionSignature(entryPointReference.ContainingType.Name, entryPointReference.Name,
ImmutableArray.CreateRange(functionParameters.ToArray()), GetFullTypeName(entryPointReference.ReturnType), hasLocalTypeReferences);
}
public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
{
EnsureAssemblyOption();
// Scrape the compiled assembly for entry points
IList<MethodReference<MethodInfo>> methods =
_assemblyOption.Value.GetTypes().SelectMany(t =>
t.GetMethods().Select(m =>
new MethodReference<MethodInfo>(m.Name, m.IsPublic, m))).ToList();
MethodInfo entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
// For F#, this currently creates a malformed signautre with fewer parameter symbols than parameter names.
// For validation we only need the parameter names. The implementation of DotNetFunctionSignature copes with the
// lists having different lengths.
var parameters = entryPointReference.GetParameters().Select(x => new FunctionParameter(x.Name, x.ParameterType.FullName, x.IsOptional, GetParameterRefKind(x)));
// For F#, we always set this to true for now.
bool hasLocalTypeReference = true;
var signature = new FunctionSignature(entryPointReference.DeclaringType.Name, entryPointReference.Name,
parameters.ToImmutableArray(), entryPointReference.ReturnType.Name, hasLocalTypeReference);
return signature;
}
public static CSharpFunctionSignature FromCompilation(Compilation compilation, IFunctionEntryPointResolver entryPointResolver)
{
if (compilation == null)
{
throw new ArgumentNullException("compilation");
}
if (entryPointResolver == null)
{
throw new ArgumentNullException("entryPointResolver");
}
if (!compilation.SyntaxTrees.Any())
{
throw new ArgumentException("The provided compilation does not have a syntax tree.", "compilation");
}
var methods = compilation.ScriptClass
.GetMembers()
.OfType <IMethodSymbol>()
.Select(m => new MethodReference <IMethodSymbol>(m.Name, m.DeclaredAccessibility == Accessibility.Public, m));
IMethodSymbol entryPointReference = entryPointResolver.GetFunctionEntryPoint(methods).Value;
var signature = new CSharpFunctionSignature(entryPointReference.Parameters);
signature.HasLocalTypeReference = entryPointReference.Parameters.Any(p => IsOrUsesAssemblyType(p.Type, entryPointReference.ContainingAssembly));
return(signature);
}
