internal void WorkerInitResponse(GrpcEvent initEvent)
{
_startLatencyMetric?.Dispose();
_startLatencyMetric = null;
_workerChannelLogger.LogDebug("Received WorkerInitResponse. Worker process initialized");
_initMessage = initEvent.Message.WorkerInitResponse;
_workerChannelLogger.LogDebug($"Worker capabilities: {_initMessage.Capabilities}");
if (_initMessage.Result.IsFailure(out Exception exc))
{
HandleWorkerInitError(exc);
_workerInitTask.SetResult(false);
return;
}
_state = _state | RpcWorkerChannelState.Initialized;
_workerCapabilities.UpdateCapabilities(_initMessage.Capabilities);
_isSharedMemoryDataTransferEnabled = IsSharedMemoryDataTransferEnabled();
if (!_isSharedMemoryDataTransferEnabled)
{
// If the worker does not support using shared memory data transfer, caching must also be disabled
ScriptHost.IsFunctionDataCacheEnabled = false;
}
_workerInitTask.SetResult(true);
}
public void SetupFunctionInvocationBuffers(IEnumerable <FunctionMetadata> functions)
{
_functions = functions;
foreach (FunctionMetadata metadata in functions)
{
_workerChannelLogger.LogDebug("Setting up FunctionInvocationBuffer for function:{functionName} with functionId:{id}", metadata.Name, metadata.GetFunctionId());
_functionInputBuffers[metadata.GetFunctionId()] = new BufferBlock <ScriptInvocationContext>();
}
_state = _state | RpcWorkerChannelState.InvocationBuffersInitialized;
}
internal GrpcWorkerChannel(
string workerId,
IScriptEventManager eventManager,
RpcWorkerConfig workerConfig,
IWorkerProcess rpcWorkerProcess,
ILogger logger,
IMetricsLogger metricsLogger,
int attemptCount,
IEnvironment environment,
IOptionsMonitor <ScriptApplicationHostOptions> applicationHostOptions,
ISharedMemoryManager sharedMemoryManager,
IFunctionDataCache functionDataCache,
IOptions <WorkerConcurrencyOptions> workerConcurrencyOptions)
{
_workerId = workerId;
_eventManager = eventManager;
_workerConfig = workerConfig;
_runtime = workerConfig.Description.Language;
_rpcWorkerProcess = rpcWorkerProcess;
_workerChannelLogger = logger;
_metricsLogger = metricsLogger;
_environment = environment;
_applicationHostOptions = applicationHostOptions;
_sharedMemoryManager = sharedMemoryManager;
_workerConcurrencyOptions = workerConcurrencyOptions;
_workerCapabilities = new GrpcCapabilities(_workerChannelLogger);
_inboundWorkerEvents = _eventManager.OfType <InboundGrpcEvent>()
.Where(msg => msg.WorkerId == _workerId);
_eventSubscriptions.Add(_inboundWorkerEvents
.Where(msg => msg.IsMessageOfType(MsgType.RpcLog) && !msg.IsLogOfCategory(RpcLogCategory.System))
.Subscribe(Log));
_eventSubscriptions.Add(_inboundWorkerEvents
.Where(msg => msg.IsMessageOfType(MsgType.RpcLog) && msg.IsLogOfCategory(RpcLogCategory.System))
.Subscribe(SystemLog));
_eventSubscriptions.Add(_eventManager.OfType <FileEvent>()
.Where(msg => _workerConfig.Description.Extensions.Contains(Path.GetExtension(msg.FileChangeArguments.FullPath)))
.Throttle(TimeSpan.FromMilliseconds(300)) // debounce
.Subscribe(msg => _eventManager.Publish(new HostRestartEvent())));
_eventSubscriptions.Add(_inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.InvocationResponse)
.Subscribe(async(msg) => await InvokeResponse(msg.Message.InvocationResponse)));
_inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.WorkerStatusResponse)
.Subscribe((msg) => ReceiveWorkerStatusResponse(msg.Message.RequestId, msg.Message.WorkerStatusResponse));
_startLatencyMetric = metricsLogger?.LatencyEvent(string.Format(MetricEventNames.WorkerInitializeLatency, workerConfig.Description.Language, attemptCount));
_state = RpcWorkerChannelState.Default;
}
public async Task StartWorkerProcessAsync()
{
_startSubscription = _inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.StartStream)
.Timeout(TimeSpan.FromSeconds(WorkerConstants.ProcessStartTimeoutSeconds))
.Take(1)
.Subscribe(SendWorkerInitRequest, HandleWorkerStartStreamError);
_workerChannelLogger.LogDebug("Initiating Worker Process start up");
await _rpcWorkerProcess.StartProcessAsync();
_state = RpcWorkerChannelState.Initializing;
await _workerInitTask.Task;
}
public async Task StartWorkerProcessAsync(CancellationToken cancellationToken)
{
_startSubscription = _inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.StartStream)
.Timeout(_workerConfig.CountOptions.ProcessStartupTimeout)
.Take(1)
.Subscribe(SendWorkerInitRequest, HandleWorkerStartStreamError);
_workerChannelLogger.LogDebug("Initiating Worker Process start up");
await _rpcWorkerProcess.StartProcessAsync();
_state = _state | RpcWorkerChannelState.Initializing;
await _workerInitTask.Task;
}
internal RpcWorkerChannel(
string workerId,
string rootScriptPath,
IScriptEventManager eventManager,
RpcWorkerConfig workerConfig,
IWorkerProcess rpcWorkerProcess,
ILogger logger,
IMetricsLogger metricsLogger,
int attemptCount,
IOptions <ManagedDependencyOptions> managedDependencyOptions = null)
{
_workerId = workerId;
_rootScriptPath = rootScriptPath;
_eventManager = eventManager;
_workerConfig = workerConfig;
_runtime = workerConfig.Description.Language;
_rpcWorkerProcess = rpcWorkerProcess;
_workerChannelLogger = logger;
_metricsLogger = metricsLogger;
_workerCapabilities = new Capabilities(_workerChannelLogger);
_inboundWorkerEvents = _eventManager.OfType <InboundEvent>()
.Where(msg => msg.WorkerId == _workerId);
_eventSubscriptions.Add(_inboundWorkerEvents
.Where(msg => msg.IsMessageOfType(MsgType.RpcLog) && !msg.IsLogOfCategory(RpcLogCategory.System))
.Subscribe(Log));
_eventSubscriptions.Add(_inboundWorkerEvents
.Where(msg => msg.IsMessageOfType(MsgType.RpcLog) && msg.IsLogOfCategory(RpcLogCategory.System))
.Subscribe(SystemLog));
_eventSubscriptions.Add(_eventManager.OfType <FileEvent>()
.Where(msg => _workerConfig.Description.Extensions.Contains(Path.GetExtension(msg.FileChangeArguments.FullPath)))
.Throttle(TimeSpan.FromMilliseconds(300)) // debounce
.Subscribe(msg => _eventManager.Publish(new HostRestartEvent())));
_eventSubscriptions.Add(_inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.FunctionLoadResponse)
.Subscribe((msg) => LoadResponse(msg.Message.FunctionLoadResponse)));
_eventSubscriptions.Add(_inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.InvocationResponse)
.Subscribe((msg) => InvokeResponse(msg.Message.InvocationResponse)));
_startLatencyMetric = metricsLogger?.LatencyEvent(string.Format(MetricEventNames.WorkerInitializeLatency, workerConfig.Description.Language, attemptCount));
_managedDependencyOptions = managedDependencyOptions;
_state = RpcWorkerChannelState.Default;
}
internal void WorkerInitResponse(RpcEvent initEvent)
{
_startLatencyMetric?.Dispose();
_startLatencyMetric = null;
_workerChannelLogger.LogDebug("Received WorkerInitResponse. Worker process initialized");
_initMessage = initEvent.Message.WorkerInitResponse;
if (_initMessage.Result.IsFailure(out Exception exc))
{
HandleWorkerInitError(exc);
_workerInitTask.SetResult(false);
return;
}
_state = RpcWorkerChannelState.Initialized;
_workerCapabilities.UpdateCapabilities(_initMessage.Capabilities);
_workerInitTask.SetResult(true);
}
public async Task StartWorkerProcessAsync()
{
// To verify FunctionDispatcher transistions
await Task.Delay(TimeSpan.FromMilliseconds(500));
if (_throwOnProcessStartUp)
{
throw new ArgumentException("Process startup failed");
}
string workerVersion = Guid.NewGuid().ToString();
IDictionary <string, string> workerCapabilities = new Dictionary <string, string>()
{
{ "test", "testSupported" }
};
_state = RpcWorkerChannelState.Initialized;
}
public void SetupFunctionInvocationBuffers(IEnumerable <FunctionMetadata> functions)
{
_state = _state | RpcWorkerChannelState.InvocationBuffersInitialized;
_testLogger.LogInformation("SetupFunctionInvocationBuffers called");
}
