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(); } }
private async Task EnsureAvailablePackagesLoadedAsync() { var availablePackagesLoaded = await _availableLock.WaitAsync(); try { if (!availablePackagesLoaded) { await LoadAvailablePackagesAsync(); } } catch (RPackageManagerException ex) { _coreShell.DispatchOnUIThread(() => AddErrorMessage(ex.Message)); } finally { _availableLock.Release(); } }
private async Task EnsureInstalledAndAvailablePackagesLoadedAsync() { var areLoaded = await _availableAndInstalledLock.WaitAsync(); if (!areLoaded) { IsLoading = true; try { await LoadInstalledAndAvailablePackagesAsync(); } finally { IsLoading = false; _availableAndInstalledLock.Release(); } } }
public async Task Release() { var bal = new BinaryAsyncLock(); var count = 0; await ParallelTools.InvokeAsync(4, async i => { var isSet = await bal.WaitAsync(); if (!isSet) { Interlocked.Increment(ref count); bal.Release(); } }); count.Should().Be(1); }
private async Task ReloadInstalledAndLoadedPackagesAsync() { _installedAndLoadedLock.ResetIfNotWaiting(); var areLoaded = await _installedAndLoadedLock.WaitAsync(); try { if (!areLoaded) { await LoadInstalledAndLoadedPackagesAsync(); } } catch (RPackageManagerException ex) { _coreShell.DispatchOnUIThread(() => AddErrorMessage(ex.Message)); } finally { _installedAndLoadedLock.Release(); } }
protected override async Task ConnectToBrokerAsync() { DisposableBag.ThrowIfDisposed(); await TaskUtilities.SwitchToBackgroundThread(); try { if (!await _connectLock.WaitAsync()) { if (_brokerProcess == null) { await ConnectToBrokerWorker(); } } } finally { _connectLock.Release(); } }
public async Task BuildIndexAsync() { var ready = await _buildIndexLock.WaitAsync(); try { if (!ready) { var startTotalTime = DateTime.Now; await TaskUtilities.SwitchToBackgroundThread(); await _host.CreateSessionAsync(); Debug.WriteLine("R function host start: {0} ms", (DateTime.Now - startTotalTime).TotalMilliseconds); var startTime = DateTime.Now; // Fetch list of available packages from R session await BuildPackageListAsync(); Debug.WriteLine("R package names/description: {0} ms", (DateTime.Now - startTime).TotalMilliseconds); // Populate function index for preloaded packages first startTime = DateTime.Now; await BuildPreloadedPackagesFunctionListAsync(); Debug.WriteLine("R function index (preloaded): {0} ms", (DateTime.Now - startTime).TotalMilliseconds); // Populate function index for all remaining packages startTime = DateTime.Now; await BuildRemainingPackagesFunctionListAsync(); Debug.WriteLine("R function index (remaining): {0} ms", (DateTime.Now - startTime).TotalMilliseconds); await _functionIndex.BuildIndexAsync(this); Debug.WriteLine("R function index total: {0} ms", (DateTime.Now - startTotalTime).TotalMilliseconds); } } catch (RHostDisconnectedException ex) { Debug.WriteLine(ex.Message); } finally { _buildIndexLock.Release(); } }
public async Task CreateSessionAsync() { await _lock.WaitAsync(); try { if (Session == null) { Session = _sessionProvider.GetOrCreate(SessionId, _brokerConnector); } if (!Session.IsHostRunning) { int timeout = _coreShell.IsUnitTestEnvironment ? 10000 : 3000; await Session.StartHostAsync(new RHostStartupInfo { Name = "IntelliSense", CranMirrorName = RToolsSettings.Current.CranMirror, CodePage = RToolsSettings.Current.RCodePage }, null, timeout); } } finally { _lock.Release(); } }