/// <summary>
/// Performs all required initialization on the host.
/// Must be called before the host is started.
/// </summary>
public async Task InitializeAsync(CancellationToken cancellationToken = default)
{
_stopwatch.Start();
using (_metricsLogger.LatencyEvent(MetricEventNames.HostStartupLatency))
{
PreInitialize();
HostInitializing?.Invoke(this, EventArgs.Empty);
// Generate Functions
IEnumerable <FunctionMetadata> functionMetadataList = GetFunctionsMetadata();
_workerRuntime = _workerRuntime ?? Utility.GetWorkerRuntime(functionMetadataList);
if (!_environment.IsPlaceholderModeEnabled())
{
// Appending the runtime version is currently only enabled for linux consumption.
// This will be eventually enabled for Windows Consumption as well.
string runtimeStack = GetPreciseRuntimeStack(_workerRuntime);
_metricsLogger.LogEvent(string.Format(MetricEventNames.HostStartupRuntimeLanguage, runtimeStack));
}
var directTypes = GetDirectTypes(functionMetadataList);
await InitializeFunctionDescriptorsAsync(functionMetadataList);
// Initialize worker function invocation dispatcher only for valid functions after creating function descriptors
await _functionDispatcher.InitializeAsync(Utility.GetValidFunctions(functionMetadataList, Functions), cancellationToken);
GenerateFunctions(directTypes);
CleanupFileSystem();
}
}
/// <summary>
/// Performs all required initialization on the host.
/// Must be called before the host is started.
/// </summary>
public async Task InitializeAsync()
{
_stopwatch.Start();
using (_metricsLogger.LatencyEvent(MetricEventNames.HostStartupLatency))
{
PreInitialize();
HostInitializing?.Invoke(this, EventArgs.Empty);
// Generate Functions
IEnumerable <FunctionMetadata> functions = GetFunctionsMetadata();
_workerRuntime = _workerRuntime ?? Utility.GetWorkerRuntime(functions);
if (!_environment.IsPlaceholderModeEnabled())
{
_metricsLogger.LogEvent(string.Format(MetricEventNames.HostStartupRuntimeLanguage, _workerRuntime));
}
// Initialize language worker function dispatcher
await _functionDispatcher.InitializeAsync(functions);
var directTypes = GetDirectTypes(functions);
await InitializeFunctionDescriptorsAsync(functions);
GenerateFunctions(directTypes);
CleanupFileSystem();
}
}
/// <summary>
/// Performs all required initialization on the host.
/// Must be called before the host is started.
/// </summary>
public async Task InitializeAsync(CancellationToken cancellationToken = default)
{
_stopwatch = ValueStopwatch.StartNew();
using (_metricsLogger.LatencyEvent(MetricEventNames.HostStartupLatency))
{
PreInitialize();
HostInitializing?.Invoke(this, EventArgs.Empty);
_workerRuntime = _workerRuntime ?? _environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionWorkerRuntime);
// get worker config information and check to see if worker should index or not
var workerConfigs = _languageWorkerOptions.Value.WorkerConfigs;
bool workerIndexing = Utility.CanWorkerIndex(workerConfigs, _environment);
// Generate Functions
IEnumerable <FunctionMetadata> functionMetadataList = GetFunctionsMetadata(workerIndexing);
if (!_environment.IsPlaceholderModeEnabled())
{
string runtimeStack = _workerRuntime;
if (!string.IsNullOrEmpty(runtimeStack))
{
// Appending the runtime version is currently only enabled for linux consumption. This will be eventually enabled for
// Windows Consumption as well.
string runtimeVersion = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeVersionSettingName);
if (!string.IsNullOrEmpty(runtimeVersion))
{
runtimeStack = string.Concat(runtimeStack, "-", runtimeVersion);
}
}
_metricsLogger.LogEvent(string.Format(MetricEventNames.HostStartupRuntimeLanguage, Sanitizer.Sanitize(runtimeStack)));
Utility.LogAutorestGeneratedJsonIfExists(ScriptOptions.RootScriptPath, _logger);
}
IsFunctionDataCacheEnabled = GetIsFunctionDataCacheEnabled();
await InitializeFunctionDescriptorsAsync(functionMetadataList, cancellationToken);
if (!workerIndexing)
{
// Initialize worker function invocation dispatcher only for valid functions after creating function descriptors
// Dispatcher not needed for codeless function.
// Disptacher needed for non-dotnet codeless functions
var filteredFunctionMetadata = functionMetadataList.Where(m => !Utility.IsCodelessDotNetLanguageFunction(m));
await _functionDispatcher.InitializeAsync(Utility.GetValidFunctions(filteredFunctionMetadata, Functions), cancellationToken);
}
GenerateFunctions();
ScheduleFileSystemCleanup();
}
}
public async Task <ImmutableArray <FunctionMetadata> > GetFunctionMetadataAsync(IEnumerable <RpcWorkerConfig> workerConfigs, IEnvironment environment, bool forceRefresh)
{
IEnumerable <FunctionMetadata> functions = new List <FunctionMetadata>();
_logger.FunctionMetadataProviderParsingFunctions();
if (_functions.IsDefaultOrEmpty || forceRefresh)
{
IEnumerable <RawFunctionMetadata> rawFunctions = new List <RawFunctionMetadata>();
bool workerIndexing = Utility.CanWorkerIndex(workerConfigs, environment);
if (workerIndexing)
{
if (_dispatcher == null)
{
throw new InvalidOperationException(nameof(_dispatcher));
}
// start up GRPC channels
await _dispatcher.InitializeAsync(new List <FunctionMetadata>());
// get function metadata from worker, then validate it
rawFunctions = await _dispatcher.GetWorkerMetadata();
if (IsDefaultIndexingRequired(rawFunctions))
{
_logger.LogDebug("Fallback to host indexing as worker denied indexing");
functions = await _hostFunctionMetadataProvider.GetFunctionMetadataAsync(workerConfigs, environment, forceRefresh);
}
else if (!IsNullOrEmpty(rawFunctions))
{
functions = ValidateMetadata(rawFunctions);
}
// set up invocation buffers and send load requests
await _dispatcher.FinishInitialization(functions);
// Validate if the app has functions in legacy format and add in logs to inform about the mixed app
_ = Task.Delay(TimeSpan.FromMinutes(1)).ContinueWith(t => ValidateFunctionAppFormat(_scriptOptions.Value.RootScriptPath, _logger, environment));
}
else
{
functions = await _hostFunctionMetadataProvider.GetFunctionMetadataAsync(workerConfigs, environment, forceRefresh);
}
}
_functions = functions.ToImmutableArray();
_logger.FunctionMetadataProviderFunctionFound(_functions.IsDefault ? 0 : _functions.Count());
return(_functions);
}
/// <summary>
/// Performs all required initialization on the host.
/// Must be called before the host is started.
/// </summary>
public async Task InitializeAsync(CancellationToken cancellationToken = default)
{
_stopwatch.Start();
using (_metricsLogger.LatencyEvent(MetricEventNames.HostStartupLatency))
{
PreInitialize();
HostInitializing?.Invoke(this, EventArgs.Empty);
// Generate Functions
IEnumerable <FunctionMetadata> functionMetadataList = GetFunctionsMetadata();
_workerRuntime = _workerRuntime ?? Utility.GetWorkerRuntime(functionMetadataList);
if (!_environment.IsPlaceholderModeEnabled())
{
string runtimeStack = _workerRuntime;
if (!string.IsNullOrEmpty(runtimeStack))
{
// Appending the runtime version is currently only enabled for linux consumption. This will be eventually enabled for
// Windows Consumption as well.
string runtimeVersion = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeVersionSettingName);
if (!string.IsNullOrEmpty(runtimeVersion))
{
runtimeStack = string.Concat(runtimeStack, "-", runtimeVersion);
}
}
_metricsLogger.LogEvent(string.Format(MetricEventNames.HostStartupRuntimeLanguage, runtimeStack));
Utility.LogAutorestGeneratedJsonIfExists(ScriptOptions.RootScriptPath, _logger);
}
var directTypes = GetDirectTypes(functionMetadataList);
await InitializeFunctionDescriptorsAsync(functionMetadataList, cancellationToken);
// Initialize worker function invocation dispatcher only for valid functions after creating function descriptors
// Dispatcher not needed for non-proxy codeless function.
// Disptacher needed for non-dotnet codeless functions
var filteredFunctionMetadata = functionMetadataList.Where(m => m.IsProxy() || !Utility.IsCodelessDotNetLanguageFunction(m));
await _functionDispatcher.InitializeAsync(Utility.GetValidFunctions(filteredFunctionMetadata, Functions), cancellationToken);
GenerateFunctions(directTypes);
ScheduleFileSystemCleanup();
}
}
