public void Create_creates_envelope_with_reference_to_original_event()
{
IKernelEvent @event = new DisplayedValueProduced(
123,
new SubmitCode("display(123)"));
var envelope = KernelEventEnvelope.Create(@event);
envelope.Event.Should().BeSameAs(@event);
}
public void Create_creates_envelope_of_the_correct_type()
{
IKernelEvent @event = new DisplayedValueProduced(
123,
new SubmitCode("display(123)"));
var envelope = KernelEventEnvelope.Create(@event);
envelope.Should().BeOfType <KernelEventEnvelope <DisplayedValueProduced> >();
}
public static CSharpKernel UseNugetDirective(this CSharpKernel kernel, INativeAssemblyLoadHelper helper = null)
{
var packageRefArg = new Argument <NugetPackageReference>((SymbolResult result, out NugetPackageReference reference) =>
NugetPackageReference.TryParse(result.Token.Value, out reference))
{
Name = "package"
};
var r = new Command("#r")
{
packageRefArg
};
var restoreContext = new PackageRestoreContext();
r.Handler = CommandHandler.Create <NugetPackageReference, KernelInvocationContext>(async(package, pipelineContext) =>
{
var addPackage = new AddNugetPackage(package);
addPackage.Handler = async context =>
{
var message = $"Installing package {package.PackageName}";
if (!string.IsNullOrWhiteSpace(package.PackageVersion))
{
message += $", version {package.PackageVersion}";
}
var key = message;
var displayed = new DisplayedValueProduced(message, context.Command, valueId: key);
context.Publish(displayed);
var installTask = restoreContext.AddPackage(package.PackageName, package.PackageVersion);
while (await Task.WhenAny(Task.Delay(1000), installTask) != installTask)
{
message += ".";
context.Publish(new DisplayedValueUpdated(message, key));
}
message += "done!";
context.Publish(new DisplayedValueUpdated(message, key));
var result = await installTask;
helper?.Configure(await restoreContext.OutputPath());
if (result.Succeeded)
{
foreach (var reference in result.NewReferences)
{
if (reference is PortableExecutableReference peRef)
{
helper?.Handle(peRef.FilePath);
}
}
kernel.AddMetadataReferences(result.NewReferences);
context.Publish(new DisplayedValueProduced($"Successfully added reference to package {package.PackageName}, version {result.InstalledVersion}",
context.Command));
context.Publish(new NuGetPackageAdded(addPackage, package));
var nugetPackageDirectory = new FileSystemDirectoryAccessor(await restoreContext.GetDirectoryForPackage(package.PackageName));
await context.HandlingKernel.SendAsync(new LoadExtensionsInDirectory(nugetPackageDirectory, result.References.Select(r => r.Display)));
}
else
{
context.Publish(new DisplayedValueProduced($"Failed to add reference to package {package.PackageName}", context.Command));
context.Publish(new DisplayedValueProduced(result.DetailedErrors, context.Command));
}
context.Complete();
};
await pipelineContext.HandlingKernel.SendAsync(addPackage);
});
kernel.AddDirective(r);
return(kernel);
}
public static CSharpKernel UseNugetDirective(
this CSharpKernel kernel,
Func <INativeAssemblyLoadHelper> getHelper = null)
{
var packageRefArg = new Argument <NugetPackageReference>((SymbolResult result, out NugetPackageReference reference) =>
NugetPackageReference.TryParse(result.Token.Value, out reference))
{
Name = "package"
};
var command = new Command("#r")
{
packageRefArg
};
var restoreContext = new PackageRestoreContext(kernel);
command.Handler = CommandHandler.Create <NugetPackageReference, KernelInvocationContext>(async(package, pipelineContext) =>
{
var addPackage = new AddNugetPackage(package);
addPackage.Handler = async context =>
{
var message = $"Installing package {package.PackageName}";
if (!string.IsNullOrWhiteSpace(package.PackageVersion))
{
message += $", version {package.PackageVersion}";
}
message += "...";
var key = message;
var displayed = new DisplayedValueProduced(message, context.Command, valueId: key);
context.Publish(displayed);
var addPackageTask = restoreContext.AddPackage(
package.PackageName,
package.PackageVersion,
package.RestoreSources);
while (await Task.WhenAny(Task.Delay(500), addPackageTask) != addPackageTask)
{
message += ".";
context.Publish(new DisplayedValueUpdated(message, key));
}
message += "done!";
context.Publish(new DisplayedValueUpdated(message, key));
var result = await addPackageTask;
var helper = getHelper?.Invoke();
if (helper != null)
{
kernel.RegisterForDisposal(helper);
}
if (result.Succeeded)
{
switch (result)
{
case AddNugetPackageResult packageResult:
var nativeLibraryProbingPaths = packageResult.NativeLibraryProbingPaths;
helper?.SetNativeLibraryProbingPaths(nativeLibraryProbingPaths);
var addedAssemblyPaths =
packageResult
.AddedReferences
.SelectMany(added => added.AssemblyPaths)
.ToArray();
if (helper != null)
{
foreach (var addedReference in packageResult.AddedReferences)
{
helper.Handle(addedReference);
}
}
kernel.AddScriptReferences(packageResult.AddedReferences);
context.Publish(
new DisplayedValueProduced($"Successfully added reference to package {package.PackageName}, version {packageResult.InstalledVersion}",
context.Command));
context.Publish(new NuGetPackageAdded(addPackage, package));
var resolvedNugetPackageReference = await restoreContext.GetResolvedNugetPackageReference(package.PackageName);
var nugetPackageDirectory = new FileSystemDirectoryAccessor(resolvedNugetPackageReference.PackageRoot);
await context.HandlingKernel.SendAsync(
new LoadExtensionsInDirectory(
nugetPackageDirectory,
addedAssemblyPaths));
break;
default:
break;
}
}
else
{
var errors = $"{string.Join(Environment.NewLine, result.Errors)}";
switch (result)
{
case AddNugetPackageResult _:
context.Publish(
new ErrorProduced(
$"Failed to add reference to package {package.PackageName}{Environment.NewLine}{errors}"));
break;
case AddNugetRestoreSourcesResult _:
context.Publish(
new ErrorProduced(
$"Failed to apply RestoreSources {package.RestoreSources}{Environment.NewLine}{errors}"));
break;
default:
break;
}
}
context.Complete();
};
await pipelineContext.HandlingKernel.SendAsync(addPackage);
});
kernel.AddDirective(command);
return(kernel);
}
public static CSharpKernel UseNugetDirective(
this CSharpKernel kernel,
Func <NativeAssemblyLoadHelper> getHelper = null)
{
var packageRefArg = new Argument <PackageReference>((SymbolResult result, out PackageReference reference) =>
PackageReference.TryParse(result.Token.Value, out reference))
{
Name = "package"
};
var command = new Command("#r")
{
packageRefArg
};
var restoreContext = new PackageRestoreContext();
command.Handler = CommandHandler.Create <PackageReference, KernelInvocationContext>(async(package, pipelineContext) =>
{
var addPackage = new AddPackage(package)
{
Handler = async context =>
{
var added =
await Task.FromResult(
restoreContext.AddPackagReference(
package.PackageName,
package.PackageVersion,
package.RestoreSources));
if (!added)
{
var errorMessage = $"{GenerateErrorMessage(package)}{Environment.NewLine}";
context.Publish(new ErrorProduced(errorMessage));
}
context.Complete();
}
};
await pipelineContext.HandlingKernel.SendAsync(addPackage);
});
kernel.AddDirective(command);
var restore = new Command("#!nuget-restore")
{
Handler = CommandHandler.Create(async(KernelInvocationContext pipelineContext) =>
{
var nugetRestoreDirective = new RestoreNugetDirective();
nugetRestoreDirective.Handler = async context =>
{
var messages = new Dictionary <string, string>();
foreach (var package in restoreContext.PackageReferences)
{
var key = InstallingPackageMessage(package);
if (key == null)
{
context.Publish(new ErrorProduced($"Invalid Package Id: '{package.PackageName}'{Environment.NewLine}"));
}
else
{
var message = key + "...";
var displayed = new DisplayedValueProduced(message, context.Command, null, valueId: key);
context.Publish(displayed);
messages.Add(key, message);
}
}
// Restore packages
var restorePackagesTask = restoreContext.Restore();
while (await Task.WhenAny(Task.Delay(500), restorePackagesTask) != restorePackagesTask)
{
foreach (var key in messages.Keys.ToArray())
{
var message = messages[key] + ".";
context.Publish(new DisplayedValueUpdated(message, key, null, null));
messages[key] = message;
}
}
var helper = kernel.NativeAssemblyLoadHelper;
var result = await restorePackagesTask;
if (result.Succeeded)
{
switch (result)
{
case PackageRestoreResult packageRestore:
var nativeLibraryProbingPaths = packageRestore.NativeLibraryProbingPaths;
helper?.SetNativeLibraryProbingPaths(nativeLibraryProbingPaths);
var addedAssemblyPaths =
packageRestore
.ResolvedReferences
.SelectMany(added => added.AssemblyPaths)
.Distinct()
.ToArray();
if (helper != null)
{
foreach (var addedReference in packageRestore.ResolvedReferences)
{
helper.Handle(addedReference);
}
}
kernel.AddScriptReferences(packageRestore.ResolvedReferences);
foreach (var resolvedReference in packageRestore.ResolvedReferences)
{
string message;
string key = InstallingPackageMessage(resolvedReference);
if (messages.TryGetValue(key, out message))
{
context.Publish(new DisplayedValueUpdated(message + " done!", key, null, null));
messages[key] = message;
}
context.Publish(new PackageAdded(new AddPackage(resolvedReference)));
// Load extensions
await context.HandlingKernel.SendAsync(
new LoadExtensionsInDirectory(
resolvedReference.PackageRoot,
addedAssemblyPaths));
}
break;
default:
break;
}
}
else
{
var errors = $"{string.Join(Environment.NewLine, result.Errors)}";
switch (result)
{
case PackageRestoreResult packageRestore:
foreach (var resolvedReference in packageRestore.ResolvedReferences)
{
if (string.IsNullOrEmpty(resolvedReference.PackageName))
{
context.Publish(new ErrorProduced($"Failed to apply RestoreSources {resolvedReference.RestoreSources}{Environment.NewLine}{errors}"));
}
else
{
context.Publish(new ErrorProduced($"Failed to add reference to package {resolvedReference.PackageName}{Environment.NewLine}{errors}"));
}
}
break;
default:
break;
}
}
// Events for finished
context.Complete();
};
await pipelineContext.HandlingKernel.SendAsync(nugetRestoreDirective);
})
};
kernel.AddDirective(restore);
return(kernel);
