protected FunctionIndexBasedTest(AssemblyMefCatalogFixture catalog)
{
_exportProvider = catalog.CreateExportProvider();
_editorShell = _exportProvider.GetExportedValue <IEditorShell>();
_packageIndex = _exportProvider.GetExportedValue <IPackageIndex>();
_functionIndex = _exportProvider.GetExportedValue <IFunctionIndex>();
}
public async Task BuildIndexAsync(IPackageIndex packageIndex = null)
{
packageIndex = packageIndex ?? _coreShell.ExportProvider.GetExportedValue <IPackageIndex>();
var ready = await _buildIndexLock.WaitAsync();
try {
if (!ready)
{
// First populate index for popular packages that are commonly preloaded
foreach (var pi in packageIndex.Packages)
{
foreach (var f in pi.Functions)
{
// Avoid duplicates. Packages are normally populated from base (intrinsic)
// to user so we don't want new packages to override base function information
if (!_functionToPackageMap.ContainsKey(f.Name))
{
_functionToPackageMap[f.Name] = pi.Name;
}
}
}
}
} finally {
_buildIndexLock.Release();
}
}
/// <summary>
/// Builds function index
/// </summary>
/// <param name="packageIndex">Package index, if available. If not available,
/// index builder will attempt to obtain it from the service container</param>
public async Task BuildIndexAsync(IPackageIndex packageIndex = null, CancellationToken ct = default(CancellationToken))
{
packageIndex = packageIndex ?? Services.GetService <IPackageIndex>();
var lockToken = await _buildIndexLock.WaitAsync(ct);
try {
if (!lockToken.IsSet)
{
// First populate index for popular packages that are commonly preloaded
foreach (var pi in packageIndex.Packages)
{
if (ct.IsCancellationRequested)
{
break;
}
foreach (var f in pi.Functions)
{
if (ct.IsCancellationRequested)
{
break;
}
RegisterFunction(f.Name, pi.Name, f.IsInternal);
}
}
}
} finally {
lockToken.Set();
}
}
public static void Initialize(IPackageIndex packageIndex, IRToolsSettings settings, IREditorSettings editorSettings, ITelemetryService service = null)
{
if (Current == null)
{
Current = new RtvsTelemetry(packageIndex, settings, editorSettings, service);
}
}
public FunctionInfoTest(IExportProvider exportProvider)
{
_exportProvider = exportProvider;
_workflow = UIThreadHelper.Instance.Invoke(() => _exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate());
_packageIndex = _exportProvider.GetExportedValue <IPackageIndex>();
_functionIndex = _exportProvider.GetExportedValue <IFunctionIndex>();
}
public static void Initialize(IPackageIndex packageIndex, ITelemetryService service = null)
{
if (Current == null)
{
Current = new RtvsTelemetry(packageIndex, service);
}
}
public FunctionInfoTest(RSupportMefCatalogFixture catalog)
{
_exportProvider = catalog.CreateExportProvider();
UIThreadHelper.Instance.Invoke(() => _exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate());
_packageIndex = _exportProvider.GetExportedValue <IPackageIndex>();
_functionIndex = _exportProvider.GetExportedValue <IFunctionIndex>();
}
public FunctionInfoTest(IServiceContainer services)
{
_shell = services.GetService <ICoreShell>();
_workflow = UIThreadHelper.Instance.Invoke(() => _shell.GetService <IRInteractiveWorkflowProvider>().GetOrCreate());
_packageIndex = _shell.GetService <IPackageIndex>();
_functionIndex = _shell.GetService <IFunctionIndex>();
}
public RtvsTelemetry(IPackageIndex packageIndex, IRToolsSettings settings, IREditorSettings editorSettings, ITelemetryService service = null)
{
_packageIndex = packageIndex;
_settings = settings;
_editorSettings = editorSettings;
TelemetryService = service ?? VsAppShell.Current.GetService <ITelemetryService>();
}
public RtvsTelemetry(IPackageIndex packageIndex, IRSettings settings, IREditorSettings editorSettings, ITelemetryService telemetryService = null, ToolWindowTracker toolWindowTracker = null)
{
_packageIndex = packageIndex;
_settings = settings;
_editorSettings = editorSettings;
TelemetryService = telemetryService;
_toolWindowTracker = toolWindowTracker;
}
public static void Initialize(IPackageIndex packageIndex, IServiceContainer services)
{
if (Current == null)
{
var settings = services.GetService <IRSettings>();
var editorSettings = services.GetService <IREditorSettings>();
var telemetryService = services.GetService <ITelemetryService>();
Current = new RtvsTelemetry(packageIndex, settings, editorSettings, telemetryService, new ToolWindowTracker(services));
}
}
public static async Task DisposeAsync(this IPackageIndex packageIndex, ICoreShell coreShell)
{
var sessionProvider = coreShell.GetService <IRInteractiveWorkflowProvider>().GetOrCreate().RSessions;
if (sessionProvider != null)
{
await sessionProvider.RemoveBrokerAsync();
}
packageIndex?.Dispose();
}
private bool TryExtractIndex(IPackage package, out IPackageIndex packageIndex)
{
packageIndex = null;
if (package.Index == null)
{
return(false);
}
packageIndex = IndexExtractor.ExtractIndex(package);
return(packageIndex != null);
}
public static async Task DisposeAsync(this IPackageIndex packageIndex, IExportProvider exportProvider)
{
IRSessionProvider sessionProvider = exportProvider.GetExportedValue <IRSessionProvider>();
if (sessionProvider != null)
{
await Task.WhenAll(sessionProvider.GetSessions().Select(s => s.StopHostAsync()));
}
packageIndex?.Dispose();
}
public static async Task DisposeAsync(this IPackageIndex packageIndex, IExportProvider exportProvider)
{
var sessionProvider = exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate().RSessions;
if (sessionProvider != null)
{
await Task.WhenAll(sessionProvider.GetSessions().Select(s => s.StopHostAsync()));
}
packageIndex?.Dispose();
}
public TelemetryTest() {
_packageIndex = Substitute.For<IPackageIndex>();
var package1 = Substitute.For<IPackageInfo>();
package1.Name.Returns("base");
var package2 = Substitute.For<IPackageInfo>();
package1.Name.Returns("user_package");
_packageIndex.Packages.Returns(new IPackageInfo[] { package1, package2 });
}
public static async Task DisposeAsync(this IPackageIndex packageIndex, IExportProvider exportProvider)
{
var sessionProvider = exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate().RSessions;
if (sessionProvider != null)
{
await sessionProvider.RemoveBrokerAsync();
}
packageIndex?.Dispose();
}
public PackageFunctionCompletionProvider(IServiceContainer serviceContainer)
{
_session = serviceContainer.GetService <IIntellisenseRSession>();
_snippetInformationSource = serviceContainer.GetService <ISnippetInformationSourceProvider>();
_packageIndex = serviceContainer.GetService <IPackageIndex>();
_functionIndex = serviceContainer.GetService <IFunctionIndex>();
var imageService = serviceContainer.GetService <IImageService>();
_functionGlyph = imageService.GetImage(ImageType.Method);
_constantGlyph = imageService.GetImage(ImageType.Constant);
}
public TelemetryTest()
{
_packageIndex = Substitute.For <IPackageIndex>();
var package1 = Substitute.For <IPackageInfo>();
package1.Name.Returns("base");
var package2 = Substitute.For <IPackageInfo>();
package1.Name.Returns("user_package");
_packageIndex.Packages.Returns(new IPackageInfo[] { package1, package2 });
}
public PackageFunctionCompletionProvider(
ILoadedPackagesProvider loadedPackagesProvider,
[Import(AllowDefault = true)] ISnippetInformationSourceProvider snippetInformationSource,
IPackageIndex packageIndex,
IFunctionIndex functionIndex,
ICoreShell shell)
{
_loadedPackagesProvider = loadedPackagesProvider;
_snippetInformationSource = snippetInformationSource;
_shell = shell;
_packageIndex = packageIndex;
_functionIndex = functionIndex;
}
public PackageFunctionCompletionProvider(
ILoadedPackagesProvider loadedPackagesProvider,
[Import(AllowDefault = true)] ISnippetInformationSourceProvider snippetInformationSource,
IPackageIndex packageIndex,
IFunctionIndex functionIndex,
IGlyphService glyphService) {
_loadedPackagesProvider = loadedPackagesProvider;
_snippetInformationSource = snippetInformationSource;
_packageIndex = packageIndex;
_functionIndex = functionIndex;
_functionGlyph = glyphService.GetGlyphThreadSafe(StandardGlyphGroup.GlyphGroupMethod, StandardGlyphItem.GlyphItemPublic);
_constantGlyph = glyphService.GetGlyphThreadSafe(StandardGlyphGroup.GlyphGroupConstant, StandardGlyphItem.GlyphItemPublic);
}
private async Task ConnectAsync(CancellationToken ct)
{
var provider = _services.GetService <IRInteractiveWorkflowProvider>();
_workflow = provider.GetOrCreate();
_ui = _services.GetService <IHostUIService>();
_ui.SetLogLevel(MessageType.Info);
var e = GetREngine();
if (e == null)
{
return;
}
var log = _services.Log();
var info = BrokerConnectionInfo.Create("(local)", e.InstallPath, e.Architecture, string.Empty);
var start = DateTime.Now;
_ui.LogMessageAsync($"Starting R Process with {e.InstallPath}...", MessageType.Info).DoNotWait();
try {
if (await _workflow.RSessions.TrySwitchBrokerAsync("(local)", info, ct))
{
try {
await _workflow.RSession.StartHostAsync(new RHostStartupInfo(), new RSessionCallback(), _services.UI(), Debugger.IsAttached? 1000000 : 20000, ct);
} catch (Exception ex) {
_ui.ShowMessageAsync($"Unable to start Microsoft.R.Host process. Exception: {ex.Message}", MessageType.Error).DoNotWait();
return;
}
// Start package building
_ui.LogMessageAsync($"complete in {FormatElapsed(DateTime.Now - start)}", MessageType.Info).DoNotWait();
start = DateTime.Now;
_ui.LogMessageAsync("Building IntelliSense index...", MessageType.Info).DoNotWait();
_packageIndex = _services.GetService <IPackageIndex>();
_packageIndex.BuildIndexAsync(ct).ContinueWith(t => {
_ui.LogMessageAsync($"complete in {FormatElapsed(DateTime.Now - start)}", MessageType.Info).DoNotWait();
}, ct, TaskContinuationOptions.None, TaskScheduler.Default).DoNotWait();
}
else
{
_ui.ShowMessageAsync($"Unable to connect to broker.", MessageType.Error).DoNotWait();
}
} catch (Exception ex) {
_ui.ShowMessageAsync($"Unable to connect to broker. Exception: {ex.Message}", MessageType.Error).DoNotWait();
}
}
public TelemetryTest()
{
_packageIndex = Substitute.For <IPackageIndex>();
var package1 = Substitute.For <IPackageInfo>();
package1.Name.Returns("base");
var package2 = Substitute.For <IPackageInfo>();
package1.Name.Returns("user_package");
_packageIndex.Packages.Returns(new IPackageInfo[] { package1, package2 });
_settings = new REditorSettings(new TestSettingsStorage());
}
public PackageFunctionCompletionProvider(
ILoadedPackagesProvider loadedPackagesProvider,
[Import(AllowDefault = true)] ISnippetInformationSourceProvider snippetInformationSource,
IPackageIndex packageIndex,
IFunctionIndex functionIndex,
IGlyphService glyphService)
{
_loadedPackagesProvider = loadedPackagesProvider;
_snippetInformationSource = snippetInformationSource;
_packageIndex = packageIndex;
_functionIndex = functionIndex;
_functionGlyph = glyphService.GetGlyphThreadSafe(StandardGlyphGroup.GlyphGroupMethod, StandardGlyphItem.GlyphItemPublic);
_constantGlyph = glyphService.GetGlyphThreadSafe(StandardGlyphGroup.GlyphGroupConstant, StandardGlyphItem.GlyphItemPublic);
}
private async Task ConnectAsync(CancellationToken ct)
{
var provider = _services.GetService <IRInteractiveWorkflowProvider>();
_workflow = provider.GetOrCreate();
_ui = _services.GetService <IUIService>();
_ui.SetLogLevel(MessageType.Info);
var e = GetREngine();
if (e == null)
{
return;
}
var log = _services.Log();
var info = BrokerConnectionInfo.Create(_services.Security(), "VSCR", e.InstallPath, string.Empty, false);
var start = DateTime.Now;
var message = $"Starting R Process with {e.InstallPath}...";
_ui.LogMessageAsync(message, MessageType.Info).DoNotWait();
log.Write(LogVerbosity.Normal, MessageCategory.General, $"Switching local broker to {e.InstallPath}");
if (await _workflow.RSessions.TrySwitchBrokerAsync("VSCR", info, ct))
{
try {
await _workflow.RSession.StartHostAsync(new RHostStartupInfo(), new RSessionCallback(), Debugger.IsAttached? 100000 : 20000, ct);
} catch (Exception ex) {
_ui.ShowMessageAsync($"Unable to start R process. Exception: {ex.Message}", MessageType.Error).DoNotWait();
return;
}
// Start package building
_ui.LogMessageAsync($"complete in {FormatElapsed(DateTime.Now - start)}", MessageType.Info).DoNotWait();
start = DateTime.Now;
_ui.LogMessageAsync("Building IntelliSense index...", MessageType.Info).DoNotWait();
_packageIndex = _services.GetService <IPackageIndex>();
_packageIndex.BuildIndexAsync(ct).ContinueWith(t => {
_ui.LogMessageAsync($"complete in {FormatElapsed(DateTime.Now - start)}", MessageType.Info).DoNotWait();
}, ct, TaskContinuationOptions.None, TaskScheduler.Default).DoNotWait();
}
else
{
_ui.ShowMessageAsync("Unable to start R process", MessageType.Error).DoNotWait();
}
}
public async Task BuildIndexAsync(IPackageIndex packageIndex = null) {
packageIndex = packageIndex ?? _coreShell.ExportProvider.GetExportedValue<IPackageIndex>();
var lockToken = await _buildIndexLock.WaitAsync();
try {
if (!lockToken.IsSet) {
// First populate index for popular packages that are commonly preloaded
foreach (var pi in packageIndex.Packages) {
foreach (var f in pi.Functions) {
RegisterFunction(f.Name, pi.Name);
}
}
}
} finally {
lockToken.Set();
}
}
public PackageFunctionCompletionProvider(
IIntellisenseRSession session,
[Import(AllowDefault = true)] ISnippetInformationSourceProvider snippetInformationSource,
IPackageIndex packageIndex,
IFunctionIndex functionIndex,
ICoreShell coreShell)
{
_session = session;
_snippetInformationSource = snippetInformationSource;
_packageIndex = packageIndex;
_functionIndex = functionIndex;
var imageService = coreShell.GetService <IImageService>();
_functionGlyph = imageService.GetImage(ImageType.Method) as ImageSource;
_constantGlyph = imageService.GetImage(ImageType.Constant) as ImageSource;;
}
/// <summary>
/// Builds function index
/// </summary>
/// <param name="packageIndex">Package index, if available. If not available,
/// index builder will attempt to obtain it from the service container</param>
public async Task BuildIndexAsync(IPackageIndex packageIndex = null)
{
packageIndex = packageIndex ?? Services.GetService <IPackageIndex>();
var lockToken = await _buildIndexLock.WaitAsync();
try {
if (!lockToken.IsSet)
{
// First populate index for popular packages that are commonly preloaded
foreach (var pi in packageIndex.Packages)
{
foreach (var f in pi.Functions)
{
RegisterFunction(f.Name, pi.Name);
}
}
}
} finally {
lockToken.Set();
}
}
public PackagesCompletionProvider(IPackageIndex packageIndex, IGlyphService glyphService) {
_packageIndex = packageIndex;
_glyph = glyphService.GetGlyphThreadSafe(StandardGlyphGroup.GlyphLibrary, StandardGlyphItem.GlyphItemPublic);
}
public FunctionInfoTest(RSupportMefCatalogFixture catalog) {
_exportProvider = catalog.CreateExportProvider();
_workflow = UIThreadHelper.Instance.Invoke(() => _exportProvider.GetExportedValue<IRInteractiveWorkflowProvider>().GetOrCreate());
_packageIndex = _exportProvider.GetExportedValue<IPackageIndex>();
_functionIndex = _exportProvider.GetExportedValue<IFunctionIndex>();
}
private void BuildFunctionIndex()
{
_packageIndex = VsAppShell.Current.ExportProvider.GetExportedValue <IPackageIndex>();
_packageIndex.BuildIndexAsync().DoNotWait();
}
private void BuildFunctionIndex() => _packageIndex = Services.GetService <IPackageIndex>();
public static Task InitializeAsync(this IPackageIndex packageIndex, IFunctionIndex functionIndex)
{
RToolsSettings.Current = new TestRToolsSettings();
return(packageIndex.BuildIndexAsync());
}
public static void Initialize(IPackageIndex packageIndex, IRSettings settings, ITelemetryService service = null) {
if (Current == null) {
Current = new RtvsTelemetry(packageIndex, settings, service);
}
}
public PackagesCompletionProvider(IPackageIndex packageIndex, IImageService imageService)
{
_packageIndex = packageIndex;
_glyph = imageService.GetImage(ImageType.Library) as ImageSource;
}
/// <summary>
/// Performs a cleanup and consistency check for the package store.
/// </summary>
/// <param name="packageIndex">Interface used to ensure that the package index is correct.</param>
/// <exception cref="ArgumentNullException"><paramref name="packageIndex"/> is null.</exception>
public override void Clean(IPackageIndex packageIndex)
{
if (packageIndex == null)
{
throw new ArgumentNullException("packageIndex");
}
InitPackageStore();
_logger.Debug("Clean('" + packageIndex + "') called");
if (_fileSystemOperations.DirectoryExists(RootPath))
{
_logger.DebugFormat("Enumerating directories in {0}...", RootPath);
IEnumerable <string> packageDirectories;
try
{
packageDirectories = _fileSystemOperations.EnumerateDirectories(RootPath);
}
catch (Exception ex)
{
_logger.Error(string.Format("Could not access RootPath '{0}'. Skipping feed cleanup.", RootPath), ex);
return;
}
foreach (var packageDirectory in packageDirectories)
{
_logger.DebugFormat("Enumerating all nupkg files in packageDirectory '{0}'", packageDirectory);
bool any = false;
var packageFileNames = _fileSystemOperations.EnumerateFiles(packageDirectory, "*.nupkg");
foreach (var fileName in packageFileNames)
{
_logger.DebugFormat("Inspecting package '{0}'", fileName);
var localFileName = _fileSystemOperations.GetFileName(fileName);
any = true;
try
{
using (var stream = TryOpenStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete))
{
if (stream != null)
{
_logger.DebugFormat("Validating {0}...", localFileName);
if (packageIndex.ValidatePackage(stream))
{
_logger.DebugFormat("Verifying that {0} is the correct file name...", localFileName);
stream.Position = 0;
var package = NuGetPackage.ReadFromNupkgFile(stream);
var expectedFileName = package.Id + "." + package.Version + ".nupkg";
if (!string.Equals(localFileName, expectedFileName, StringComparison.OrdinalIgnoreCase))
{
_logger.WarnFormat("File {0} has incorrect name; should be {1}", localFileName, expectedFileName);
_logger.DebugFormat("Renaming {0} to {1}...", localFileName, expectedFileName);
var fullExpectedFileName = Path.Combine(packageDirectory, expectedFileName);
if (File.Exists(fullExpectedFileName))
{
try
{
_logger.Debug("Deleting target file '" + fullExpectedFileName + "'");
_fileSystemOperations.DeleteFile(fullExpectedFileName);
}
catch (Exception ex)
{
_logger.Error("Exception while deleting target file '" + fullExpectedFileName + "'", ex);
}
}
try
{
_logger.DebugFormat("Moving package from '{0}' to '{1}'.", fileName, fullExpectedFileName);
_fileSystemOperations.MoveFile(fileName, fullExpectedFileName);
_logger.Debug("Package renamed.");
}
catch (Exception ex)
{
_logger.Error("Could not rename package.", ex);
}
}
}
}
}
}
catch (Exception ex)
{
_logger.Error(string.Format("Could not validate '{0}'", fileName), ex);
StoredProcs.PackageIndexingErrors_LogIndexingError(FeedId, localFileName, ex.Message,
Encoding.UTF8.GetBytes(ex.StackTrace ?? string.Empty)
).Execute();
}
}
if (!any)
{
try
{
_logger.DebugFormat("Deleting empty directory {0}...", packageDirectory);
_fileSystemOperations.DeleteDirectory(packageDirectory);
}
catch
{
_logger.Warn("Directory could not be deleted; it may not be empty.");
}
}
}
packageIndex.RemoveRemaining();
}
else
{
_logger.DebugFormat("Package root path '{0}' not found. Nothing to do.", RootPath);
}
}
public RtvsTelemetry(IPackageIndex packageIndex, IRSettings settings, ITelemetryService service = null) {
_packageIndex = packageIndex;
_settings = settings;
TelemetryService = service ?? VsAppShell.Current.ExportProvider.GetExportedValue<ITelemetryService>();
}
