public async Task RunAsync()
{
var taskHandler = _statusCenter?.PreRegister(
new TaskHandlerOptions()
{
ActionsAfterCompletion = CompletionActions.RetainAndNotifyOnFaulted | CompletionActions.RetainAndNotifyOnRanToCompletion,
Title = Strings.CondaStatusCenterCreateTitle.FormatUI(_actualName),
DisplayTaskDetails = (t) => { _outputWindow.ShowAndActivate(); }
},
new TaskProgressData()
{
CanBeCanceled = false,
ProgressText = Strings.CondaStatusCenterCreateProgressPreparing,
PercentComplete = null,
}
);
var ui = new CondaUI(taskHandler, _outputWindow, _showAndActiveOutputWindow);
_statusBar?.SetText(Strings.CondaStatusBarCreateStarted.FormatUI(_actualName));
var task = Task.Run(() => CreateCondaEnvironmentAsync(ui, taskHandler, taskHandler?.UserCancellation ?? CancellationToken.None));
taskHandler.RegisterTask(task);
_site.ShowTaskStatusCenter();
}
private async Task CreateCondaEnvironmentAsync(CondaUI ui, ITaskHandler taskHandler, CancellationToken ct)
{
try {
var factory = await CreateFactoryAsync(ui, taskHandler, ct);
if (factory != null)
{
await _site.GetUIThread().InvokeTask(async() => {
if (_project != null)
{
_project.AddInterpreter(factory.Configuration.Id);
if (_setAsCurrent)
{
_project.SetInterpreterFactory(factory);
}
}
else if (_workspace != null)
{
await _workspace.SetInterpreterFactoryAsync(factory);
}
if (_setAsDefault && _options != null)
{
_options.DefaultInterpreter = factory;
}
if (_viewInEnvWindow)
{
await InterpreterListToolWindow.OpenAtAsync(_site, factory);
}
});
}
taskHandler?.Progress.Report(new TaskProgressData()
{
CanBeCanceled = false,
ProgressText = Strings.CondaStatusCenterCreateProgressCompleted,
PercentComplete = 100,
});
_statusBar?.SetText(Strings.CondaStatusBarCreateSucceeded.FormatUI(_actualName));
} catch (Exception ex) when(!ex.IsCriticalException())
{
_statusBar?.SetText(Strings.CondaStatusBarCreateFailed.FormatUI(_actualName));
ui.OnErrorTextReceived(_condaMgr, ex.Message);
throw;
}
}
private async Task <IPythonInterpreterFactory> CreateFactoryAsync(CondaUI ui, ITaskHandler taskHandler, CancellationToken ct)
{
// Force discovery, don't respect the ignore nofitication ref count,
// which won't go back to 0 if multiple conda environments are being
// created around the same time. We need the discovery in order to find
// the new factory.
using (_factoryProvider?.SuppressDiscoverFactories(forceDiscoveryOnDispose: true)) {
taskHandler?.Progress.Report(new TaskProgressData()
{
CanBeCanceled = false,
ProgressText = Strings.CondaStatusCenterCreateProgressCreating,
PercentComplete = null,
});
bool failed = true;
bool useEnvFile = !string.IsNullOrEmpty(_envFilePath);
try {
if (useEnvFile)
{
if (!await _condaMgr.CreateFromEnvironmentFileAsync(
_envNameOrPath,
_envFilePath,
ui,
ct
))
{
throw new ApplicationException(Strings.CondaStatusCenterCreateFailure);
}
}
else
{
if (!await _condaMgr.CreateAsync(
_envNameOrPath,
_packages.ToArray(),
ui,
ct
))
{
throw new ApplicationException(Strings.CondaStatusCenterCreateFailure);
}
}
failed = false;
} finally {
_logger?.LogEvent(PythonLogEvent.CreateCondaEnv, new CreateCondaEnvInfo()
{
Failed = failed,
FromEnvironmentFile = useEnvFile,
SetAsDefault = _setAsDefault,
SetAsCurrent = _setAsCurrent,
OpenEnvironmentsWindow = _viewInEnvWindow,
});
}
}
var expectedId = CondaEnvironmentFactoryConstants.GetInterpreterId(
CondaEnvironmentFactoryProvider.EnvironmentCompanyName,
_actualName
);
// This will return null if the environment that was created does
// not contain a python interpreter. Common case for this is
// when the package list the user has entered is empty string.
var factory = _factoryProvider?.GetInterpreterFactory(expectedId);
return(factory);
}
