public static async Task LoadFromAssembliesInDirectory(
this KernelExtensionLoader loader,
DirectoryInfo directory,
IKernel kernel,
KernelInvocationContext context,
IReadOnlyList <FileInfo> additionalDependencies = null)
{
if (directory.Exists)
{
context.Publish(new DisplayedValueProduced($"Loading kernel extensions in directory {directory.FullName}", context.Command));
var extensionDlls = directory.GetFiles("*.dll", SearchOption.AllDirectories);
foreach (var extensionDll in extensionDlls)
{
await loader.LoadFromAssembly(
extensionDll,
kernel,
context,
additionalDependencies);
}
context.Publish(new DisplayedValueProduced($"Loaded kernel extensions in directory {directory.FullName}", context.Command));
}
}
private async Task LoadFromAssembly(
FileInfo assemblyFile,
IKernel kernel,
KernelInvocationContext context)
{
if (assemblyFile == null)
{
throw new ArgumentNullException(nameof(assemblyFile));
}
if (kernel == null)
{
throw new ArgumentNullException(nameof(kernel));
}
if (!assemblyFile.Exists)
{
throw new ArgumentException($"File {assemblyFile.FullName} doesn't exist", nameof(assemblyFile));
}
bool loadExtensions;
lock (AssemblyLoadLock)
{
loadExtensions = LoadedAssemblies.Add(AssemblyName.GetAssemblyName(assemblyFile.FullName));
}
if (loadExtensions)
{
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyFile.FullName);
var extensionTypes = assembly
.ExportedTypes
.Where(t => t.CanBeInstantiated() && typeof(IKernelExtension).IsAssignableFrom(t))
.ToArray();
foreach (var extensionType in extensionTypes)
{
var extension = (IKernelExtension)Activator.CreateInstance(extensionType);
var display = Guid.NewGuid().ToString("N");
context.Publish(new DisplayedValueProduced(
$"Loading kernel extension {extensionType.Name} from assembly {assemblyFile.FullName}",
context.Command, valueId: display));
try
{
await extension.OnLoadAsync(kernel);
context.Publish(new DisplayedValueUpdated(
$"Loaded kernel extension {extensionType.Name} from assembly {assemblyFile.FullName}",
display, context.Command));
}
catch (Exception e)
{
context.Publish(new ErrorProduced(
$"Failure loading kernel extension {extensionType.Name} from assembly {assemblyFile.FullName}",
context.Command));
context.Fail(new KernelExtensionLoadException(e));
}
}
}
}
public async Task LoadFromAssembliesInDirectory(
DirectoryInfo directory,
IKernel kernel,
KernelInvocationContext context)
{
if (directory.Exists)
{
var displayId = Guid.NewGuid().ToString("N");
var extensionDlls = directory.GetFiles("*.dll", SearchOption.TopDirectoryOnly).ToList();
if (extensionDlls.Count > 0)
{
context.Publish(new DisplayedValueProduced(
$"Loading kernel extensions in directory {directory.FullName}", context.Command,
valueId: displayId));
foreach (var extensionDll in extensionDlls)
{
await LoadFromAssembly(
extensionDll,
kernel,
context);
}
context.Publish(new DisplayedValueUpdated(
$"Loaded kernel extensions in directory {directory.FullName}", displayId, context.Command));
}
}
}
public async Task <bool> LoadFromAssembly(
FileInfo assemblyFile,
IKernel kernel,
KernelInvocationContext context,
IEnumerable <FileInfo> additionalDependencies = null)
{
if (assemblyFile == null)
{
throw new ArgumentNullException(nameof(assemblyFile));
}
if (kernel == null)
{
throw new ArgumentNullException(nameof(kernel));
}
if (additionalDependencies != null)
{
foreach (var additionalDependency in additionalDependencies.Where(file => file.Exists))
{
AssemblyLoadContext.Default.LoadFromAssemblyPath(additionalDependency.FullName);
}
}
var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(assemblyFile.FullName);
var extensionTypes = assembly
.ExportedTypes
.Where(t => t.CanBeInstantiated() && typeof(IKernelExtension).IsAssignableFrom(t))
.ToArray();
foreach (var extensionType in extensionTypes)
{
var extension = (IKernelExtension)Activator.CreateInstance(extensionType);
try
{
context.Publish(new DisplayedValueProduced($"Loading kernel extension {extension} from assembly {assemblyFile.FullName}", context.Command));
await extension.OnLoadAsync(kernel);
context.Publish(new DisplayedValueProduced($"Loaded kernel extension {extension} from assembly {assemblyFile.FullName}", context.Command));
context.Publish(new ExtensionLoaded(assemblyFile));
}
catch (Exception e)
{
context.Publish(new KernelExtensionLoadException($"Extension {assemblyFile.FullName} threw exception {e.Message}"));
}
}
return(extensionTypes.Length > 0);
}
public static DisplayedValue DisplayAs(
this KernelInvocationContext context,
string value,
string mimeType)
{
if (string.IsNullOrWhiteSpace(mimeType))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(mimeType));
}
var displayId = Guid.NewGuid().ToString();
var formattedValue = new FormattedValue(
mimeType,
value);
context.Publish(
new DisplayedValueProduced(
value,
context?.Command,
new[] { formattedValue },
displayId));
var displayedValue = new DisplayedValue(displayId, mimeType, context);
return(displayedValue);
}
public static DisplayedValue DisplayAs(
this KernelInvocationContext context,
string value,
string mimeType, params string[] additionalMimeTypes)
{
if (string.IsNullOrWhiteSpace(mimeType))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(mimeType));
}
var displayId = Guid.NewGuid().ToString();
var mimeTypes = new HashSet <string>(additionalMimeTypes ?? Array.Empty <string>())
{
mimeType
};
var formattedValues = mimeTypes.Select(mime => new FormattedValue(
mime,
value));
context.Publish(
new DisplayedValueProduced(
value,
context?.Command,
formattedValues.ToArray(),
displayId));
var displayedValue = new DisplayedValue(displayId, mimeType, context);
return(displayedValue);
}
public static DisplayedValue Display(
this KernelInvocationContext context,
object value,
string mimeType = null)
{
var displayId = Guid.NewGuid().ToString();
mimeType ??= Formatter.PreferredMimeTypeFor(value.GetType());
var formattedValue = new FormattedValue(
mimeType,
value.ToDisplayString(mimeType));
context.Publish(
new DisplayedValueProduced(
value,
context?.Command,
new[] { formattedValue },
displayId));
var displayedValue = new DisplayedValue(displayId, mimeType, context);
return(displayedValue);
}
public void Publish(IKernelEvent @event)
{
if (_parentContext != null)
{
_parentContext.Publish(@event);
}
else
{
_events.OnNext(@event);
}
}
public void Update(object updatedValue)
{
var formatted = new FormattedValue(
_mimeType,
updatedValue.ToDisplayString(_mimeType));
if (KernelInvocationContext.Current?.Command is SubmitCode)
{
_context = KernelInvocationContext.Current;
}
_context.Publish(new DisplayedValueUpdated(updatedValue, _displayId, _context.Command, new[] { formatted }));
}
public void Update(object updatedValue)
{
var formattedValues = MimeTypes.Select(mimeType => new FormattedValue(
mimeType,
updatedValue.ToDisplayString(mimeType))).ToArray();
if (KernelInvocationContext.Current?.Command is SubmitCode)
{
_context = KernelInvocationContext.Current;
}
_context.Publish(new DisplayedValueUpdated(updatedValue, _displayId, _context.Command, formattedValues));
}
public static void DisplayStandardError(
this KernelInvocationContext context,
string error,
KernelCommand command = null)
{
var formattedValues = new List <FormattedValue>
{
new(PlainTextFormatter.MimeType, error)
};
context.Publish(
new StandardErrorValueProduced(
command ?? context.Command,
formattedValues));
}
public static void PublishStandardError(
this KernelInvocationContext context,
string error,
IKernelCommand command)
{
var formattedValues = new List <FormattedValue>
{
new FormattedValue(
PlainTextFormatter.MimeType, error)
};
context.Publish(
new StandardErrorValueProduced(
error,
command,
formattedValues));
}
public static void DisplayStandardOut(
this KernelInvocationContext context,
string output,
KernelCommand command = null)
{
var formattedValues = new List <FormattedValue>
{
new FormattedValue(
PlainTextFormatter.MimeType, output)
};
context.Publish(
new StandardOutputValueProduced(
output,
command ?? context.Command,
formattedValues));
}
public async Task SendAsync(
IKernelCommand command,
KernelInvocationContext context)
{
EnsureMiddlewarePipelineIsInitialized();
try
{
await _pipeline(command, context, (_, __) => Task.CompletedTask);
}
catch (Exception exception)
{
context.Publish(
new CommandFailed(
exception,
command));
}
}
public static DisplayedValue Display(
this KernelInvocationContext context,
object value,
string mimeType = null)
{
var displayId = Guid.NewGuid().ToString();
var formattedValues = FormattedValue.FromObject(value, mimeType);
context.Publish(
new DisplayedValueProduced(
value,
context?.Command,
formattedValues,
displayId));
var displayedValue = new DisplayedValue(displayId, mimeType ?? formattedValues.FirstOrDefault()?.MimeType, context);
return(displayedValue);
}
public static DisplayedValue Display(
this KernelInvocationContext context,
object value,
params string[] mimeTypes)
{
var displayId = Guid.NewGuid().ToString();
var formattedValues = FormattedValue.FromObject(value, mimeTypes);
context.Publish(
new DisplayedValueProduced(
value,
context?.Command,
formattedValues,
displayId));
var displayedValue = new DisplayedValue(displayId, formattedValues.Select(fv => fv.MimeType).ToArray(), context);
return(displayedValue);
}
public static Task <DisplayedValue> DisplayAsync(
this KernelInvocationContext context,
object value,
string mimeType = null)
{
var displayId = Kernel.DisplayIdGenerator?.Invoke() ??
Guid.NewGuid().ToString();
mimeType ??= Formatter.PreferredMimeTypeFor(value.GetType());
var formattedValue = new FormattedValue(
mimeType,
value.ToDisplayString(mimeType));
context.Publish(
new DisplayedValueProduced(
value,
context?.Command,
new[] { formattedValue },
displayId));
return(Task.FromResult(new DisplayedValue(displayId, mimeType, context)));
}
