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