public int UpgradeProject(string xprojLocation, uint upgradeFlags, string backupDirectory, out string migratedProjectFileLocation,
IVsUpgradeLogger logger, out int upgradeRequired, out Guid migratedProjectGuid)
{
UIThreadHelper.VerifyOnUIThread();
bool success = false;
string projectName = Path.GetFileNameWithoutExtension(xprojLocation);
int hr = UpgradeProject_CheckOnly(xprojLocation, logger, out upgradeRequired, out migratedProjectGuid, out _);
// This implementation can only return S_OK. Throw if it returned something else.
Verify.HResult(hr);
// First, we back up the project. This function will take care of logging any backup failures.
if (!BackupProject(backupDirectory, xprojLocation, projectName, logger))
{
migratedProjectFileLocation = xprojLocation;
return(VSConstants.VS_E_PROJECTMIGRATIONFAILED);
}
#pragma warning disable RS0030 // Do not used banned APIs
IVsSolution solution = _serviceProvider.GetService <IVsSolution, SVsSolution>();
#pragma warning restore RS0030 // Do not used banned APIs
Verify.HResult(solution.GetSolutionInfo(out string solutionDirectory, out _, out _));
HResult backupResult = BackupAndDeleteGlobalJson(solutionDirectory, solution, backupDirectory, projectName, logger);
if (!backupResult.Succeeded)
{
migratedProjectGuid = GetType().GUID;
migratedProjectFileLocation = xprojLocation;
return(backupResult);
}
string directory = Path.GetDirectoryName(xprojLocation);
(string logFile, int processExitCode) = MigrateProject(solutionDirectory, directory, xprojLocation, projectName, logger);
if (!string.IsNullOrEmpty(logFile))
{
(migratedProjectFileLocation, success) = LogReport(logFile, processExitCode, projectName, xprojLocation, logger);
}
else
{
migratedProjectGuid = GetType().GUID;
migratedProjectFileLocation = null;
}
if (string.IsNullOrEmpty(migratedProjectFileLocation))
{
// If we weren't able to find a new csproj, something went very wrong, and dotnet migrate is doing something that we don't expect.
migratedProjectGuid = GetType().GUID;
Assumes.NotNullOrEmpty(migratedProjectFileLocation);
migratedProjectFileLocation = xprojLocation;
success = false;
}
if (success)
{
CleanupXproj(directory, projectName);
}
return(success ? VSConstants.S_OK : VSConstants.VS_E_PROJECTMIGRATIONFAILED);
}
public void UpgradeProject_CheckOnly(string pszFileName, IVsUpgradeLogger pLogger, out uint pUpgradeRequired, out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
int upgradeRequired;
UpgradeProject_CheckOnly(pszFileName, pLogger, out upgradeRequired, out pguidNewProjectFactory, out pUpgradeProjectCapabilityFlags);
pUpgradeRequired = unchecked ((uint)upgradeRequired);
}
public int UpgradeProject_CheckOnly(string fileName, IVsUpgradeLogger logger, out int upgradeRequired, out Guid newProjectFactory, out uint upgradeProjectCapabilityFlags)
{
upgradeRequired = 0;
newProjectFactory = this.GetType().GUID;
upgradeProjectCapabilityFlags = 0;
string toolsVersion = String.Empty;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(fileName);
foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
if (WixProjectFileConstants.PropertyGroup == node.Name)
{
foreach (XmlNode propertyNode in node.ChildNodes)
{
if (WixProjectFileConstants.WixTargetsPath == propertyNode.Name)
{
if (propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.0\\") || propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.5\\"))
{
upgradeRequired = 1;
}
}
}
}
}
return(VSConstants.S_OK);
}
public int UpgradeProject_CheckOnly(string xprojLocation,
IVsUpgradeLogger logger,
out int upgradeRequired,
out Guid migratedProjectFactory,
out uint upgradeProjectCapabilityFlags)
{
var isXproj = xprojLocation.EndsWith(".xproj");
// If the project is an xproj, then we need to one-way upgrade it. If it isn't, then there's nothing we can do with it.
upgradeRequired = isXproj ? (int)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE :
(int)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
if (isXproj)
{
migratedProjectFactory = new Guid($"{{{CSharpProjectSystemPackage.ProjectTypeGuid}}}");
upgradeProjectCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
}
else
{
migratedProjectFactory = new Guid(CSharpProjectSystemPackage.XprojTypeGuid);
upgradeProjectCapabilityFlags = 0;
}
return(VSConstants.S_OK);
}
public int UpgradeProject_CheckOnly(string xprojLocation,
IVsUpgradeLogger logger,
out int upgradeRequired,
out Guid migratedProjectFactory,
out uint upgradeProjectCapabilityFlags)
{
bool isXproj = xprojLocation.EndsWith(".xproj");
// If the project is an xproj, then we need to one-way upgrade it. If it isn't, then there's nothing we can do with it.
upgradeRequired = isXproj ? (int)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE :
(int)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
if (isXproj)
{
migratedProjectFactory = ProjectType.CSharpGuid;
upgradeProjectCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
}
else
{
migratedProjectFactory = GetType().GUID;
upgradeProjectCapabilityFlags = 0;
}
return(HResult.OK);
}
public int UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired, out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
pUpgradeRequired = 1;
pUpgradeProjectCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
pguidNewProjectFactory = Guid.Empty;
var projectData = new ProjectUpgradeHelper(projectFileName);
var version = ParseVersion(projectData.ToolsVersion.Value);
if (projectData.ToolsVersion == null || version.Major != 4 && version.Minor != 0)
return VSConstants.S_OK;
if (IsNeedUpdateNemerleProperty(projectData.NemerleProperty))
return VSConstants.S_OK;
if (IsNeedUpdateNemerleVersion(projectData))
return VSConstants.S_OK;
if (IsNeedUpdateNemerleBinPathRootProperty(projectData.NemerleBinPathRoot))
return VSConstants.S_OK;
if (!Utils.Eq(projectData.TargetFrameworkVersion.Value, Default.TargetFrameworkVersion))
return VSConstants.S_OK;
pUpgradeRequired = 0;
return VSConstants.S_OK;
}
public int UpgradeProject(string sourceProjectFilePath, uint fUpgradeFlag, string bstrCopyLocation, out string upgradedFullyQualifiedFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired, out Guid pguidNewProjectFactory)
{
pUpgradeRequired = 1;
pguidNewProjectFactory = Guid.Empty;
upgradedFullyQualifiedFileName = null;
var projectName = Path.GetFileNameWithoutExtension(sourceProjectFilePath);
try
{
var destProjectFilePath = sourceProjectFilePath;
var backupedProject = string.IsNullOrEmpty(bstrCopyLocation)
? null
: Path.Combine(bstrCopyLocation, Path.GetFileName(sourceProjectFilePath));
var projectFileName = Path.GetFileName(sourceProjectFilePath);
BackupProjectForUpgrade(sourceProjectFilePath, pLogger, ref destProjectFilePath, backupedProject, projectName);
upgradedFullyQualifiedFileName = destProjectFilePath;
UpgradeProject(sourceProjectFilePath, destProjectFilePath, pLogger, projectName);
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, sourceProjectFilePath, "Project converted successfully");
// Tell to VS which the project converted successfull. It's a magic! :)
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_STATUSMSG, projectName, sourceProjectFilePath,
// "Converted" should NOT be localized - it is referenced in the XSLT used to display the UpgradeReport
"Converted");
return VSConstants.S_OK;
}
catch (Exception ex)
{
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, sourceProjectFilePath, "Error during project convertion: " + ex.Message);
return VSConstants.E_FAIL;
}
}
public virtual int DoUpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger upgradeLogger, out __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS upgradeRequired, out Guid newProjectFactory, out uint upgradeCapabilityFlags)
{
newProjectFactory = GetType().GUID;
var project = ProjectRootElement.Open(projectFileName);
// enable Side-by-Side and CopyBackup support
upgradeCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_SXSBACKUP);
#if FX_ATLEAST_45
if (this.buildEngine.GetLoadedProjects(projectFileName).Count > 0)
{
// project has already been loaded
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
return(VSConstants.S_OK);
}
var projectInspector = new ProjectInspector(projectFileName);
if (projectInspector.IsPoisoned(Site))
{
// poisoned project cannot be opened (does not require upgrade)
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
return(VSConstants.S_OK);
}
#endif
// only upgrade known tool versions.
#if FX_ATLEAST_45
if (string.Equals("4.0", project.ToolsVersion, StringComparison.Ordinal))
{
// For 4.0, we need to take a deeper look. The logic is in
// vsproject\xmake\XMakeConversion\ProjectFileConverter.cs
var projectConverter = new Microsoft.Build.Conversion.ProjectFileConverter();
projectConverter.OldProjectFile = projectFileName;
projectConverter.NewProjectFile = projectFileName;
if (projectConverter.FSharpSpecificConversions(false))
{
upgradeRequired =
projectInspector.IsLikeDev10MinusProject()
? __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE
: __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_SAFEREPAIR;
return(VSConstants.S_OK);
}
else
{
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
return(VSConstants.S_OK);
}
}
else
#endif
if (string.Equals("3.5", project.ToolsVersion, StringComparison.Ordinal) ||
string.Equals("2.0", project.ToolsVersion, StringComparison.Ordinal))
{
// For 3.5 or 2.0, we always need to upgrade.
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE;
return(VSConstants.S_OK);
}
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
return(VSConstants.S_OK);
}
int IVsProjectUpgradeViaFactory.UpgradeProject_CheckOnly(
string bstrFileName,
IVsUpgradeLogger pLogger,
out int pUpgradeRequired,
out Guid pguidNewProjectFactory,
out uint pUpgradeProjectCapabilityFlags
)
{
pUpgradeRequired = 0;
if (!File.Exists(bstrFileName))
{
pguidNewProjectFactory = Guid.Empty;
pUpgradeProjectCapabilityFlags = 0;
return(VSConstants.E_INVALIDARG);
}
pguidNewProjectFactory = GetType().GUID;
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));
try {
ActivityLog.LogError(GetType().FullName, ex.ToString());
} catch (InvalidOperationException) {
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(ex.ToString());
}
pUpgradeRequired = 0;
}
pUpgradeProjectCapabilityFlags = (uint)backupSupport;
return(VSConstants.S_OK);
}
public void UpgradeProject_CheckOnly(string xprojLocation,
IVsUpgradeLogger logger,
out uint upgradeRequired,
out Guid migratedProjectFactory,
out uint upgradeProjectCapabilityFlags)
{
UpgradeProject_CheckOnly(xprojLocation, logger, out int iUpgradeRequired, out migratedProjectFactory, out upgradeProjectCapabilityFlags);
upgradeRequired = unchecked ((uint)iUpgradeRequired);
}
public int UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired, out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
pUpgradeRequired = 1;
pUpgradeProjectCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
pguidNewProjectFactory = Guid.Empty;
ProjectUpgradeHelper projectData;
try
{
projectData = new ProjectUpgradeHelper(projectFileName);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Nemerle language");
pUpgradeRequired = 0;
return(VSConstants.E_FAIL);
}
if (projectData.ToolsVersion == null)
{
return(VSConstants.S_OK);
}
// Check ToolsVersion
// Can be one of the following: 4.0
var version = ParseVersion(projectData.ToolsVersion.Value);
if (!(version.Major == 4 && version.Minor == 0))
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateNemerleProperty(projectData.NemerleProperty))
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateNemerleVersion(projectData))
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateNemerleBinPathRootProperty(projectData.NemerleBinPathRoot))
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateTargetFrameworkVersion(projectData))
{
return(VSConstants.S_OK);
}
pUpgradeRequired = 0;
return(VSConstants.S_OK);
}
public void UpgradeProject_CheckOnly(string pszFileName, IVsUpgradeLogger pLogger, out uint pUpgradeRequired,
out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
ThreadHelper.ThrowIfNotOnUIThread();
UpgradeProject_CheckOnly(pszFileName, pLogger, out int upgradeRequired, out pguidNewProjectFactory,
out pUpgradeProjectCapabilityFlags);
pUpgradeRequired = (uint)upgradeRequired;
}
public ProjectUpgradeLogger(IVsUpgradeLogger logger, string projectName, string projectFileName)
{
if (logger != null)
{
write = (errLevel, message) => logger.LogMessage((uint)errLevel, projectName, projectFileName, message);
}
else
{
write = delegate { };
}
}
public virtual int UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger upgradeLogger, out int upgradeRequired, out Guid newProjectFactory, out uint upgradeCapabilityFlags)
{
newProjectFactory = GetType().GUID;
upgradeCapabilityFlags = 0; // VSPPROJECTUPGRADEVIAFACTORYFLAGS: we only support in-place upgrade with no back-up
ProjectRootElement project = ProjectRootElement.Open(projectFileName);
// only upgrade known tool versions.
if (string.Equals("3.5", project.ToolsVersion, StringComparison.Ordinal) || string.Equals("2.0", project.ToolsVersion, StringComparison.Ordinal))
{
upgradeRequired = 1;
return(VSConstants.S_OK);
}
upgradeRequired = 0;
return(VSConstants.S_OK);
}
public int UpgradeProject(string bstrFileName, uint fUpgradeFlag, string bstrCopyLocation, out string pbstrUpgradedFullyQualifiedFileName,
IVsUpgradeLogger pLogger, out int pUpgradeRequired, out Guid pguidNewProjectFactory)
{
bool success;
uint dummy;
var projectName = Path.GetFileNameWithoutExtension(bstrFileName);
var hr = UpgradeProject_CheckOnly(bstrFileName, pLogger, out pUpgradeRequired, out pguidNewProjectFactory, out dummy);
// This implementation can only return S_OK. Throw if it returned something else.
Verify.HResult(hr);
// First, we back up the project. This function will take care of logging any backup failures.
if (!BackupProject(bstrCopyLocation, bstrFileName, projectName, pLogger))
{
pbstrUpgradedFullyQualifiedFileName = bstrFileName;
return(VSConstants.VS_E_PROJECTMIGRATIONFAILED);
}
// Next, we attempt to migrate. If migration failed, it will handle logging the result.
// TODO: This structure will likely want some refactoring once we have a Migration Report, tracked by:
// https://github.com/dotnet/roslyn-project-system/issues/507
var directory = Path.GetDirectoryName(bstrFileName);
var migrationResult = MigrateProject(directory, bstrFileName, projectName, pLogger);
if (!migrationResult)
{
// If migration failed, then we set the the new project file to point at the old project file.
success = false;
pbstrUpgradedFullyQualifiedFileName = bstrFileName;
}
else
{
success = true;
pbstrUpgradedFullyQualifiedFileName = GetCsproj(directory, projectName, bstrFileName, pLogger);
}
if (string.IsNullOrEmpty(pbstrUpgradedFullyQualifiedFileName))
{
// If we weren't able to find a new csproj, something went very wrong, and dotnet migrate is doing something that we don't expect.
Assumes.NotNullOrEmpty(pbstrUpgradedFullyQualifiedFileName);
pbstrUpgradedFullyQualifiedFileName = bstrFileName;
success = false;
}
return(success ? VSConstants.S_OK : VSConstants.VS_E_PROJECTMIGRATIONFAILED);
}
internal static void SqlDatabaseFileUpgradeService_OnUpgradeProject(
IVsHierarchy hierarchy, string databaseFile, string newConnectionString, IVsUpgradeLogger logger)
{
if (PackageManager.Package != null &&
PackageManager.Package.ModelManager != null)
{
var project = VSHelpers.GetProject(hierarchy);
// skip the step if it is a miscellaneous project or if the project is using IIS
// (projects using IIS should not be upgraded - see bug 812074)
if (project != null &&
!VsUtils.IsMiscellaneousProject(project) &&
!IsUsingIIS(project))
{
// update the config file as needed
IDictionary <string, object> documentMap = new Dictionary <string, object>();
var configFilePath = ConnectionManager.GetConfigFilePath(project, false);
try
{
if (false == string.IsNullOrWhiteSpace(configFilePath)) // check config file exists
{
XmlDocument configXmlDoc;
if (ConnectionManager.UpdateSqlDatabaseFileDataSourceInConnectionStrings(configFilePath, out configXmlDoc))
{
documentMap.Add(configFilePath, configXmlDoc);
}
}
}
catch (Exception ex)
{
// if there were errors above then do not try to change the files on disk - just log the message and return
var errMsg = String.Format(
CultureInfo.CurrentCulture, Resources.ErrorDuringSqlDatabaseFileUpgrade, configFilePath, ex.Message);
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, configFilePath, errMsg);
return;
}
// Actually update the file here
if (documentMap.Count > 0)
{
VsUtils.WriteCheckoutXmlFilesInProject(documentMap);
}
}
}
}
int IVsSolutionEventsProjectUpgrade.OnAfterUpgradeProject(IVsHierarchy pHierarchy, uint fUpgradeFlag, string bstrCopyLocation, SYSTEMTIME stUpgradeTime, IVsUpgradeLogger pLogger)
{
Debug.Assert(pHierarchy != null);
Project upgradedProject = VsUtility.GetProjectFromHierarchy(pHierarchy);
if (upgradedProject != null)
{
IList<IPackage> packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(upgradedProject);
if (!packagesToBeReinstalled.IsEmpty())
{
pLogger.LogMessage((int)__VSUL_ERRORLEVEL.VSUL_ERROR, upgradedProject.Name, upgradedProject.Name,
String.Format(CultureInfo.CurrentCulture, Resources.ProjectUpgradeAndRetargetErrorMessage, String.Join(", ", packagesToBeReinstalled.Select(p => p.Id))));
}
}
return VSConstants.S_OK;
}
public int UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired, out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
pUpgradeRequired = 1;
pUpgradeProjectCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
pguidNewProjectFactory = Guid.Empty;
ProjectUpgradeHelper projectData;
try
{
projectData = new ProjectUpgradeHelper(projectFileName);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Nemerle language");
pUpgradeRequired = 0;
return VSConstants.E_FAIL;
}
if (projectData.ToolsVersion == null)
return VSConstants.S_OK;
// Check ToolsVersion
// Can be one of the following: 4.0
var version = ParseVersion(projectData.ToolsVersion.Value);
if (!(version.Major == 4 && version.Minor == 0))
return VSConstants.S_OK;
if (IsNeedUpdateNemerleProperty(projectData.NemerleProperty))
return VSConstants.S_OK;
if (IsNeedUpdateNemerleVersion(projectData))
return VSConstants.S_OK;
if (IsNeedUpdateNemerleBinPathRootProperty(projectData.NemerleBinPathRoot))
return VSConstants.S_OK;
if (IsNeedUpdateTargetFrameworkVersion(projectData))
return VSConstants.S_OK;
pUpgradeRequired = 0;
return VSConstants.S_OK;
}
internal static void SqlDatabaseFileUpgradeService_OnUpgradeProject(
IVsHierarchy hierarchy, string databaseFile, string newConnectionString, IVsUpgradeLogger logger)
{
if (PackageManager.Package != null &&
PackageManager.Package.ModelManager != null)
{
var project = VSHelpers.GetProject(hierarchy);
// skip the step if it is a miscellaneous project or if the project is using IIS
// (projects using IIS should not be upgraded - see bug 812074)
if (project != null &&
!VsUtils.IsMiscellaneousProject(project) &&
!IsUsingIIS(project))
{
// update the config file as needed
var configFileUtils = new ConfigFileUtils(project, PackageManager.Package);
UpdateConfigForSqlDbFileUpgrade(configFileUtils, project, logger);
}
}
}
public int UpgradeProject_CheckOnly(string bstrFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired,
out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
var isCosmos = String.Equals(Path.GetExtension(bstrFileName), ".Cosmos", StringComparison.OrdinalIgnoreCase);
pUpgradeRequired = isCosmos ? (int)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE
: (int)__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
if (isCosmos)
{
pguidNewProjectFactory = Guid.Empty;
pUpgradeProjectCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
}
else
{
pguidNewProjectFactory = GetType().GUID;
pUpgradeProjectCapabilityFlags = 0;
}
return(VSConstants.S_OK);
}
public int UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired, out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
pUpgradeRequired = 1;
pUpgradeProjectCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
pguidNewProjectFactory = Guid.Empty;
var projectData = new ProjectUpgradeHelper(projectFileName);
var version = ParseVersion(projectData.ToolsVersion.Value);
if (projectData.ToolsVersion == null || version.Major != 3 && version.Minor != 5)
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateNemerleProperty(projectData.NemerleProperty))
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateNemerleVersion(projectData))
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateNemerleBinPathRootProperty(projectData.NemerleBinPathRoot))
{
return(VSConstants.S_OK);
}
if (!Utils.Eq(projectData.TargetFrameworkVersion.Value, Default.TargetFrameworkVersion))
{
return(VSConstants.S_OK);
}
pUpgradeRequired = 0;
return(VSConstants.S_OK);
}
/// <inheritdoc />
public int UpgradeProject_CheckOnly(string bstrFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired,
out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
XNamespace msbuild = "http://schemas.microsoft.com/developer/msbuild/2003";
Version toolsVersion, projectVersion;
pUpgradeRequired = 0;
pguidNewProjectFactory = this.GetType().GUID;
pUpgradeProjectCapabilityFlags = PUVFF_SXSBACKUP;
XDocument project = XDocument.Load(bstrFileName);
// Check the ToolsVerion attribute first. It should be 4.0 or better.
var toolsVersionAttr = project.Root.Attribute("ToolsVersion");
if (toolsVersionAttr == null || String.IsNullOrEmpty(toolsVersionAttr.Value) ||
!Version.TryParse(toolsVersionAttr.Value, out toolsVersion) || toolsVersion.Major < 4)
{
pUpgradeRequired = 1;
}
else
{
// Next, see if the SHFB schema version is current
XElement property = project.Root.Descendants(msbuild + "SHFBSchemaVersion").FirstOrDefault();
if (property == null || !Version.TryParse(property.Value, out projectVersion) ||
projectVersion < SandcastleProject.SchemaVersion)
{
pUpgradeRequired = 1;
}
}
// If it's of a higher version, we'll let the project node catch it. Despite what the documentation
// for this interface says, any value returned from here appears to be ignored and you cannot prevent
// it from either loading or continuing with the conversion when the shell calls it.
return(VSConstants.S_OK);
}
public int UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired, out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
pUpgradeRequired = 1;
pUpgradeProjectCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP);
pguidNewProjectFactory = Guid.Empty;
ProjectUpgradeHelper projectData;
try
{
projectData = new ProjectUpgradeHelper(projectFileName);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Nemerle language");
pUpgradeRequired = 0;
return(VSConstants.E_FAIL);
}
if (IsNeedUpdateNemerleProperty(projectData.NemerleProperty))
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateNemerleVersion(projectData))
{
return(VSConstants.S_OK);
}
if (IsNeedUpdateNemerleBinPathRootProperty(projectData.NemerleBinPathRoot))
{
return(VSConstants.S_OK);
}
pUpgradeRequired = 0;
return(VSConstants.S_OK);
}
private static void BackupProjectForUpgrade(string sourceProjectFilePath, IVsUpgradeLogger pLogger, ref string destProjectFilePath, string backupedProject, string projectName)
{
var dlg = new PromptProjectRenameForm(projectName);
Form parent = null;
foreach (Form item in Application.OpenForms)
{
if (item.GetType().Name == "UpgradeWizard_Dialog")
{
parent = item;
break;
}
}
var result = dlg.ShowDialog(parent);
if (result == DialogResult.Yes)
{
destProjectFilePath = Path.Combine(Path.GetDirectoryName(sourceProjectFilePath), dlg.ProjectName + Path.GetExtension(sourceProjectFilePath));
if (Utils.Eq(sourceProjectFilePath, destProjectFilePath))
{
throw new ApplicationException("Can't rename project to itself name.");
}
File.Copy(sourceProjectFilePath, destProjectFilePath);
//File successfully backed up as
pLogger.LogMessage(0, projectName, sourceProjectFilePath, "The project file has been renamed to '"
+ Path.GetFileName(destProjectFilePath) + "' ('" + destProjectFilePath
+ "'). The old project file remain unchanged.");
}
else if (!string.IsNullOrEmpty(backupedProject))
{
File.Copy(sourceProjectFilePath, backupedProject);
pLogger.LogMessage(0, projectName, sourceProjectFilePath, "File successfully backed up as "
+ backupedProject);
}
}
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));
try {
ActivityLog.LogError(GetType().FullName, ex.ToString());
} catch (InvalidOperationException) {
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(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;
}
}
public virtual int UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger upgradeLogger, out int upgradeRequired, out Guid newProjectFactory, out uint upgradeCapabilityFlags)
{
newProjectFactory = GetType().GUID;
upgradeCapabilityFlags = 0; // VSPPROJECTUPGRADEVIAFACTORYFLAGS: we only support in-place upgrade with no back-up
ProjectRootElement project = ProjectRootElement.Open(projectFileName);
// only upgrade known tool versions.
if (string.Equals("3.5", project.ToolsVersion, StringComparison.Ordinal) || string.Equals("2.0", project.ToolsVersion, StringComparison.Ordinal))
{
upgradeRequired = 1;
return VSConstants.S_OK;
}
upgradeRequired = 0;
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 (!ErrorHandler.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;
ErrorHandler.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 (!ErrorHandler.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));
try {
ActivityLog.LogError(GetType().FullName, ex.ToString());
} catch (InvalidOperationException) {
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(ex.ToString());
}
return VSConstants.E_FAIL;
}
}
internal static void SqlDatabaseFileUpgradeService_OnUpgradeProject(
IVsHierarchy hierarchy, string databaseFile, string newConnectionString, IVsUpgradeLogger logger)
{
if (PackageManager.Package != null
&& PackageManager.Package.ModelManager != null)
{
var project = VSHelpers.GetProject(hierarchy);
// skip the step if it is a miscellaneous project or if the project is using IIS
// (projects using IIS should not be upgraded - see bug 812074)
if (project != null
&& !VsUtils.IsMiscellaneousProject(project)
&& !IsUsingIIS(project))
{
// update the config file as needed
var configFileUtils = new ConfigFileUtils(project, PackageManager.Package);
UpdateConfigForSqlDbFileUpgrade(configFileUtils, project, logger);
}
}
}
public override int UpgradeProject_CheckOnly(string fileName, IVsUpgradeLogger logger, out int upgradeRequired, out Guid newProjectFactory, out uint upgradeProjectCapabilityFlags)
{
upgradeRequired = 0;
newProjectFactory = this.GetType().GUID;
upgradeProjectCapabilityFlags = 0;
string toolsVersion = String.Empty;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(fileName);
XmlNode toolVersionNode = xmlDoc.DocumentElement.Attributes.GetNamedItem(WixProjectFileConstants.ToolsVersion);
if (toolVersionNode != null)
{
toolsVersion = toolVersionNode.Value;
}
try
{
if (!String.IsNullOrEmpty(toolsVersion))
{
string[] version = toolsVersion.Split('.');
if (version.GetLength(0) >= 1)
{
int high = Convert.ToInt32(version[0], CultureInfo.InvariantCulture);
if (high < 4)
{
upgradeRequired = 1;
}
}
}
else
{
upgradeRequired = 1;
}
}
catch (FormatException)
{
// Unknown version, we don't want to touch it
}
catch (OverflowException)
{
// Unknown version, we don't want to touch it
}
foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
if (WixProjectFileConstants.PropertyGroup == node.Name)
{
foreach (XmlNode propertyNode in node.ChildNodes)
{
if (WixProjectFileConstants.WixTargetsPath == propertyNode.Name)
{
if (propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.0\\") || propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.5\\"))
{
upgradeRequired = 1;
}
if (propertyNode.InnerText.Contains("\\Wix2010.targets"))
{
upgradeRequired = 1;
}
}
}
}
}
return(VSConstants.S_OK);
}
internal static void SqlCeUpgradeService_OnUpgradeProject(IVsHierarchy hierarchy, IVsUpgradeLogger logger)
{
if (PackageManager.Package != null &&
PackageManager.Package.ModelManager != null)
{
// since this is about retargeting EDMX files on disk, no need to process other file extensions from any converters
var fileFinder = new VSFileFinder(EntityDesignArtifact.ExtensionEdmx);
fileFinder.FindInProject(hierarchy);
var project = VSHelpers.GetProject(hierarchy);
// skip the step if it is a miscellaneous project.
if (project != null &&
!VsUtils.IsMiscellaneousProject(project))
{
IDictionary <string, object> documentMap = new Dictionary <string, object>();
foreach (var vsFileInfo in fileFinder.MatchingFiles)
{
try
{
var projectItem = VsUtils.GetProjectItem(hierarchy, vsFileInfo.ItemId);
// Dev 10 bug 648969: skip the process for astoria edmx file.
if (EdmUtils.IsDataServicesEdmx(projectItem.get_FileNames(1)))
{
continue;
}
// Check whether project item is a linked item
var isLinkItem = VsUtils.IsLinkProjectItem(projectItem);
if (!isLinkItem)
{
var doc = MetadataConverterDriver.SqlCeInstance.Convert(SafeLoadXmlFromPath(vsFileInfo.Path));
if (doc != null)
{
documentMap.Add(vsFileInfo.Path, doc);
}
}
}
catch (Exception ex)
{
var errMsg = String.Format(
CultureInfo.CurrentCulture, Resources.ErrorDuringSqlCeUpgrade, vsFileInfo.Path, ex.Message);
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, vsFileInfo.Path, errMsg);
return;
}
}
if (documentMap.Count > 0)
{
VsUtils.WriteCheckoutXmlFilesInProject(documentMap);
}
// now update the config file as needed
var configFileUtils = new ConfigFileUtils(project, PackageManager.Package);
try
{
var configXmlDoc = configFileUtils.LoadConfig();
if (configXmlDoc != null) // check config file exists
{
if (ConnectionManager.UpdateSqlCeProviderInConnectionStrings(configXmlDoc))
{
configFileUtils.SaveConfig(configXmlDoc);
}
}
}
catch (Exception ex)
{
var errMsg = String.Format(
CultureInfo.CurrentCulture, Resources.ErrorDuringSqlCeUpgrade, configFileUtils.GetConfigPath(), ex.Message);
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, configFileUtils.GetConfigPath(), errMsg);
}
}
}
}
internal static void UpdateConfigForSqlDbFileUpgrade(ConfigFileUtils configFileUtils, Project project, IVsUpgradeLogger logger)
{
try
{
var configXmlDoc = configFileUtils.LoadConfig();
if (configXmlDoc != null) // check config file exists
{
if (ConnectionManager.UpdateSqlDatabaseFileDataSourceInConnectionStrings(configXmlDoc))
{
configFileUtils.SaveConfig(configXmlDoc);
}
}
}
catch (Exception ex)
{
// if there were errors above then do not try to change the files on disk - just log the message and return
var errMsg = String.Format(
CultureInfo.CurrentCulture, Resources.ErrorDuringSqlDatabaseFileUpgrade, configFileUtils.GetConfigPath(), ex.Message);
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, configFileUtils.GetConfigPath(), errMsg);
}
}
public override int UpgradeProject_CheckOnly(string fileName, IVsUpgradeLogger logger, out int upgradeRequired, out Guid newProjectFactory, out uint upgradeProjectCapabilityFlags)
{
upgradeRequired = 0;
newProjectFactory = this.GetType().GUID;
upgradeProjectCapabilityFlags = 0;
string toolsVersion = String.Empty;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(fileName);
XmlNode toolVersionNode = xmlDoc.DocumentElement.Attributes.GetNamedItem(WixProjectFileConstants.ToolsVersion);
if (toolVersionNode != null)
{
toolsVersion = toolVersionNode.Value;
}
try
{
if (!String.IsNullOrEmpty(toolsVersion))
{
string[] version = toolsVersion.Split('.');
if (version.GetLength(0) >= 1)
{
int high = Convert.ToInt32(version[0], CultureInfo.InvariantCulture);
if (high < 4)
{
upgradeRequired = 1;
}
}
}
else
{
upgradeRequired = 1;
}
}
catch (FormatException)
{
// Unknown version, we don't want to touch it
}
catch (OverflowException)
{
// Unknown version, we don't want to touch it
}
foreach(XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
if (WixProjectFileConstants.PropertyGroup == node.Name)
{
foreach (XmlNode propertyNode in node.ChildNodes)
{
if (WixProjectFileConstants.WixTargetsPath == propertyNode.Name)
{
if (propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.0\\") || propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.5\\"))
{
upgradeRequired = 1;
}
if (propertyNode.InnerText.Contains("\\Wix2010.targets"))
{
upgradeRequired = 1;
}
}
}
}
}
return VSConstants.S_OK;
}
private static void BackupProjectForUpgrade(string sourceProjectFilePath, IVsUpgradeLogger pLogger, ref string destProjectFilePath, string backupedProject, string projectName)
{
var dlg = new PromptProjectRenameForm(projectName);
Form parent = null;
foreach (Form item in Application.OpenForms)
if (item.GetType().Name == "UpgradeWizard_Dialog")
{
parent = item;
break;
}
var result = dlg.ShowDialog(parent);
if (result == DialogResult.Yes)
{
destProjectFilePath = Path.Combine(Path.GetDirectoryName(sourceProjectFilePath), dlg.ProjectName + Path.GetExtension(sourceProjectFilePath));
if (Utils.Eq(sourceProjectFilePath, destProjectFilePath))
throw new ApplicationException("Can't rename project to itself name.");
File.Copy(sourceProjectFilePath, destProjectFilePath);
//File successfully backed up as
pLogger.LogMessage(0, projectName, sourceProjectFilePath, "The project file has been renamed to '"
+ Path.GetFileName(destProjectFilePath) + "' ('" + destProjectFilePath
+ "'). The old project file remain unchanged.");
}
else if (!string.IsNullOrEmpty(backupedProject))
{
File.Copy(sourceProjectFilePath, backupedProject);
pLogger.LogMessage(0, projectName, sourceProjectFilePath, "File successfully backed up as "
+ backupedProject);
}
}
void IVsProjectUpgradeViaFactory4.UpgradeProject_CheckOnly(string pszFileName, IVsUpgradeLogger pLogger, out uint pUpgradeRequired, out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
throw new NotImplementedException();
}
int IVsProjectUpgradeViaFactory.UpgradeProject(string bstrFileName, uint fUpgradeFlag, string bstrCopyLocation, out string pbstrUpgradedFullyQualifiedFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired, out Guid pguidNewProjectFactory)
{
throw new NotImplementedException();
}
public UpgradeLogger(string projectFile, IVsUpgradeLogger logger) {
_projectFile = projectFile;
_projectName = Path.GetFileNameWithoutExtension(projectFile);
_logger = logger;
}
public int UpgradeProject_CheckOnly(string fileName, IVsUpgradeLogger logger, out int upgradeRequired, out Guid newProjectFactory, out uint upgradeProjectCapabilityFlags)
{
upgradeRequired = 0;
newProjectFactory = this.GetType().GUID;
upgradeProjectCapabilityFlags = 0;
string toolsVersion = String.Empty;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(fileName);
foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
if (WixProjectFileConstants.PropertyGroup == node.Name)
{
foreach (XmlNode propertyNode in node.ChildNodes)
{
if (WixProjectFileConstants.WixTargetsPath == propertyNode.Name)
{
if (propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.0\\") || propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.5\\"))
{
upgradeRequired = 1;
}
}
}
}
}
return VSConstants.S_OK;
}
public int UpgradeProject(string fileName, uint upgradeFlag, string copyLocation, out string upgradedFullyQualifiedFileName, IVsUpgradeLogger logger, out int upgradeRequired, out Guid newProjectFactory)
{
uint ignore;
string projectName = Path.GetFileNameWithoutExtension(fileName);
upgradedFullyQualifiedFileName = fileName;
this.UpgradeProject_CheckOnly(fileName, logger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
upgradedFullyQualifiedFileName = fileName;
return VSConstants.S_OK;
}
IVsQueryEditQuerySave2 queryEditQuerySave = WixHelperMethods.GetService<IVsQueryEditQuerySave2, SVsQueryEditQuerySave>(this.Site);
int qef = (int)tagVSQueryEditFlags.QEF_ReportOnly | (int)__VSQueryEditFlags2.QEF_AllowUnopenedProjects;
uint verdict;
uint moreInfo;
string[] files = new string[1];
files[0] = fileName;
bool continueUpgrade = false;
ErrorHandler.ThrowOnFailure(queryEditQuerySave.QueryEditFiles((uint)qef, 1, files, null, null, out verdict, out moreInfo));
if (verdict == (uint)tagVSQueryEditResult.QER_EditOK)
{
continueUpgrade = true;
}
if (verdict == (uint)tagVSQueryEditResult.QER_EditNotOK)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, fileName, WixStrings.ReadOnlyFile);
if ((moreInfo & (uint)tagVSQueryEditResultFlags.QER_ReadOnlyUnderScc) != 0)
{
qef = (int)tagVSQueryEditFlags.QEF_DisallowInMemoryEdits | (int)__VSQueryEditFlags2.QEF_AllowUnopenedProjects | (int)tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting;
ErrorHandler.ThrowOnFailure(queryEditQuerySave.QueryEditFiles((uint)qef, 1, files, null, null, out verdict, out moreInfo));
if (verdict == (uint)tagVSQueryEditResult.QER_EditOK)
{
continueUpgrade = true;
}
}
if (continueUpgrade)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, fileName, WixStrings.CheckoutSuccess);
}
else
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, fileName, WixStrings.FailedToCheckoutProject);
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, WixStrings.FailedToCheckoutFile, fileName));
}
}
// If file was modified during the checkout, maybe upgrade is not needed
if ((moreInfo & (uint)tagVSQueryEditResultFlags.QER_MaybeChanged) != 0)
{
this.UpgradeProject_CheckOnly(fileName, logger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, fileName, WixStrings.UpgradeNoNeedToUpgradeAfterCheckout);
}
return VSConstants.S_OK;
}
}
if (continueUpgrade)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(fileName);
bool targetsPathUpdated = false;
foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
if (WixProjectFileConstants.PropertyGroup == node.Name)
{
foreach (XmlNode propertyNode in node.ChildNodes)
{
if (WixProjectFileConstants.WixTargetsPath == propertyNode.Name)
{
if (propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.0\\"))
{
targetsPathUpdated = true;
propertyNode.InnerText = propertyNode.InnerText.Replace("\\Microsoft\\WiX\\v3.0\\", "\\Microsoft\\WiX\\v3.x\\");
}
else if (propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.5\\"))
{
targetsPathUpdated = true;
propertyNode.InnerText = propertyNode.InnerText.Replace("\\Microsoft\\WiX\\v3.5\\", "\\Microsoft\\WiX\\v3.x\\");
}
}
}
}
}
if (targetsPathUpdated)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, fileName, WixStrings.WixTargetsPathUpdated);
}
xmlDoc.Save(fileName);
upgradedFullyQualifiedFileName = fileName;
}
return VSConstants.S_OK;
}
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) when(!ExceptionExtensions.IsCriticalException(ex))
{
// Log the error and don't attempt to upgrade the project.
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UnexpectedUpgradeError, ex.Message));
try
{
ActivityLog.LogError(GetType().FullName, ex.ToString());
}
catch (InvalidOperationException)
{
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(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;
}
}
private static void UpgradeProject(string sourceProjectFilePath, string destProjectFilePath, IVsUpgradeLogger pLogger, string projectName)
{
var projectData = new ProjectUpgradeHelper(sourceProjectFilePath);
projectData.ToolsVersion.Value = Default.ToolsVersion;
if (IsNeedUpdateNemerleBinPathRootProperty(projectData.NemerleBinPathRoot))
{
projectData.NemerleBinPathRoot.Value = Default.NemerleBinPathRoot;
projectData.NemerleBinPathRoot.SetAttributeValue("Condition", " '$(NemerleBinPathRoot)' == '' ");
}
else if (!Utils.Eq(projectData.NemerleBinPathRoot.Value, Default.NemerleBinPathRoot))
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_WARNING, projectName, sourceProjectFilePath, "The NemerleBinPathRoot property changed by user. You must update it manually.");
projectData.NemerleVersion.Value = Default.NemerleVersion;
if (IsNeedUpdateNemerleProperty(projectData.NemerleProperty))
projectData.NemerleProperty.Value = Default.NemerleProperty;
else if (!Utils.Eq(projectData.NemerleProperty.Value, Default.NemerleProperty))
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_WARNING, projectName, sourceProjectFilePath, "The Nemerle property changed by user. You must update it manually.");
projectData.TargetFrameworkVersion.Value = Default.TargetFrameworkVersion;
projectData.NemerleProperty.Document.Save(destProjectFilePath);
}
/// <summary>
/// Defines a method to call after a project upgrade.
/// </summary>
/// <param name="pHierarchy">[in] Pointer to the <see cref="T:Microsoft.VisualStudio.Shell.Interop.IVsHierarchy"></see> interface of the project.</param>
/// <param name="fUpgradeFlag">[in] Integer. Flag indicating the nature of the upgrade. Values taken from the <see cref="T:Microsoft.VisualStudio.Shell.Interop.__VSPPROJECTUPGRADEVIAFACTORYFLAGS"></see> enumeration. Will only be PUVFF_COPYUPGRADE, PUVFF_SXSBACKUP, or PUVFF_COPYBACKUP.</param>
/// <param name="bstrCopyLocation">[in] String containing the location of the copy upgrade (PUVFF_COPYUPGRADE) or back up copy (PUVFF_COPYBACKUP).</param>
/// <param name="stUpgradeTime">[in] A <see cref="T:Microsoft.VisualStudio.Shell.Interop.SYSTEMTIME"></see> value. The time the upgrade was done.</param>
/// <param name="pLogger">[in] Pointer to an <see cref="T:Microsoft.VisualStudio.Shell.Interop.IVsUpgradeLogger"></see> interface to use for logging upgrade messages.</param>
/// <returns>
/// If the method succeeds, it returns <see cref="F:Microsoft.VisualStudio.VSErr.S_OK"></see>. If it fails, it returns an error code.
/// </returns>
public int OnAfterUpgradeProject(IVsHierarchy pHierarchy, uint fUpgradeFlag, string bstrCopyLocation, SYSTEMTIME stUpgradeTime, IVsUpgradeLogger pLogger)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (!SccProvider.IsActive)
{
return(VSErr.S_OK);
}
IProjectFileMapper mapper = GetService <IProjectFileMapper>();
IFileStatusMonitor monitor = GetService <IFileStatusMonitor>();
if (monitor == null || mapper == null)
{
return(VSErr.S_OK);
}
if (SccProvider.IsSafeSccPath(bstrCopyLocation))
{
monitor.ScheduleSvnStatus(bstrCopyLocation);
}
IVsSccProject2 project = pHierarchy as IVsSccProject2;
if (project != null)
{
ISccProjectInfo info = mapper.GetProjectInfo(new SccProject(null, project));
if (info != null && !string.IsNullOrEmpty(info.ProjectFile))
{
monitor.ScheduleSvnStatus(info.ProjectFile);
}
}
return(VSErr.S_OK);
}
/// <summary>
/// Defines a method to call after a project upgrade.
/// </summary>
/// <param name="pHierarchy">[in] Pointer to the <see cref="T:Microsoft.VisualStudio.Shell.Interop.IVsHierarchy"></see> interface of the project.</param>
/// <param name="fUpgradeFlag">[in] Integer. Flag indicating the nature of the upgrade. Values taken from the <see cref="T:Microsoft.VisualStudio.Shell.Interop.__VSPPROJECTUPGRADEVIAFACTORYFLAGS"></see> enumeration. Will only be PUVFF_COPYUPGRADE, PUVFF_SXSBACKUP, or PUVFF_COPYBACKUP.</param>
/// <param name="bstrCopyLocation">[in] String containing the location of the copy upgrade (PUVFF_COPYUPGRADE) or back up copy (PUVFF_COPYBACKUP).</param>
/// <param name="stUpgradeTime">[in] A <see cref="T:Microsoft.VisualStudio.Shell.Interop.SYSTEMTIME"></see> value. The time the upgrade was done.</param>
/// <param name="pLogger">[in] Pointer to an <see cref="T:Microsoft.VisualStudio.Shell.Interop.IVsUpgradeLogger"></see> interface to use for logging upgrade messages.</param>
/// <returns>
/// If the method succeeds, it returns <see cref="F:Microsoft.VisualStudio.VSConstants.S_OK"></see>. If it fails, it returns an error code.
/// </returns>
public int OnAfterUpgradeProject(IVsHierarchy pHierarchy, uint fUpgradeFlag, string bstrCopyLocation, SYSTEMTIME stUpgradeTime, IVsUpgradeLogger pLogger)
{
IProjectFileMapper mapper = GetService<IProjectFileMapper>();
IFileStatusMonitor monitor = GetService<IFileStatusMonitor>();
if(monitor == null || mapper == null)
return VSConstants.S_OK;
if (!string.IsNullOrEmpty(bstrCopyLocation))
monitor.ScheduleGitStatus(bstrCopyLocation);
IVsSccProject2 project = pHierarchy as IVsSccProject2;
if (project != null)
{
IGitProjectInfo info = mapper.GetProjectInfo(new GitProject(null, project));
if (info != null && !string.IsNullOrEmpty(info.ProjectFile))
monitor.ScheduleGitStatus(info.ProjectFile);
}
return VSConstants.S_OK;
}
public virtual int UpgradeProject(string projectFileName, uint upgradeFlag, string copyLocation, out string upgradeFullyQualifiedFileName, IVsUpgradeLogger logger, out int upgradeRequired,
out Guid newProjectFactory)
{
uint ignore;
this.UpgradeProject_CheckOnly(projectFileName, logger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
upgradeFullyQualifiedFileName = projectFileName;
return VSConstants.S_OK;
}
string projectName = Path.GetFileNameWithoutExtension(projectFileName);
upgradeFullyQualifiedFileName = projectFileName;
// Query for edit
IVsQueryEditQuerySave2 queryEdit = site.GetService(typeof(SVsQueryEditQuerySave)) as IVsQueryEditQuerySave2;
if (queryEdit != null)
{
uint editVerdict;
uint queryEditMoreInfo;
const tagVSQueryEditFlags tagVSQueryEditFlags_QEF_AllowUnopenedProjects = (tagVSQueryEditFlags)0x80;
int hr = queryEdit.QueryEditFiles(
(uint)(tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting | tagVSQueryEditFlags.QEF_DisallowInMemoryEdits | tagVSQueryEditFlags_QEF_AllowUnopenedProjects),
1, new[] { projectFileName }, null, null, out editVerdict, out queryEditMoreInfo);
if (ErrorHandler.Failed(hr))
{
return VSConstants.E_FAIL;
}
if (editVerdict != (uint)tagVSQueryEditResult.QER_EditOK)
{
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, projectFileName,
SR.GetString(SR.UpgradeCannotOpenProjectFileForEdit));
}
return VSConstants.E_FAIL;
}
// If file was modified during the checkout, maybe upgrade is not needed
if ((queryEditMoreInfo & (uint)tagVSQueryEditResultFlags.QER_MaybeChanged) != 0)
{
this.UpgradeProject_CheckOnly(projectFileName, logger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, projectFileName,
SR.GetString(SR.UpgradeNoNeedToUpgradeAfterCheckout));
}
return VSConstants.S_OK;
}
}
}
// Convert the project
Microsoft.Build.Conversion.ProjectFileConverter projectConverter = new Microsoft.Build.Conversion.ProjectFileConverter();
projectConverter.OldProjectFile = projectFileName;
projectConverter.NewProjectFile = projectFileName;
ProjectRootElement convertedProject = null;
try
{
convertedProject = projectConverter.ConvertInMemory();
}
catch (Exception ex)
{
if (logger != null)
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, projectFileName, ex.Message);
}
if (convertedProject != null)
{
this.m_lastUpgradedProjectFile = projectFileName;
foreach (ProjectPropertyElement property in convertedProject.Properties)
{
switch (property.Name)
{
case SCC_LOCAL_PATH:
this.m_sccLocalPath = property.Value;
break;
case SCC_AUX_PATH:
this.m_sccAuxPath = property.Value;
break;
case SCC_PROVIDER:
this.m_sccProvider = property.Value;
break;
case SCC_PROJECT_NAME:
this.m_sccProjectName = property.Value;
break;
default:
break;
}
}
try
{
convertedProject.Save(projectFileName);
}
catch (Exception ex)
{
if (logger != null)
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, projectFileName, ex.Message);
return VSConstants.E_FAIL;
}
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_STATUSMSG, projectName, projectFileName,
SR.GetString(SR.UpgradeSuccessful));
}
return VSConstants.S_OK;
}
this.m_lastUpgradedProjectFile = null;
upgradeFullyQualifiedFileName = "";
return VSConstants.E_FAIL;
}
/// <inheritdoc />
public int UpgradeProject(string bstrFileName, uint fUpgradeFlag, string bstrCopyLocation,
out string pbstrUpgradedFullyQualifiedFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired,
out Guid pguidNewProjectFactory)
{
uint verdict, moreInfo, ignored;
string[] files = new string[1] { bstrFileName };
string projectName = Path.GetFileNameWithoutExtension(bstrFileName);
bool continueUpgrade = false;
pbstrUpgradedFullyQualifiedFileName = bstrFileName;
// Be sure we need an upgrade
this.UpgradeProject_CheckOnly(bstrFileName, pLogger, out pUpgradeRequired, out pguidNewProjectFactory, out ignored);
if(pUpgradeRequired == 0)
return VSConstants.S_OK;
// See if the file is editable
IVsQueryEditQuerySave2 qes = Utility.GetServiceFromPackage<IVsQueryEditQuerySave2, SVsQueryEditQuerySave>(true);
ErrorHandler.ThrowOnFailure(qes.QueryEditFiles((uint)tagVSQueryEditFlags.QEF_ReportOnly |
(uint)__VSQueryEditFlags2.QEF_AllowUnopenedProjects, 1, files, null, null, out verdict,
out moreInfo));
if(verdict == (uint)tagVSQueryEditResult.QER_EditOK)
continueUpgrade = true;
if(verdict == (uint)tagVSQueryEditResult.QER_EditNotOK)
{
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, bstrFileName,
"The project file is read-only. An attempt will be made to check it out if under source control.");
if((moreInfo & (uint)tagVSQueryEditResultFlags.QER_ReadOnlyUnderScc) != 0)
{
ErrorHandler.ThrowOnFailure(qes.QueryEditFiles(
(uint)tagVSQueryEditFlags.QEF_DisallowInMemoryEdits |
(uint)__VSQueryEditFlags2.QEF_AllowUnopenedProjects |
(uint)tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting, 1, files, null, null,
out verdict, out moreInfo));
if(verdict == (uint)tagVSQueryEditResult.QER_EditOK)
continueUpgrade = true;
}
if(continueUpgrade)
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, bstrFileName,
"The project file was successfully checked out.");
else
{
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, bstrFileName,
"Unable to check project out of source control. Upgrade failed.");
throw new InvalidOperationException("Unable to check out project file for upgrade: " + bstrFileName);
}
}
// If file was modified during the checkout, confirm that it still needs upgrading
if((moreInfo & (uint)tagVSQueryEditResultFlags.QER_MaybeChanged) != 0)
{
this.UpgradeProject_CheckOnly(bstrFileName, pLogger, out pUpgradeRequired,
out pguidNewProjectFactory, out ignored);
if(pUpgradeRequired == 0)
{
if(pLogger != null)
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, bstrFileName,
"The project file was checked out and is already up to date. No upgrade needed.");
return VSConstants.S_OK;
}
}
if(continueUpgrade)
{
// Make a backup?
if(fUpgradeFlag == PUVFF_SXSBACKUP)
File.Copy(bstrFileName, bstrFileName + ".backup", true);
// The SancastleProject class contains all the code needed to update the project so all we need
// to do is load a copy and force it to save a new copy.
using(SandcastleProject p = new SandcastleProject(bstrFileName, true, false))
{
p.SaveProject(bstrFileName);
}
pLogger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, bstrFileName,
"The project file was upgraded successfully.");
}
return VSConstants.S_OK;
}
internal static void SqlCeUpgradeService_OnUpgradeProject(IVsHierarchy hierarchy, IVsUpgradeLogger logger)
{
if (PackageManager.Package != null
&& PackageManager.Package.ModelManager != null)
{
// since this is about retargeting EDMX files on disk, no need to process other file extensions from any converters
var fileFinder = new VSFileFinder(EntityDesignArtifact.ExtensionEdmx);
fileFinder.FindInProject(hierarchy);
var project = VSHelpers.GetProject(hierarchy);
// skip the step if it is a miscellaneous project.
if (project != null
&& !VsUtils.IsMiscellaneousProject(project))
{
IDictionary<string, object> documentMap = new Dictionary<string, object>();
foreach (var vsFileInfo in fileFinder.MatchingFiles)
{
try
{
var projectItem = VsUtils.GetProjectItem(hierarchy, vsFileInfo.ItemId);
// Dev 10 bug 648969: skip the process for astoria edmx file.
if (EdmUtils.IsDataServicesEdmx(projectItem.get_FileNames(1)))
{
continue;
}
// Check whether project item is a linked item
var isLinkItem = VsUtils.IsLinkProjectItem(projectItem);
if (!isLinkItem)
{
var doc = MetadataConverterDriver.SqlCeInstance.Convert(SafeLoadXmlFromPath(vsFileInfo.Path));
if (doc != null)
{
documentMap.Add(vsFileInfo.Path, doc);
}
}
}
catch (Exception ex)
{
var errMsg = String.Format(
CultureInfo.CurrentCulture, Resources.ErrorDuringSqlCeUpgrade, vsFileInfo.Path, ex.Message);
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, vsFileInfo.Path, errMsg);
return;
}
}
if (documentMap.Count > 0)
{
VsUtils.WriteCheckoutXmlFilesInProject(documentMap);
}
// now update the config file as needed
var configFileUtils = new ConfigFileUtils(project, PackageManager.Package);
try
{
var configXmlDoc = configFileUtils.LoadConfig();
if (configXmlDoc != null) // check config file exists
{
if (ConnectionManager.UpdateSqlCeProviderInConnectionStrings(configXmlDoc))
{
configFileUtils.SaveConfig(configXmlDoc);
}
}
}
catch (Exception ex)
{
var errMsg = String.Format(
CultureInfo.CurrentCulture, Resources.ErrorDuringSqlCeUpgrade, configFileUtils.GetConfigPath(), ex.Message);
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, configFileUtils.GetConfigPath(), errMsg);
}
}
}
}
int IVsProjectUpgradeViaFactory.UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger upgradeLogger, out int upgradeRequired, out Guid newProjectFactory, out uint upgradeCapabilityFlags)
{
__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS upgradeRequiredFlag;
var hr = DoUpgradeProject_CheckOnly(projectFileName, upgradeLogger, out upgradeRequiredFlag, out newProjectFactory, out upgradeCapabilityFlags);
upgradeRequired = upgradeRequiredFlag != __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR ? 1 : 0;
return hr;
}
internal static void UpdateConfigForSqlDbFileUpgrade(ConfigFileUtils configFileUtils, Project project, IVsUpgradeLogger logger)
{
try
{
var configXmlDoc = configFileUtils.LoadConfig();
if (configXmlDoc != null) // check config file exists
{
if (ConnectionManager.UpdateSqlDatabaseFileDataSourceInConnectionStrings(configXmlDoc))
{
configFileUtils.SaveConfig(configXmlDoc);
}
}
}
catch (Exception ex)
{
// if there were errors above then do not try to change the files on disk - just log the message and return
var errMsg = String.Format(
CultureInfo.CurrentCulture, Resources.ErrorDuringSqlDatabaseFileUpgrade, configFileUtils.GetConfigPath(), ex.Message);
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, configFileUtils.GetConfigPath(), errMsg);
}
}
public virtual int DoUpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger upgradeLogger, out __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS upgradeRequired, out Guid newProjectFactory, out uint upgradeCapabilityFlags)
{
newProjectFactory = GetType().GUID;
var project = ProjectRootElement.Open(projectFileName);
// enable Side-by-Side and CopyBackup support
upgradeCapabilityFlags = (uint)(__VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_BACKUPSUPPORTED | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_COPYBACKUP | __VSPPROJECTUPGRADEVIAFACTORYFLAGS.PUVFF_SXSBACKUP);
#if FX_ATLEAST_45
if (this.buildEngine.GetLoadedProjects(projectFileName).Count > 0)
{
// project has already been loaded
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
return VSConstants.S_OK;
}
var projectInspector = new ProjectInspector(projectFileName);
if (projectInspector.IsPoisoned(Site))
{
// poisoned project cannot be opened (does not require upgrade)
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
return VSConstants.S_OK;
}
#endif
// only upgrade known tool versions.
#if FX_ATLEAST_45
if (string.Equals("4.0", project.ToolsVersion, StringComparison.Ordinal))
{
// For 4.0, we need to take a deeper look. The logic is in
// vsproject\xmake\XMakeConversion\ProjectFileConverter.cs
var projectConverter = new Microsoft.Build.Conversion.ProjectFileConverter();
projectConverter.OldProjectFile = projectFileName;
projectConverter.NewProjectFile = projectFileName;
if (projectConverter.FSharpSpecificConversions(false))
{
upgradeRequired =
projectInspector.IsLikeDev10MinusProject()
? __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE
: __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_SAFEREPAIR;
return VSConstants.S_OK;
}
else
{
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
return VSConstants.S_OK;
}
}
else
#endif
if (string.Equals("3.5", project.ToolsVersion, StringComparison.Ordinal)
|| string.Equals("2.0", project.ToolsVersion, StringComparison.Ordinal))
{
// For 3.5 or 2.0, we always need to upgrade.
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_ONEWAYUPGRADE;
return VSConstants.S_OK;
}
upgradeRequired = __VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS.VSPUVF_PROJECT_NOREPAIR;
return VSConstants.S_OK;
}
public override int UpgradeProject(string fileName, uint upgradeFlag, string copyLocation, out string upgradedFullyQualifiedFileName, IVsUpgradeLogger logger, out int upgradeRequired, out Guid newProjectFactory)
{
uint ignore;
string projectName = Path.GetFileNameWithoutExtension(fileName);
upgradedFullyQualifiedFileName = fileName;
this.UpgradeProject_CheckOnly(fileName, logger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
upgradedFullyQualifiedFileName = fileName;
return(VSConstants.S_OK);
}
IVsQueryEditQuerySave2 queryEditQuerySave = WixHelperMethods.GetService <IVsQueryEditQuerySave2, SVsQueryEditQuerySave>(this.Site);
int qef = (int)tagVSQueryEditFlags.QEF_ReportOnly | (int)__VSQueryEditFlags2.QEF_AllowUnopenedProjects;
uint verdict;
uint moreInfo;
string[] files = new string[1];
files[0] = fileName;
bool continueUpgrade = false;
ErrorHandler.ThrowOnFailure(queryEditQuerySave.QueryEditFiles((uint)qef, 1, files, null, null, out verdict, out moreInfo));
if (verdict == (uint)tagVSQueryEditResult.QER_EditOK)
{
continueUpgrade = true;
}
if (verdict == (uint)tagVSQueryEditResult.QER_EditNotOK)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, fileName, WixStrings.ReadOnlyFile);
if ((moreInfo & (uint)tagVSQueryEditResultFlags.QER_ReadOnlyUnderScc) != 0)
{
qef = (int)tagVSQueryEditFlags.QEF_DisallowInMemoryEdits | (int)__VSQueryEditFlags2.QEF_AllowUnopenedProjects | (int)tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting;
ErrorHandler.ThrowOnFailure(queryEditQuerySave.QueryEditFiles((uint)qef, 1, files, null, null, out verdict, out moreInfo));
if (verdict == (uint)tagVSQueryEditResult.QER_EditOK)
{
continueUpgrade = true;
}
}
if (continueUpgrade)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, fileName, WixStrings.CheckoutSuccess);
}
else
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, fileName, WixStrings.FailedToCheckoutProject);
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, WixStrings.FailedToCheckoutFile, fileName));
}
}
// If file was modified during the checkout, maybe upgrade is not needed
if ((moreInfo & (uint)tagVSQueryEditResultFlags.QER_MaybeChanged) != 0)
{
this.UpgradeProject_CheckOnly(fileName, logger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, fileName, WixStrings.UpgradeNoNeedToUpgradeAfterCheckout);
}
return(VSConstants.S_OK);
}
}
if (continueUpgrade)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(fileName);
xmlDoc.DocumentElement.SetAttribute(WixProjectFileConstants.ToolsVersion, "4.0");
bool targetsPathUpdated = false;
foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
{
if (WixProjectFileConstants.PropertyGroup == node.Name)
{
foreach (XmlNode propertyNode in node.ChildNodes)
{
if (WixProjectFileConstants.WixTargetsPath == propertyNode.Name)
{
if (propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.0\\"))
{
targetsPathUpdated = true;
propertyNode.InnerText = propertyNode.InnerText.Replace("\\Microsoft\\WiX\\v3.0\\", "\\Microsoft\\WiX\\v3.x\\");
}
else if (propertyNode.InnerText.Contains("\\Microsoft\\WiX\\v3.5\\"))
{
targetsPathUpdated = true;
propertyNode.InnerText = propertyNode.InnerText.Replace("\\Microsoft\\WiX\\v3.5\\", "\\Microsoft\\WiX\\v3.x\\");
}
if (propertyNode.InnerText.Contains("\\Wix2010.targets"))
{
targetsPathUpdated = true;
propertyNode.InnerText = propertyNode.InnerText.Replace("\\Wix2010.targets", "\\Wix.targets");
}
}
}
}
}
if (targetsPathUpdated)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, fileName, WixStrings.WixTargetsPathUpdated);
}
xmlDoc.Save(fileName);
upgradedFullyQualifiedFileName = fileName;
}
return(VSConstants.S_OK);
}
public ProjectUpgradeLogger(IVsUpgradeLogger logger, string projectName, string projectFileName)
{
if (logger != null)
{
write = (errLevel, message) => logger.LogMessage((uint)errLevel, projectName, projectFileName, message) ;
}
else
{
write = delegate { };
}
}
public virtual int UpgradeProject(string projectFileName, uint upgradeFlag, string copyLocation, out string upgradeFullyQualifiedFileName, IVsUpgradeLogger logger, out int upgradeRequired,
out Guid newProjectFactory)
{
uint ignore;
this.UpgradeProject_CheckOnly(projectFileName, logger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
upgradeFullyQualifiedFileName = projectFileName;
return(VSConstants.S_OK);
}
string projectName = Path.GetFileNameWithoutExtension(projectFileName);
upgradeFullyQualifiedFileName = projectFileName;
// Query for edit
IVsQueryEditQuerySave2 queryEdit = site.GetService(typeof(SVsQueryEditQuerySave)) as IVsQueryEditQuerySave2;
if (queryEdit != null)
{
uint editVerdict;
uint queryEditMoreInfo;
const tagVSQueryEditFlags tagVSQueryEditFlags_QEF_AllowUnopenedProjects = (tagVSQueryEditFlags)0x80;
int hr = queryEdit.QueryEditFiles(
(uint)(tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting | tagVSQueryEditFlags.QEF_DisallowInMemoryEdits | tagVSQueryEditFlags_QEF_AllowUnopenedProjects),
1, new[] { projectFileName }, null, null, out editVerdict, out queryEditMoreInfo);
if (ErrorHandler.Failed(hr))
{
return(VSConstants.E_FAIL);
}
if (editVerdict != (uint)tagVSQueryEditResult.QER_EditOK)
{
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, projectFileName,
SR.GetString(SR.UpgradeCannotOpenProjectFileForEdit));
}
return(VSConstants.E_FAIL);
}
// If file was modified during the checkout, maybe upgrade is not needed
if ((queryEditMoreInfo & (uint)tagVSQueryEditResultFlags.QER_MaybeChanged) != 0)
{
this.UpgradeProject_CheckOnly(projectFileName, logger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_INFORMATIONAL, projectName, projectFileName,
SR.GetString(SR.UpgradeNoNeedToUpgradeAfterCheckout));
}
return(VSConstants.S_OK);
}
}
}
// Convert the project
Microsoft.Build.Conversion.ProjectFileConverter projectConverter = new Microsoft.Build.Conversion.ProjectFileConverter();
projectConverter.OldProjectFile = projectFileName;
projectConverter.NewProjectFile = projectFileName;
ProjectRootElement convertedProject = null;
try
{
convertedProject = projectConverter.ConvertInMemory();
}
catch (Exception ex)
{
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, projectFileName, ex.Message);
}
}
if (convertedProject != null)
{
this.m_lastUpgradedProjectFile = projectFileName;
foreach (ProjectPropertyElement property in convertedProject.Properties)
{
switch (property.Name)
{
case SCC_LOCAL_PATH:
this.m_sccLocalPath = property.Value;
break;
case SCC_AUX_PATH:
this.m_sccAuxPath = property.Value;
break;
case SCC_PROVIDER:
this.m_sccProvider = property.Value;
break;
case SCC_PROJECT_NAME:
this.m_sccProjectName = property.Value;
break;
default:
break;
}
}
try
{
convertedProject.Save(projectFileName);
}
catch (Exception ex)
{
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, projectName, projectFileName, ex.Message);
}
return(VSConstants.E_FAIL);
}
if (logger != null)
{
logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_STATUSMSG, projectName, projectFileName,
SR.GetString(SR.UpgradeSuccessful));
}
return(VSConstants.S_OK);
}
this.m_lastUpgradedProjectFile = null;
upgradeFullyQualifiedFileName = "";
return(VSConstants.E_FAIL);
}
/// <inheritdoc />
public int UpgradeProject_CheckOnly(string bstrFileName, IVsUpgradeLogger pLogger, out int pUpgradeRequired,
out Guid pguidNewProjectFactory, out uint pUpgradeProjectCapabilityFlags)
{
XNamespace msbuild = "http://schemas.microsoft.com/developer/msbuild/2003";
Version toolsVersion, projectVersion;
pUpgradeRequired = 0;
pguidNewProjectFactory = this.GetType().GUID;
pUpgradeProjectCapabilityFlags = PUVFF_SXSBACKUP;
XDocument project = XDocument.Load(bstrFileName);
// Check the ToolsVerion attribute first. It should be 4.0 or later
var toolsVersionAttr = project.Root.Attribute("ToolsVersion");
if(toolsVersionAttr == null || String.IsNullOrWhiteSpace(toolsVersionAttr.Value) ||
!Version.TryParse(toolsVersionAttr.Value, out toolsVersion) || toolsVersion.Major < 4)
pUpgradeRequired = 1;
else
{
// Next, see if the SHFB schema version is current
XElement property = project.Root.Descendants(msbuild + "SHFBSchemaVersion").FirstOrDefault();
if(property == null || !Version.TryParse(property.Value, out projectVersion) ||
projectVersion < SandcastleProject.SchemaVersion)
pUpgradeRequired = 1;
}
// If it's of a higher version, we'll let the project node catch it. Despite what the documentation
// for this interface says, any value returned from here appears to be ignored and you cannot prevent
// it from either loading or continuing with the conversion when the shell calls it.
return VSConstants.S_OK;
}
void IVsProjectUpgradeViaFactory4.UpgradeProject_CheckOnly(string projectFileName, IVsUpgradeLogger upgradeLogger, out uint upgradeRequired, out Guid newProjectFactory, out uint upgradeCapabilityFlags)
{
__VSPPROJECTUPGRADEVIAFACTORYREPAIRFLAGS upgradeRequiredFlag;
DoUpgradeProject_CheckOnly(projectFileName, upgradeLogger, out upgradeRequiredFlag, out newProjectFactory, out upgradeCapabilityFlags);
upgradeRequired = (uint)upgradeRequiredFlag;
}
public UpgradeLogger(string projectFile, IVsUpgradeLogger logger)
{
this._projectFile = projectFile;
this._projectName = Path.GetFileNameWithoutExtension(projectFile);
this._logger = logger;
}
public virtual int UpgradeProject(
string projectFilePath,
uint upgradeFlag,
string initialCopyLocation,
out string upgradeFullyQualifiedFileName,
IVsUpgradeLogger upgradeLogger,
out int upgradeRequired,
out Guid newProjectFactory
)
{
// initialize out params in case of failure
upgradeFullyQualifiedFileName = null;
upgradeRequired = 0;
newProjectFactory = Guid.Empty;
__VSPPROJECTUPGRADEVIAFACTORYFLAGS flag;
string copyLocation = initialCopyLocation;
var r = NormalizeUpgradeFlag(upgradeFlag, out flag, ref copyLocation);
if (r != VSConstants.S_OK)
{
return r;
}
string projectName = Path.GetFileNameWithoutExtension(projectFilePath);
var logger = new ProjectUpgradeLogger(upgradeLogger, projectName, projectFilePath);
uint ignore;
((IVsProjectUpgradeViaFactory)this).UpgradeProject_CheckOnly(projectFilePath, upgradeLogger, out upgradeRequired, out newProjectFactory, out ignore);
// no upgrade required and not 'copy-backup'
if (upgradeRequired == 0 && !HasCopyBackupFlag(flag))
{
//Write an informational message "No upgrade required for project foo"?
logger.LogInfo(SR.GetString(SR.ProjectConversionNotRequired));
logger.LogInfo(SR.GetString(SR.ConversionNotRequired));
upgradeFullyQualifiedFileName = projectFilePath;
return VSConstants.S_OK;
}
// upgrade is not required but backup may still be needed
var projectFileName = Path.GetFileName(projectFilePath);
upgradeFullyQualifiedFileName = projectFilePath;
if (HasSxSBackupFlag(flag))
{
// for SxS call use location near the original file
copyLocation = Path.GetDirectoryName(projectFilePath);
}
// workflow is taken from vsprjfactory.cpp (vsproject\vsproject)
// 1. convert the project (in-memory)
// 2. save SCC related info
// 3. use data stored on step 2 in GetSccInfo calls (during QueryEditFiles)
// 4. if succeeded - save project on disk
// F# doesn't use .user file so all related code is skipped
try
{
// load MSBuild project in memory: this will be needed in all cases not depending whether upgrade is required or not
// we use this project to determine the set of files to copy
ProjectRootElement convertedProject = ConvertProject(projectFilePath, logger);
if (convertedProject == null)
{
throw new ProjectUpgradeFailedException();
}
// OK, we need upgrade, save SCC info and ask if project file can be edited
if (upgradeRequired != 0)
{
// 2. save SCC related info
this.m_lastUpgradedProjectFile = projectFilePath;
foreach (var property in convertedProject.Properties)
{
switch (property.Name)
{
case SCC_LOCAL_PATH:
this.m_sccLocalPath = property.Value;
break;
case SCC_AUX_PATH:
this.m_sccAuxPath = property.Value;
break;
case SCC_PROVIDER:
this.m_sccProvider = property.Value;
break;
case SCC_PROJECT_NAME:
this.m_sccProjectName = property.Value;
break;
default:
break;
}
}
// 3. Query for edit (this call may query information stored on previous step)
IVsQueryEditQuerySave2 queryEdit = site.GetService(typeof(SVsQueryEditQuerySave)) as IVsQueryEditQuerySave2;
if (queryEdit != null)
{
uint editVerdict;
uint queryEditMoreInfo;
const tagVSQueryEditFlags tagVSQueryEditFlags_QEF_AllowUnopenedProjects = (tagVSQueryEditFlags)0x80;
int hr = queryEdit.QueryEditFiles(
(uint)(tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting | tagVSQueryEditFlags.QEF_DisallowInMemoryEdits | tagVSQueryEditFlags_QEF_AllowUnopenedProjects),
1, new[] { projectFilePath }, null, null, out editVerdict, out queryEditMoreInfo);
if (ErrorHandler.Failed(hr))
{
throw new ProjectUpgradeFailedException();
}
if (editVerdict != (uint)tagVSQueryEditResult.QER_EditOK)
{
throw new ProjectUpgradeFailedException(SR.GetString(SR.UpgradeCannotOpenProjectFileForEdit));
}
// If file was modified during the checkout, maybe upgrade is not needed
if ((queryEditMoreInfo & (uint)tagVSQueryEditResultFlags.QER_MaybeChanged) != 0)
{
((IVsProjectUpgradeViaFactory)this).UpgradeProject_CheckOnly(projectFilePath, upgradeLogger, out upgradeRequired, out newProjectFactory, out ignore);
if (upgradeRequired == 0)
{
if (logger != null)
{
logger.LogInfo(SR.GetString(SR.UpgradeNoNeedToUpgradeAfterCheckout));
}
return VSConstants.S_OK;
}
}
}
}
// 3.1 copy backup
BackupProjectFilesIfNeeded(projectFilePath, logger, flag, copyLocation, convertedProject);
// 4. if we have performed upgrade - save project to disk
if (upgradeRequired != 0)
{
try
{
convertedProject.Save(projectFilePath);
}
catch (Exception ex)
{
throw new ProjectUpgradeFailedException(ex.Message, ex);
}
}
// 821083: "Converted" should NOT be localized - it is referenced in the XSLT used to display the UpgradeReport
logger.LogStatus("Converted");
}
catch (ProjectUpgradeFailedException ex)
{
var exception = ex.InnerException ?? ex;
if (exception != null && !string.IsNullOrEmpty(exception.Message))
logger.LogError(exception.Message);
upgradeFullyQualifiedFileName = "";
m_lastUpgradedProjectFile = null;
return VSConstants.E_FAIL;
}
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.
var hr = ((IVsProjectUpgradeViaFactory)this).UpgradeProject_CheckOnly(
bstrFileName,
pLogger,
out pUpgradeRequired,
out pguidNewProjectFactory,
out var dummy
);
if (!ErrorHandler.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 (var 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
//}
}
if (this.site.GetService(typeof(SVsQueryEditQuerySave)) is IVsQueryEditQuerySave2 queryEdit)
{
var tagVSQueryEditFlags_QEF_AllowUnopenedProjects = (tagVSQueryEditFlags)0x80;
ErrorHandler.ThrowOnFailure(queryEdit.QueryEditFiles(
(uint)(tagVSQueryEditFlags.QEF_ForceEdit_NoPrompting |
tagVSQueryEditFlags.QEF_DisallowInMemoryEdits |
tagVSQueryEditFlags_QEF_AllowUnopenedProjects),
1,
new[] { bstrFileName },
null,
null,
out var editVerdict,
out var 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 (!ErrorHandler.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)
{
this._cachedSccProject = bstrFileName;
this._cachedSccProjectName = string.Empty;
this._cachedSccAuxPath = string.Empty;
this._cachedSccLocalPath = string.Empty;
this._cachedSccProvider = string.Empty;
foreach (var property in projectXml.Properties)
{
switch (property.Name)
{
case ProjectFileConstants.SccProjectName:
this._cachedSccProjectName = property.Value;
break;
case ProjectFileConstants.SccAuxPath:
this._cachedSccAuxPath = property.Value;
break;
case ProjectFileConstants.SccLocalPath:
this._cachedSccLocalPath = property.Value;
break;
case ProjectFileConstants.SccProvider:
this._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) when(!ExceptionExtensions.IsCriticalException(ex))
{
logger.Log(__VSUL_ERRORLEVEL.VSUL_ERROR, SR.GetString(SR.UnexpectedUpgradeError, ex.Message));
try
{
ActivityLog.LogError(GetType().FullName, ex.ToString());
}
catch (InvalidOperationException)
{
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(ex.ToString());
}
return(VSConstants.E_FAIL);
}
}
int IVsSolutionEventsProjectUpgrade.OnAfterUpgradeProject(IVsHierarchy pHierarchy, uint fUpgradeFlag, string bstrCopyLocation, SYSTEMTIME stUpgradeTime, IVsUpgradeLogger pLogger)
{
Debug.Assert(pHierarchy != null);
Project upgradedProject = VsUtility.GetProjectFromHierarchy(pHierarchy);
if (upgradedProject != null)
{
IList <IPackage> packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(upgradedProject);
if (!packagesToBeReinstalled.IsEmpty())
{
pLogger.LogMessage((int)__VSUL_ERRORLEVEL.VSUL_ERROR, upgradedProject.Name, upgradedProject.Name,
String.Format(CultureInfo.CurrentCulture, Resources.ProjectUpgradeAndRetargetErrorMessage, String.Join(", ", packagesToBeReinstalled.Select(p => p.Id))));
}
}
return(VSConstants.S_OK);
}
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));
try {
ActivityLog.LogError(GetType().FullName, ex.ToString());
} catch (InvalidOperationException) {
// Cannot log to ActivityLog. This may occur if we are
// outside of VS right now (for example, unit tests).
System.Diagnostics.Trace.TraceError(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;
}
