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();
}
}