internal void PublishRpcChannelReadyEvent(RpcEvent initEvent)
{
_startLatencyMetric?.Dispose();
_startLatencyMetric = null;
if (_disposing)
{
// do not publish ready events when disposing
return;
}
_initMessage = initEvent.Message.WorkerInitResponse;
if (_initMessage.Result.IsFailure(out Exception exc))
{
HandleWorkerError(exc);
return;
}
_state = LanguageWorkerChannelState.Initialized;
if (_isWebHostChannel)
{
RpcWebHostChannelReadyEvent readyEvent = new RpcWebHostChannelReadyEvent(_workerId, _workerConfig.Language, this, _initMessage.WorkerVersion, _initMessage.Capabilities);
_eventManager.Publish(readyEvent);
}
else
{
RpcJobHostChannelReadyEvent readyEvent = new RpcJobHostChannelReadyEvent(_workerId, _workerConfig.Language, this, _initMessage.WorkerVersion, _initMessage.Capabilities);
_eventManager.Publish(readyEvent);
}
}
public Task StartWorkerProcessAsync()
{
_startSubscription = _inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.StartStream)
.Timeout(TimeSpan.FromSeconds(LanguageWorkerConstants.ProcessStartTimeoutSeconds))
.Take(1)
.Subscribe(SendWorkerInitRequest, HandleWorkerError);
var workerContext = new WorkerContext()
{
RequestId = Guid.NewGuid().ToString(),
MaxMessageLength = LanguageWorkerConstants.DefaultMaxMessageLengthBytes,
WorkerId = _workerId,
Arguments = _workerConfig.Arguments,
WorkingDirectory = _rootScriptPath,
ServerUri = _serverUri,
};
_process = _processFactory.CreateWorkerProcess(workerContext);
StartProcess();
_processRegistry?.Register(_process);
_state = LanguageWorkerChannelState.Initializing;
return(Task.CompletedTask);
}
public Task StartWorkerProcessAsync()
{
_startSubscription = _inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.StartStream)
.Timeout(TimeSpan.FromSeconds(LanguageWorkerConstants.ProcessStartTimeoutSeconds))
.Take(1)
.Subscribe(SendWorkerInitRequest, HandleWorkerChannelError);
_languageWorkerProcess.StartProcess();
_state = LanguageWorkerChannelState.Initializing;
return(Task.CompletedTask);
}
public async Task StartWorkerProcessAsync()
{
// To verify FunctionDispatcher transistions
await Task.Delay(TimeSpan.FromMilliseconds(100));
string workerVersion = Guid.NewGuid().ToString();
IDictionary <string, string> workerCapabilities = new Dictionary <string, string>()
{
{ "test", "testSupported" }
};
_state = LanguageWorkerChannelState.Initialized;
}
public async Task StartWorkerProcessAsync()
{
_startSubscription = _inboundWorkerEvents.Where(msg => msg.MessageType == MsgType.StartStream)
.Timeout(TimeSpan.FromSeconds(LanguageWorkerConstants.ProcessStartTimeoutSeconds))
.Take(1)
.Subscribe(SendWorkerInitRequest, HandleWorkerStartStreamError);
_workerChannelLogger.LogDebug("Initiating Worker Process start up");
await _languageWorkerProcess.StartProcessAsync();
_state = LanguageWorkerChannelState.Initializing;
await _workerInitTask.Task;
}
internal LanguageWorkerChannel(
string workerId,
string rootScriptPath,
IScriptEventManager eventManager,
IWorkerProcessFactory processFactory,
IProcessRegistry processRegistry,
WorkerConfig workerConfig,
Uri serverUri,
ILoggerFactory loggerFactory,
IMetricsLogger metricsLogger,
int attemptCount,
ILanguageWorkerConsoleLogSource consoleLogSource,
bool isWebHostChannel = false,
IOptions <ManagedDependencyOptions> managedDependencyOptions = null)
{
_workerId = workerId;
_rootScriptPath = rootScriptPath;
_eventManager = eventManager;
_processFactory = processFactory;
_processRegistry = processRegistry;
_workerConfig = workerConfig;
_serverUri = serverUri;
_workerChannelLogger = loggerFactory.CreateLogger($"Worker.{workerConfig.Language}.{_workerId}");
_consoleLogSource = consoleLogSource;
_isWebHostChannel = isWebHostChannel;
_inboundWorkerEvents = _eventManager.OfType <InboundEvent>()
.Where(msg => msg.WorkerId == _workerId);
_eventSubscriptions.Add(_inboundWorkerEvents
.Where(msg => msg.MessageType == MsgType.RpcLog)
.Subscribe(Log));
_eventSubscriptions.Add(_eventManager.OfType <FileEvent>()
.Where(msg => Config.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.Language, attemptCount));
_managedDependencyOptions = managedDependencyOptions;
_state = LanguageWorkerChannelState.Default;
}
internal LanguageWorkerChannel(
string workerId,
string rootScriptPath,
IScriptEventManager eventManager,
WorkerConfig workerConfig,
ILanguageWorkerProcess languageWorkerProcess,
ILogger logger,
IMetricsLogger metricsLogger,
int attemptCount,
IOptions <ManagedDependencyOptions> managedDependencyOptions = null)
{
_workerId = workerId;
_rootScriptPath = rootScriptPath;
_eventManager = eventManager;
_workerConfig = workerConfig;
_runtime = workerConfig.Language;
_languageWorkerProcess = languageWorkerProcess;
_workerChannelLogger = logger;
_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.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.Language, attemptCount));
_managedDependencyOptions = managedDependencyOptions;
_state = LanguageWorkerChannelState.Default;
}
internal void WorkerInitResponse(RpcEvent initEvent)
{
_startLatencyMetric?.Dispose();
_startLatencyMetric = null;
_workerChannelLogger.LogDebug("Received WorkerInitResponse");
_initMessage = initEvent.Message.WorkerInitResponse;
if (_initMessage.Result.IsFailure(out Exception exc))
{
HandleWorkerChannelError(exc);
_workerInitTask.SetResult(false);
return;
}
_state = LanguageWorkerChannelState.Initialized;
_workerCapabilities.UpdateCapabilities(_initMessage.Capabilities);
_workerInitTask.SetResult(true);
}
public Task StartWorkerProcessAsync()
{
// To verify FunctionDispatcher transistions
Task.Delay(TimeSpan.FromMilliseconds(100));
string workerVersion = Guid.NewGuid().ToString();
IDictionary <string, string> workerCapabilities = new Dictionary <string, string>()
{
{ "test", "testSupported" }
};
if (_isWebhostChannel)
{
RpcWebHostChannelReadyEvent readyEvent = new RpcWebHostChannelReadyEvent(_workerId, _runtime, this, workerVersion, workerCapabilities);
_eventManager.Publish(readyEvent);
}
else
{
RpcJobHostChannelReadyEvent readyEvent = new RpcJobHostChannelReadyEvent(_workerId, _runtime, this, workerVersion, workerCapabilities);
_eventManager.Publish(readyEvent);
}
_state = LanguageWorkerChannelState.Initialized;
return(Task.CompletedTask);
}
