private async void CreateProjectAndHandleErrors(
IVsStatusbar statusBar,
Microsoft.PythonTools.Project.ImportWizard.ImportWizard dlg,
bool addToExistingSolution
)
{
try {
var path = await dlg.ImportSettings.CreateRequestedProjectAsync();
if (File.Exists(path))
{
object outRef = null, pathRef = ProcessOutput.QuoteSingleArgument(path);
_serviceProvider.GetDTE().Commands.Raise(
VSConstants.GUID_VSStandardCommandSet97.ToString("B"),
addToExistingSolution
? (int)VSConstants.VSStd97CmdID.AddExistingProject
: (int)VSConstants.VSStd97CmdID.OpenProject,
ref pathRef,
ref outRef
);
statusBar.SetText("");
return;
}
} catch (UnauthorizedAccessException) {
MessageBox.Show(Strings.ErrorImportWizardUnauthorizedAccess, Strings.ProductTitle);
} catch (Exception ex) {
CommonUtils.ActivityLogError(Strings.ProductTitle, ex.ToString());
MessageBox.Show(Strings.ErrorImportWizardException.FormatUI(ex.GetType().Name), Strings.ProductTitle);
}
statusBar.SetText(Strings.StatusImportWizardError);
}
public Task ExecuteAsync(object parameter)
{
var task = ExecuteWorker((parameter as PythonProjectNode) ?? _project);
// Ensure the exception is observed.
// The caller can check task.Exception to do their own reporting.
task.ContinueWith(t => {
try {
t.Wait();
} catch (AggregateException ex) {
var exception = ex.InnerException;
if (exception is NoInterpretersException ||
exception is MissingInterpreterException ||
exception is TaskCanceledException)
{
// No need to log this exception or disable the command.
return;
}
// Prevent the command from executing again until the project is
// reloaded.
_canExecute = false;
var evt = CanExecuteChanged;
if (evt != null)
{
evt(this, EventArgs.Empty);
}
// Log error to the ActivityLog.
CommonUtils.ActivityLogError(Strings.ProductTitle, Strings.ErrorRunningCustomCommand.FormatUI(_target, ex));
}
});
return(task);
}
private async Task RequestFeeds(string feedSource)
{
try {
await Task.Run(() => GetFeeds(feedSource));
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
MessageBox.Show(SR.GetString(SR.WebPiFeedError, feedSource, ex.Message));
var fullMessage = SR.GetString(SR.WebPiFeedError, feedSource, ex);
Trace.WriteLine(fullMessage);
CommonUtils.ActivityLogError("WebPiComponentPickerControl", fullMessage);
}
}
private static string LoadResourceFromAssembly(string assembly, string ns, string key)
{
try {
var asmName = new System.Reflection.AssemblyName(assembly);
System.Reflection.Assembly asm = null;
if (asmName.FullName == asmName.Name)
{
// A partial name was provided. If there is an assembly with
// matching name in the current AppDomain, assume that is
// the intended one.
asm = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => assembly == a.GetName().Name);
}
asm = asm ?? System.Reflection.Assembly.Load(asmName);
var rm = new System.Resources.ResourceManager(ns, asm);
return(rm.GetString(key, CultureInfo.CurrentUICulture) ?? key);
} catch (Exception ex) {
CommonUtils.ActivityLogError(Strings.ProductTitle, Strings.FailedToReadResource.FormatUI(assembly, ns, key, ex));
return(key);
}
}
private async Task <bool> RunInRepl(IPythonProject project, CommandStartInfo startInfo)
{
var executeIn = string.IsNullOrEmpty(startInfo.ExecuteIn) ? CreatePythonCommandItem.ExecuteInRepl : startInfo.ExecuteIn;
bool resetRepl = executeIn.StartsWithOrdinal("R");
var replTitle = executeIn.Substring(4).TrimStart(' ', ':');
if (string.IsNullOrEmpty(replTitle))
{
replTitle = Strings.CustomCommandReplTitle.FormatUI(DisplayLabelWithoutAccessKeys);
}
else
{
var match = _customCommandLabelRegex.Match(replTitle);
if (match.Success)
{
replTitle = LoadResourceFromAssembly(
match.Groups["assembly"].Value,
match.Groups["namespace"].Value,
match.Groups["key"].Value
);
}
}
replTitle = PerformSubstitutions(project, replTitle);
var replWindowId = PythonReplEvaluatorProvider.GetTemporaryId(
ReplId + executeIn.Substring(4),
_project.GetInterpreterFactory().Configuration
);
var model = _project.Site.GetComponentModel();
var replProvider = model.GetService <InteractiveWindowProvider>();
if (replProvider == null)
{
return(false);
}
bool created;
var replWindow = replProvider.OpenOrCreateTemporary(replWindowId, replTitle, out created);
// TODO: Find alternative way of closing repl window on Dev15
var replFrame = (replWindow as ToolWindowPane)?.Frame as IVsWindowFrame;
var interactive = replWindow.InteractiveWindow;
var pyEvaluator = replWindow.InteractiveWindow.Evaluator as PythonInteractiveEvaluator;
if (pyEvaluator == null)
{
if (created && replFrame != null)
{
// We created the window, but it isn't valid, so we'll close
// it again immediately.
replFrame.CloseFrame((uint)__FRAMECLOSE.FRAMECLOSE_NoSave);
}
return(false);
}
if (pyEvaluator.IsExecuting)
{
throw new InvalidOperationException(Strings.ErrorCommandAlreadyRunning);
}
pyEvaluator.ProjectMoniker = _project.GetMkDocument();
pyEvaluator.Configuration = new LaunchConfiguration(startInfo.Interpreter)
{
WorkingDirectory = startInfo.WorkingDirectory,
Environment = startInfo.EnvironmentVariables.ToDictionary(kv => kv.Key, kv => kv.Value)
};
pyEvaluator.Configuration.LaunchOptions[PythonInteractiveEvaluator.DoNotResetConfigurationLaunchOption] = "true";
project.AddActionOnClose((object)replWindow, InteractiveWindowProvider.Close);
replWindow.Show(true);
var result = await pyEvaluator.ResetAsync(false, quiet : true);
if (result.IsSuccessful)
{
try {
var filename = startInfo.Filename;
var arguments = startInfo.Arguments ?? string.Empty;
if (startInfo.IsScript)
{
interactive.WriteLine(Strings.CustomCommandExecutingScript.FormatUI(Path.GetFileName(filename), arguments));
Debug.WriteLine("Executing {0} {1}", filename, arguments);
await pyEvaluator.ExecuteFileAsync(filename, arguments);
}
else if (startInfo.IsModule)
{
interactive.WriteLine(Strings.CustomCommandExecutingModule.FormatUI(filename, arguments));
Debug.WriteLine("Executing -m {0} {1}", filename, arguments);
await pyEvaluator.ExecuteModuleAsync(filename, arguments);
}
else if (startInfo.IsCode)
{
Debug.WriteLine("Executing -c \"{0}\"", filename, arguments);
await pyEvaluator.ExecuteCodeAsync(filename);
}
else
{
interactive.WriteLine(Strings.CustomCommandExecutingOther.FormatUI(Path.GetFileName(filename), arguments));
Debug.WriteLine("Executing {0} {1}", filename, arguments);
await pyEvaluator.ExecuteProcessAsync(filename, arguments);
}
if (resetRepl)
{
// We really close the backend, rather than resetting.
pyEvaluator.Dispose();
}
} catch (OperationCanceledException) {
// Swallow OperationCanceledException, it is normal for async operation to be cancelled
ActivityLog.LogInformation(Strings.ProductTitle, Strings.CustomCommandCanceled.FormatUI(_label));
} catch (Exception ex) {
CommonUtils.ActivityLogError(Strings.ProductTitle, Strings.ErrorRunningCustomCommand.FormatUI(_label, ex));
var outWindow = OutputWindowRedirector.GetGeneral(project.Site);
if (outWindow != null)
{
outWindow.WriteErrorLine(Strings.ErrorRunningCustomCommand.FormatUI(_label, ex));
outWindow.Show();
}
}
return(true);
}
return(false);
}
void IVsProjectUpgradeViaFactory4.UpgradeProject_CheckOnly(
string bstrFileName,
IVsUpgradeLogger pLogger,
out uint pUpgradeRequired,
out Guid pguidNewProjectFactory,
out uint pUpgradeProjectCapabilityFlags
)
{
pguidNewProjectFactory = Guid.Empty;
if (!File.Exists(bstrFileName))
{
pUpgradeRequired = 0;
pUpgradeProjectCapabilityFlags = 0;
return;
}
var backupSupport = __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED |
__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP |
__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_SXSBACKUP;
var logger = new UpgradeLogger(bstrFileName, pLogger);
try {
var projectXml = ProjectRootElement.Open(bstrFileName);
var userProjectName = bstrFileName + ".user";
var userProjectXml = File.Exists(userProjectName) ? ProjectRootElement.Open(userProjectName) : null;
var upgradeRequired = UpgradeProjectCheck(
projectXml,
userProjectXml,
logger.Log,
ref pguidNewProjectFactory,
ref backupSupport
);
switch (upgradeRequired)
{
case ProjectUpgradeState.SafeRepair:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_SAFEREPAIR;
break;
case ProjectUpgradeState.UnsafeRepair:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_UNSAFEREPAIR;
break;
case ProjectUpgradeState.OneWayUpgrade:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE;
break;
case ProjectUpgradeState.Incompatible:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_INCOMPATIBLE;
break;
case ProjectUpgradeState.Deprecated:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_DEPRECATED;
break;
default:
case ProjectUpgradeState.NotNeeded:
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
break;
}
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
// Log the error and don't attempt to upgrade the project.
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UnexpectedUpgradeError, ex.Message));
CommonUtils.ActivityLogError(GetType().FullName, ex.ToString());
pUpgradeRequired = (uint)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
}
pUpgradeProjectCapabilityFlags = (uint)backupSupport;
// If the upgrade checker set the factory GUID to ourselves, we need
// to clear it
if (pguidNewProjectFactory == GetType().GUID)
{
pguidNewProjectFactory = Guid.Empty;
}
}
int IVsProjectUpgradeViaFactory.UpgradeProject_CheckOnly(
string bstrFileName,
IVsUpgradeLogger pLogger,
out int pUpgradeRequired,
out Guid pguidNewProjectFactory,
out uint pUpgradeProjectCapabilityFlags
)
{
pUpgradeRequired = 0;
pguidNewProjectFactory = Guid.Empty;
if (!File.Exists(bstrFileName))
{
pUpgradeProjectCapabilityFlags = 0;
return(VSConstants.E_INVALIDARG);
}
var backupSupport = __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED |
__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP |
__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_SXSBACKUP;
var logger = new UpgradeLogger(bstrFileName, pLogger);
try {
var projectXml = ProjectRootElement.Open(bstrFileName);
var userProjectName = bstrFileName + ".user";
var userProjectXml = File.Exists(userProjectName) ? ProjectRootElement.Open(userProjectName) : null;
var upgradeRequired = UpgradeProjectCheck(
projectXml,
userProjectXml,
logger.Log,
ref pguidNewProjectFactory,
ref backupSupport
);
if (upgradeRequired != ProjectUpgradeState.NotNeeded)
{
pUpgradeRequired = 1;
}
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
// Log the error and don't attempt to upgrade the project.
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UnexpectedUpgradeError, ex.Message));
CommonUtils.ActivityLogError(GetType().FullName, ex.ToString());
pUpgradeRequired = 0;
}
pUpgradeProjectCapabilityFlags = (uint)backupSupport;
// If the upgrade checker set the factory GUID to ourselves, we need
// to clear it
if (pguidNewProjectFactory == GetType().GUID)
{
pguidNewProjectFactory = Guid.Empty;
}
return(VSConstants.S_OK);
}
int IVsProjectUpgradeViaFactory.UpgradeProject(
string bstrFileName,
uint fUpgradeFlag,
string bstrCopyLocation,
out string pbstrUpgradedFullyQualifiedFileName,
IVsUpgradeLogger pLogger,
out int pUpgradeRequired,
out Guid pguidNewProjectFactory
)
{
pbstrUpgradedFullyQualifiedFileName = null;
// We first run (or re-run) the upgrade check and bail out early if
// there is actually no need to upgrade.
uint dummy;
var hr = ((IVsProjectUpgradeViaFactory)this).UpgradeProject_CheckOnly(
bstrFileName,
pLogger,
out pUpgradeRequired,
out pguidNewProjectFactory,
out dummy
);
if (!CommonUtils.Succeeded(hr))
{
return(hr);
}
var logger = new UpgradeLogger(bstrFileName, pLogger);
var backup = (__VSPPROJECTUPGRADEVIAFACTORYFLAGS)fUpgradeFlag;
bool anyBackup, sxsBackup, copyBackup;
anyBackup = backup.HasFlag(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED);
if (anyBackup)
{
sxsBackup = backup.HasFlag(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_SXSBACKUP);
copyBackup = !sxsBackup && backup.HasFlag(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
}
else
{
sxsBackup = copyBackup = false;
}
if (copyBackup)
{
throw new NotSupportedException("PUVFF_COPYBACKUP is not supported");
}
pbstrUpgradedFullyQualifiedFileName = bstrFileName;
if (pUpgradeRequired == 0 && !copyBackup)
{
// No upgrade required, and no backup required.
logger.Log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, SR.GetString(SR.UpgradeNotRequired));
return(VSConstants.S_OK);
}
try {
UpgradeLogger logger2 = null;
var userFileName = bstrFileName + ".user";
if (File.Exists(userFileName))
{
logger2 = new UpgradeLogger(userFileName, pLogger);
}
else
{
userFileName = null;
}
if (sxsBackup)
{
// For SxS backups we want to put the old project file alongside
// the current one.
bstrCopyLocation = Path.GetDirectoryName(bstrFileName);
}
if (anyBackup)
{
var namePart = Path.GetFileNameWithoutExtension(bstrFileName);
var extPart = Path.GetExtension(bstrFileName) + (sxsBackup ? ".old" : "");
var projectFileBackup = Path.Combine(bstrCopyLocation, namePart + extPart);
for (int i = 1; File.Exists(projectFileBackup); ++i)
{
projectFileBackup = Path.Combine(
bstrCopyLocation,
string.Format("{0}{1}{2}", namePart, i, extPart)
);
}
File.Copy(bstrFileName, projectFileBackup);
// Back up the .user file if there is one
if (userFileName != null)
{
if (sxsBackup)
{
File.Copy(
userFileName,
Path.ChangeExtension(projectFileBackup, ".user.old")
);
}
else
{
File.Copy(userFileName, projectFileBackup + ".old");
}
}
// TODO: Implement support for backing up all files
//if (copyBackup) {
// - Open the project
// - Inspect all Items
// - Copy those items that are referenced relative to the
// project file into bstrCopyLocation
//}
}
var queryEdit = _site.GetService(typeof(SVsQueryEditQuerySave)) as IVsQueryEditQuerySave2;
if (queryEdit != null)
{
uint editVerdict;
uint queryEditMoreInfo;
var tagVSQueryEditFlags_QEF_AllowUnopenedProjects = (tagVSQueryEditFlags)0x80;
CommonUtils.ThrowOnFailure(queryEdit.QueryEditFiles(
(uint)(tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting |
tagVSQueryEditFlags.QEF_DisallowInMemoryEdits |
tagVSQueryEditFlags_QEF_AllowUnopenedProjects),
1,
new[] { bstrFileName },
null,
null,
out editVerdict,
out queryEditMoreInfo
));
if (editVerdict != (uint)tagVSQueryEditResult.QER_EditOK)
{
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UpgradeCannotCheckOutProject));
return(VSConstants.E_FAIL);
}
// File may have been updated during checkout, so check
// again whether we need to upgrade.
if ((queryEditMoreInfo & (uint)tagVSQueryEditResultFlags.QER_MaybeChanged) != 0)
{
hr = ((IVsProjectUpgradeViaFactory)this).UpgradeProject_CheckOnly(
bstrFileName,
pLogger,
out pUpgradeRequired,
out pguidNewProjectFactory,
out dummy
);
if (!CommonUtils.Succeeded(hr))
{
return(hr);
}
if (pUpgradeRequired == 0)
{
logger.Log(__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, SR.GetString(SR.UpgradeNotRequired));
return(VSConstants.S_OK);
}
}
}
// Load the project file and user file into MSBuild as plain
// XML to make it easier for subclasses.
var projectXml = ProjectRootElement.Open(bstrFileName);
if (projectXml == null)
{
throw new Exception(SR.GetString(SR.UpgradeCannotLoadProject));
}
var userXml = userFileName != null?ProjectRootElement.Open(userFileName) : null;
// Invoke our virtual UpgradeProject function. If it fails, it
// will throw and we will log the exception.
UpgradeProject(ref projectXml, ref userXml, logger.Log);
// Get the SCC info from the project file.
if (projectXml != null)
{
_cachedSccProject = bstrFileName;
_cachedSccProjectName = string.Empty;
_cachedSccAuxPath = string.Empty;
_cachedSccLocalPath = string.Empty;
_cachedSccProvider = string.Empty;
foreach (var property in projectXml.Properties)
{
switch (property.Name)
{
case ProjectFileConstants.SccProjectName:
_cachedSccProjectName = property.Value;
break;
case ProjectFileConstants.SccAuxPath:
_cachedSccAuxPath = property.Value;
break;
case ProjectFileConstants.SccLocalPath:
_cachedSccLocalPath = property.Value;
break;
case ProjectFileConstants.SccProvider:
_cachedSccProvider = property.Value;
break;
default:
break;
}
}
}
// Save the updated files.
if (projectXml != null)
{
projectXml.Save();
}
if (userXml != null)
{
userXml.Save();
}
// Need to add "Converted" (unlocalized) to the report because
// the XSLT refers to it.
logger.Log(__VSUL_ERRORLEVEL.VSUL_STATUSMSG, "Converted");
return(VSConstants.S_OK);
} catch (Exception ex) {
if (ex.IsCriticalException())
{
throw;
}
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UnexpectedUpgradeError, ex.Message));
CommonUtils.ActivityLogError(GetType().FullName, ex.ToString());
return(VSConstants.E_FAIL);
}
}