/// <nodoc />
public async Task <Possible <IPlugin> > CreatePluginAsync(PluginCreationArgument pluginCreationArgument)
{
PluginResponseResult <bool> pluginCreationResult;
try
{
var plugin = CreatePlugin(pluginCreationArgument);
pluginCreationResult = await plugin.StartAsync();
if (pluginCreationResult.Succeeded)
{
plugin.Status = PluginStatus.Running;
return(new Possible <IPlugin>(plugin));
}
else
{
plugin.PluginProcess.Kill();
return(pluginCreationResult.Failure);
}
}
catch (Exception e)
{
return(new Failure <string>($"Exception happens when start plugin at {pluginCreationArgument.PluginPath}, Exception: {e}"));
}
}
/// <nodoc />
private async Task <Possible <IPlugin> > CreatePluginAsync(PluginCreationArgument pluinCreationArgument)
{
try
{
if (!File.Exists(pluinCreationArgument.PluginPath) && pluinCreationArgument.RunInSeparateProcess)
{
Tracing.Logger.Log.PluginManagerLogMessage(m_loggingContext, $"Can't Load plugin because {pluinCreationArgument.PluginPath} doesn't exist");
new Failure <IPlugin>(null);
}
var sw = Stopwatch.StartNew();
var result = await PluginFactory.Instance.CreatePluginAsync(pluinCreationArgument);
Interlocked.Add(ref m_pluginLoadingTime, sw.ElapsedMilliseconds);
if (result.Succeeded)
{
Interlocked.Increment(ref m_pluginLoadedSuccessfulCount);
var plugin = result.Result;
Tracing.Logger.Log.PluginManagerLoadingPlugin(m_loggingContext, plugin.FilePath, plugin.Name, plugin.Id);
}
else
{
Interlocked.Increment(ref m_pluginLoadedFailureCount);
Tracing.Logger.Log.PluginManagerLogMessage(m_loggingContext, $"Failed to load {pluinCreationArgument.PluginPath} because {result.Failure.Describe()}");
}
return(result.Succeeded ? new Possible <IPlugin>(result.Result) : new Failure <IPlugin>(null));
}
catch (Exception e)
{
return(new Failure <string>($"Can't start plugin with exception {e}"));
}
}
/// <nodoc />
public async Task <Possible <IPlugin> > GetOrCreateAsync(PluginCreationArgument startPluginArguments)
{
var creationResult = await m_plugins.GetOrAdd(startPluginArguments.PluginPath, path => CreatePluginAsync(startPluginArguments));
if (!creationResult.Succeeded)
{
m_plugins.TryRemove(startPluginArguments.PluginPath, out _);
return(creationResult);
}
var plugin = creationResult.Result;
Possible <List <PluginMessageType> > messageType = await GetSupportedMessageTypeAsync(plugin);
if (messageType.Succeeded)
{
// Register the plugin in handlers only when response of supportedMessageType is received
foreach (var pluginMessageType in messageType.Result)
{
IPlugin alreadyRegisteredPlugin = null;
if (!m_pluginHandlers.TryGet(pluginMessageType, out alreadyRegisteredPlugin))
{
m_pluginHandlers.TryAdd(pluginMessageType, plugin);
}
else
{
Tracing.Logger.Log.PluginManagerErrorMessage(m_loggingContext, $"Two plugins({plugin.FilePath} and {alreadyRegisteredPlugin.FilePath}) can hanlde {pluginMessageType} that we don't suuport this scenario");
}
}
Tracing.Logger.Log.PluginManagerLogMessage(m_loggingContext, $"Supported Messagey Type for {plugin.Name} is {string.Join(",", messageType.Result)}");
plugin.SupportedMessageType = messageType.Result;
}
else
{
Tracing.Logger.Log.PluginManagerLogMessage(m_loggingContext, $"Can't get supported message tyep for {plugin.Name}");
}
return(creationResult);
}
/// <nodoc />
public IPlugin CreatePlugin(PluginCreationArgument pluginCreationArgument)
{
return(pluginCreationArgument.RunInSeparateProcess ?
m_pluginRunInProcessCreationFunc.Invoke(pluginCreationArgument) :
m_pluginRunInThreadCreationFunc.Invoke(pluginCreationArgument));
}
