/// <summary> /// Copies the source to the destination. /// </summary> /// <remarks> /// If the source is a directory, it is copied recursively. /// </remarks> /// <param name="p_tfmFileManager">The transactional file manager to use to copy the files.</param> /// <param name="p_strSource">The path from which to copy.</param> /// <param name="p_strDestination">The path to which to copy.</param> /// <param name="p_fncCopyCallback">A callback method that notifies the caller when a file has been copied, /// and provides the opportunity to cancel the copy operation.</param> /// <returns><c>true</c> if the copy operation wasn't cancelled; <c>false</c> otherwise.</returns> public static bool Copy(TxFileManager p_tfmFileManager, string p_strSource, string p_strDestination, Func<string, bool> p_fncCopyCallback) { if (File.Exists(p_strSource)) { if (!Directory.Exists(Path.GetDirectoryName(p_strDestination))) p_tfmFileManager.CreateDirectory(Path.GetDirectoryName(p_strDestination)); p_tfmFileManager.Copy(p_strSource, p_strDestination, true); if ((p_fncCopyCallback != null) && p_fncCopyCallback(p_strSource)) return false; } else if (Directory.Exists(p_strSource)) { if (!Directory.Exists(p_strDestination)) p_tfmFileManager.CreateDirectory(p_strDestination); string[] strFiles = Directory.GetFiles(p_strSource); foreach (string strFile in strFiles) { p_tfmFileManager.Copy(strFile, Path.Combine(p_strDestination, Path.GetFileName(strFile)), true); if ((p_fncCopyCallback != null) && p_fncCopyCallback(strFile)) return false; } string[] strDirectories = Directory.GetDirectories(p_strSource); foreach (string strDirectory in strDirectories) if (!Copy(strDirectory, Path.Combine(p_strDestination, Path.GetFileName(strDirectory)), p_fncCopyCallback)) return false; } return true; }
/// <summary> /// A simple constructor that initializes the object with its dependencies. /// </summary> /// <param name="p_gmiGameModeInfo">The environment info of the current game mode.</param> /// <param name="p_modMod">The mod being installed.</param> /// <param name="p_ilgInstallLog">The install log to use to log file installations.</param> /// <param name="p_pmgPluginManager">The plugin manager.</param> /// <param name="p_dfuDataFileUtility">The utility class to use to work with data files.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> /// <param name="p_UsesPlugins">Game using plugin or mods (True for plugins).</param> public ModFileUpgradeInstaller(IGameModeEnvironmentInfo p_gmiGameModeInfo, IMod p_modMod, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager, IDataFileUtil p_dfuDataFileUtility, TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate, bool p_UsesPlugins) : base(p_gmiGameModeInfo, p_modMod, p_ilgInstallLog, p_pmgPluginManager, p_dfuDataFileUtility, p_tfmFileManager, p_dlgOverwriteConfirmationDelegate, p_UsesPlugins, null) { OriginallyInstalledFiles = new Set<string>(StringComparer.OrdinalIgnoreCase); foreach (string strFile in InstallLog.GetInstalledModFiles(Mod)) OriginallyInstalledFiles.Add(strFile.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar)); }
/// <summary> /// A simple constructor that initializes the object with its dependencies. /// </summary> /// <param name="p_modMod">The mod being installed.</param> /// <param name="p_ilgInstallLog">The install log to use to log file installations.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> public IniInstaller(IMod p_modMod, IInstallLog p_ilgInstallLog, TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) { TouchedFiles = new Set<string>(StringComparer.OrdinalIgnoreCase); Mod = p_modMod; InstallLog = p_ilgInstallLog; TransactionalFileManager = p_tfmFileManager; m_dlgOverwriteConfirmationDelegate = p_dlgOverwriteConfirmationDelegate ?? ((s, b, m) => OverwriteResult.No); }
/// <summary> /// A simple constructor that initializes the object with its dependencies. /// </summary> /// <param name="p_gmiGameModeInfo">The environment info of the current game mode.</param> /// <param name="p_modMod">The mod being installed.</param> /// <param name="p_ilgInstallLog">The install log to use to log file installations.</param> /// <param name="p_pmgPluginManager">The plugin manager.</param> /// <param name="p_dfuDataFileUtility">The utility class to use to work with data files.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> /// <param name="p_UsesPlugins">Whether the file is a mod or a plugin.</param> public ModFileInstaller(IGameModeEnvironmentInfo p_gmiGameModeInfo, IMod p_modMod, IInstallLog p_ilgInstallLog, IPluginManager p_pmgPluginManager, IDataFileUtil p_dfuDataFileUtility, TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate, bool p_UsesPlugins) { GameModeInfo = p_gmiGameModeInfo; Mod = p_modMod; InstallLog = p_ilgInstallLog; PluginManager = p_pmgPluginManager; DataFileUtility = p_dfuDataFileUtility; TransactionalFileManager = p_tfmFileManager; m_dlgOverwriteConfirmationDelegate = p_dlgOverwriteConfirmationDelegate ?? ((s, b, m) => OverwriteResult.No); IsPlugin = p_UsesPlugins; }
/// <summary> /// Called to perform the upgrade. /// </summary> /// <remarks> /// Sets up the resources required to upgrade the install log. /// </remarks> /// <param name="p_mdrManagedModRegistry">The <see cref="ModRegistry"/> that contains the list /// of managed mods.</param> /// <param name="p_strModInstallDirectory">The path of the directory where all of the mods are installed.</param> /// <param name="p_strLogPath">The path from which to load the install log information.</param> public void Upgrade(string p_strLogPath, string p_strModInstallDirectory, ModRegistry p_mdrManagedModRegistry) { Trace.WriteLine("Beginning Install Log Upgrade."); m_tfmFileManager = new TxFileManager(); using (TransactionScope tsTransaction = new TransactionScope()) { m_tfmFileManager.Snapshot(p_strLogPath); Start(p_strLogPath, p_strModInstallDirectory, p_mdrManagedModRegistry); tsTransaction.Complete(); m_tfmFileManager = null; } }
public void RenameImageAndUsages(PlantPhoto plantPhoto) { var dateString = _now.ToString("yyyy-MM-dd HH:mm:ss.fff"); var fileManager = new TxFileManager(); try { using (var conn = new SqlConnection(_settings.ConnectionString)) using (var scope = new TransactionScope()) { conn.Open(); conn.Execute(_photoUpdateQuery, new { OldPhotoId = plantPhoto.PhotoId, NewPhotoId = plantPhoto.PhotoId.AddTif(), NewUpdatedAt = _now }); conn.Execute(_usageUpdateQuery, new { plantPhoto.PhotoId, NewPhotoId = plantPhoto.PhotoId.AddTif() }); foreach (var imageRoot in _settings.ImageRoots) { var imagePath = plantPhoto.GetActualImagePath(imageRoot); var newPath = plantPhoto.GetReplacementPath(imageRoot, _settings.TargetExtension); if (File.Exists(imagePath)) { fileManager.Move(imagePath, newPath); } } foreach (var thumbnailRoot in _settings.ThumbnailRoots) { var thumbPath = plantPhoto.GetThumbnailPath(thumbnailRoot); var newPath = plantPhoto.GetReplacementPath(thumbnailRoot, _settings.TargetExtension, true); if (File.Exists(thumbPath)) { fileManager.Move(thumbPath, newPath); } } scope.Complete(); var message = string.Format("{0}\t{0}{1}\t{2}", plantPhoto.PhotoId, _settings.TargetExtension, dateString); Logger.Info(message); } } catch (TransactionAbortedException trex) { Logger.Error(string.Format("{0}\t{1}", plantPhoto.PhotoId, trex.Message.Replace(Environment.NewLine, " "))); } catch (Exception exc) { Logger.Error(string.Format("{0}\t{1}", plantPhoto.PhotoId, exc.Message.Replace(Environment.NewLine, " "))); } }
private static void WriteSafeFile() { try { Thread.Sleep(100); IFileManager fileManager = new TxFileManager(); using (TransactionScope scope1 = new TransactionScope()) { File.Delete(TEMP); FileInfo fi = new FileInfo(ORIGINAL); fi.CopyTo(TEMP); Console.WriteLine("Created temp"); File.Replace(TEMP, ORIGINAL, "monkey"); //fileManager.Copy(ORIGINAL,TEMP,true); //Console.WriteLine("Created temp"); //fileManager.Delete(ORIGINAL); //Console.WriteLine("Deleted original"); //fileManager.Move(TEMP,ORIGINAL); //Console.WriteLine("Rename temop to original"); scope1.Complete(); } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
/// <summary> /// Called to perform the upgrade. /// </summary> /// <remarks> /// Sets up the resources required to upgrade the install log, and then /// call <see cref="DoUpgrade()" /> so implementers can do the upgrade. /// </remarks> /// <returns> /// <lang langref="true" /> if the upgrade completed; <lang langref="false" /> /// if the user cancelled. /// </returns> internal bool PerformUpgrade() { FileManager = new TxFileManager(); var booComplete = false; using (var tsTransaction = new TransactionScope()) { FileManager.Snapshot(InstallLog.Current.InstallLogPath); using (ProgressWorker = new BackgroundWorkerProgressDialog(DoUpgrade)) { ProgressWorker.OverallMessage = "Upgrading FOMM Files"; if (ProgressWorker.ShowDialog() == DialogResult.OK) { booComplete = true; tsTransaction.Complete(); } } FileManager = null; } return booComplete; }
/// <summary> /// Registers the given mods with the registry. /// </summary> /// <param name="p_lstAddedMods">The mods that have been added and need to be registered with the manager.</param> protected void RegisterModFiles(IList<string> p_lstAddedMods) { OverallMessage = "Adding mod to manager..."; ItemMessage = "Registering Mods..."; if (p_lstAddedMods != null) { ItemProgress = 0; ItemProgressMaximum = p_lstAddedMods.Count; foreach (string strMod in p_lstAddedMods) { OverallMessage = String.Format("Adding mod: {0}", strMod); try { if (m_mrgModRegistry.RegisteredMods.SingleOrDefault(x => x.Filename == strMod) == null) { if (m_eifEnvironmentInfo.Settings.AddMissingInfoToMods) m_mrgModRegistry.RegisterMod(strMod, ModInfo); else m_mrgModRegistry.RegisterMod(strMod); } if (m_rmmReadMeManager != null) { TxFileManager tfmFileManager = new TxFileManager(); string strModFolderPath = m_gmdGameMode.GameModeEnvironmentInfo.ModDirectory; if (m_rmmReadMeManager.VerifyReadMeFile(tfmFileManager, strMod)) m_rmmReadMeManager.SaveReadMeConfig(); } } catch (Exception ex) { OverallMessage = String.Format("Error registering this mod: {1}" + Environment.NewLine + "Error: {0} ", ex.Message, GetModDisplayName()); ItemMessage = "Error registering mod."; Status = TaskStatus.Error; OnTaskEnded(null, null); return; } StepItemProgress(); } } StepOverallProgress(); OverallMessage = String.Format("{0} has been added", GetModDisplayName()); ItemMessage = "Finished adding mod."; Status = TaskStatus.Complete; OnTaskEnded(null, null); }
/// <summary> /// A simple constructor that initializes the object with its dependencies. /// </summary> /// <param name="p_gmiGameModeInfo">The environment info of the current game mode.</param> /// <param name="p_modMod">The mod being installed.</param> /// <param name="p_ilgInstallLog">The install log to use to log file installations.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_futFileUtility">The file utility class.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> public GamebryoGameSpecificValueUpgradeInstaller(IMod p_modMod, IGameModeEnvironmentInfo p_gmiGameModeInfo, IInstallLog p_ilgInstallLog, TxFileManager p_tfmFileManager, FileUtil p_futFileUtility, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) :base(p_modMod, p_gmiGameModeInfo, p_ilgInstallLog, p_tfmFileManager, p_futFileUtility, p_dlgOverwriteConfirmationDelegate) { OriginallyInstalledEdits = new Set<string>(); OriginallyInstalledEdits.AddRange(InstallLog.GetInstalledGameSpecificValueEdits(Mod)); }
/// <summary> /// Runs the install script. /// </summary> /// <remarks> /// This contains the boilerplate code that needs to be done for all install-type /// scripts. Implementers must override the <see cref="DoScript()" /> method to /// implement their script-specific functionality. /// </remarks> /// <param name="p_booSuppressSuccessMessage"> /// Indicates whether to /// supress the success message. This is useful for batch installs. /// </param> /// <seealso cref="DoScript()" /> protected bool Run(bool p_booSuppressSuccessMessage, bool p_booSetFOModReadOnly) { var booSuccess = false; if (CheckAlreadyDone()) { booSuccess = true; } if (!booSuccess) { try { //the install process modifies INI and config files. // if multiple sources (i.e., installs) try to modify // these files simultaneously the outcome is not well known // (e.g., one install changes SETTING1 in a config file to valueA // while simultaneously another install changes SETTING1 in the // file to value2 - after each install commits its changes it is // not clear what the value of SETTING1 will be). // as a result, we only allow one mod to be installed at a time, // hence the lock. lock (objInstallLock) { using (var tsTransaction = new TransactionScope()) { m_tfmFileManager = new TxFileManager(); using (Script = CreateInstallScript()) { var booCancelled = false; if (p_booSetFOModReadOnly && (Fomod != null)) { if (Fomod.ReadOnlyInitStepCount > 1) { using (m_bwdProgress = new BackgroundWorkerProgressDialog(BeginFOModReadOnlyTransaction)) { m_bwdProgress.OverallMessage = "Preparing FOMod..."; m_bwdProgress.ShowItemProgress = false; m_bwdProgress.OverallProgressMaximum = Fomod.ReadOnlyInitStepCount; m_bwdProgress.OverallProgressStep = 1; try { Fomod.ReadOnlyInitStepStarted += Fomod_ReadOnlyInitStepStarted; Fomod.ReadOnlyInitStepFinished += Fomod_ReadOnlyInitStepFinished; if (m_bwdProgress.ShowDialog() == DialogResult.Cancel) { booCancelled = true; } } finally { Fomod.ReadOnlyInitStepStarted -= Fomod_ReadOnlyInitStepStarted; Fomod.ReadOnlyInitStepFinished -= Fomod_ReadOnlyInitStepFinished; } } } else { Fomod.BeginReadOnlyTransaction(); } } if (!booCancelled) { booSuccess = DoScript(); if (booSuccess) { tsTransaction.Complete(); } } } } } } catch (Exception e) { var stbError = new StringBuilder(e.Message); if (e is FileNotFoundException) { stbError.Append(" (" + ((FileNotFoundException) e).FileName + ")"); } if (e is IllegalFilePathException) { stbError.Append(" (" + ((IllegalFilePathException) e).Path + ")"); } if (e.InnerException != null) { stbError.AppendLine().AppendLine(e.InnerException.Message); } if (e is RollbackException) { foreach (var erm in ((RollbackException) e).ExceptedResourceManagers) { stbError.AppendLine(erm.ResourceManager.ToString()); stbError.AppendLine(erm.Exception.Message); if (erm.Exception.InnerException != null) { stbError.AppendLine(erm.Exception.InnerException.Message); } } } var strMessage = String.Format(ExceptionMessage, stbError); MessageBox.Show(strMessage, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return false; } finally { m_tfmFileManager = null; m_ilmModInstallLog = null; if (Fomod != null) { Fomod.EndReadOnlyTransaction(); } } } if (booSuccess && !p_booSuppressSuccessMessage && !String.IsNullOrEmpty(SuccessMessage)) { MessageBox.Show(SuccessMessage, "Success", MessageBoxButtons.OK, MessageBoxIcon.Information); } else if (!booSuccess && !String.IsNullOrEmpty(FailMessage)) { MessageBox.Show(FailMessage, "Failure", MessageBoxButtons.OK, MessageBoxIcon.Error); } return booSuccess; }
public void Export(int scanFileID, string userName, string computer, string comment = null) { //kontrola vstupnich parametru if (scanFileID == 0) throw new ArgumentException("Neplatný parametr identifikátor souboru."); if (String.IsNullOrEmpty(userName)) throw new ArgumentException("Neplatný parametr jméno uživatele."); if (String.IsNullOrEmpty(computer)) throw new ArgumentException("Neplatný parametr název počítače."); ScanFileRepository repository = new ScanFileRepository(); //kontrola existence naskenovaneho souboru ScanFile result = repository.Select(scanFileID); if (result == null) throw new ApplicationException(String.Format("Soubor (ID={0}) neexistuje.", scanFileID)); //kontrola ulozenych parametrov if (result.Status != StatusCode.Complete) throw new ApplicationException(String.Format("Soubor (ID={0}) nemá status dokončeno.", result.ScanFileID)); //export ALEPH TxFileManager fileMgr = new TxFileManager(); string filePath = null; string ftpPath = null; using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required)) { try { filePath = result.GetScanFilePath(); switch (result.PartOfBook) { case PartOfBook.FrontCover: ftpPath = Path.Combine(result.Book.Catalogue.GetDirectoryFTP(true), result.FileName); fileMgr.Copy(filePath, ftpPath, true); break; case PartOfBook.TableOfContents: if (result.UseOCR) { string txtFilePath = Path.Combine(result.Book.Catalogue.GetDirectoryFTP(true), result.TxtFileName); fileMgr.WriteAllText(txtFilePath, result.OcrText); } string pdfFilePath = result.GetOcrFilePath(); ftpPath = Path.Combine(result.Book.Catalogue.GetDirectoryFTP(true), result.OcrFileName); fileMgr.Copy(pdfFilePath, ftpPath, true); break; default: break; } } catch (Exception ex) { throw new ApplicationException(String.Format("Nepodařilo se exportovat soubor '{0}' na FTP: {1}.", filePath, ex.Message)); } //ulozenie operace do databazy try { result.Modified = DateTime.Now; result.Comment = (comment != null ? comment.Left(1000) : null); result.Status = StatusCode.Exported; repository.Update(result); LogOperation(result.ScanFileID, userName, computer, result.Modified, result.Comment, result.Status); ts.Complete(); } catch (Exception ex) { throw new ApplicationException(String.Format("Nepodařilo se uložit data souboru (ID={0}) do databáze.", scanFileID), ex); } } }
/// <summary> /// A simple constructor that initializes the object with its dependencies. /// </summary> /// <param name="p_gmiGameModeInfo">The environment info of the current game mode.</param> /// <param name="p_modMod">The mod being installed.</param> /// <param name="p_ilgInstallLog">The install log to use to log file installations.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_futFileUtility">The file utility class.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> public GamebryoGameSpecificValueInstaller(IMod p_modMod, IGameModeEnvironmentInfo p_gmiGameModeInfo, IInstallLog p_ilgInstallLog, TxFileManager p_tfmFileManager, FileUtil p_futFileUtility, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) { TouchedFiles = new Set<string>(StringComparer.OrdinalIgnoreCase); Mod = p_modMod; GameModeInfo = p_gmiGameModeInfo; InstallLog = p_ilgInstallLog; TransactionalFileManager = p_tfmFileManager; FileUtility = p_futFileUtility; m_dlgOverwriteConfirmationDelegate = p_dlgOverwriteConfirmationDelegate; }
/// <summary> /// Gets the installer to use to upgrade game specific values. /// </summary> /// <param name="p_modMod">The mod being upgraded.</param> /// <param name="p_ilgInstallLog">The install log to use to log the installation of the game specific values.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <returns>The installer to use to manage game specific values, or <c>null</c> if the game mode does not /// install any game specific values.</returns> /// <param name="p_futFileUtility">The file utility class.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> public override IGameSpecificValueInstaller GetGameSpecificValueUpgradeInstaller(IMod p_modMod, IInstallLog p_ilgInstallLog, TxFileManager p_tfmFileManager, FileUtil p_futFileUtility, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) { return new GamebryoGameSpecificValueInstaller(p_modMod, GameModeEnvironmentInfo, p_ilgInstallLog, p_tfmFileManager, p_futFileUtility, p_dlgOverwriteConfirmationDelegate); }
/// <summary> /// This performs the mirgration. /// </summary> /// <param name="p_objArgs">The path to the old FOMM installation.</param> protected void DoMigration(object p_objArgs) { var strOldFOMMLocation = (string) p_objArgs; var tfmFileManager = new TxFileManager(); //copy the mods //do we need to copy? if ( !Path.Combine(strOldFOMMLocation, "mods") .Equals(Program.GameMode.ModDirectory, StringComparison.InvariantCultureIgnoreCase)) { var lstModFiles = new List<string>(); lstModFiles.AddRange(Directory.GetFiles(Path.Combine(strOldFOMMLocation, "mods"), "*.fomod")); lstModFiles.AddRange(Directory.GetFiles(Path.Combine(strOldFOMMLocation, "mods"), "*.xml")); m_bwdProgress.ItemMessage = "Copying mods..."; m_bwdProgress.ItemProgressMaximum = lstModFiles.Count; m_bwdProgress.ItemProgress = 0; foreach (var strMod in lstModFiles) { var strModFileName = Path.GetFileName(strMod); m_bwdProgress.ItemMessage = "Copying mods (" + strModFileName + ")..."; tfmFileManager.Copy(strMod, Path.Combine(Program.GameMode.ModDirectory, strModFileName), true); //File.Copy(strMod, Path.Combine(Program.GameMode.ModDirectory, Path.GetFileName(strMod))); m_bwdProgress.StepItemProgress(); if (m_bwdProgress.Cancelled()) { return; } } } m_bwdProgress.StepOverallProgress(); //copy overwrites folder //do we need to? if ( !Path.Combine(strOldFOMMLocation, "overwrites") .Equals(Program.GameMode.OverwriteDirectory, StringComparison.InvariantCultureIgnoreCase)) { var strOverwriteFiles = Directory.GetFiles(Path.Combine(strOldFOMMLocation, "overwrites"), "*.*", SearchOption.AllDirectories); m_bwdProgress.ItemMessage = "Copying overwrites..."; m_bwdProgress.ItemProgressMaximum = strOverwriteFiles.Length; m_bwdProgress.ItemProgress = 0; FileUtil.Copy(tfmFileManager, Path.Combine(strOldFOMMLocation, "overwrites"), Program.GameMode.OverwriteDirectory, OverwriteFileCopied); } m_bwdProgress.StepOverallProgress(); //copy install logs //do we need to? if ( !Path.Combine(strOldFOMMLocation, "fomm") .Equals(Program.GameMode.InstallInfoDirectory, StringComparison.InvariantCultureIgnoreCase)) { var strMiscFiles = Directory.GetFiles(Path.Combine(strOldFOMMLocation, "fomm"), "InstallLog.xml*"); m_bwdProgress.ItemMessage = "Copying info files..."; m_bwdProgress.ItemProgressMaximum = strMiscFiles.Length; m_bwdProgress.ItemProgress = 0; foreach (var strFile in strMiscFiles) { tfmFileManager.Copy(strFile, Path.Combine(Program.GameMode.InstallInfoDirectory, Path.GetFileName(strFile)), true); m_bwdProgress.StepItemProgress(); if (m_bwdProgress.Cancelled()) { return; } } } m_bwdProgress.StepOverallProgress(); }
//[Obsolete] //public void Export2(int scanFileID, string ftpPath) //{ // //kontrola vstupnich parametru // if (scanFileID == 0) // throw new ArgumentException("Neplatný parametr identifikátor souboru."); // ScanFileRepository repository = new ScanFileRepository(); // //kontrola existence naskenovaneho souboru // ScanFile result = repository.Select(scanFileID); // if (result == null) // throw new ApplicationException(String.Format("Soubor (ID={0}) neexistuje.", scanFileID)); // //kontrola ulozenych parametrov // if (result.Status != StatusCode.Exported) // throw new ApplicationException(String.Format("Soubor (ID={0}) nemá status exportováno.", result.ScanFileID)); // //export ALEPH // TxFileManager fileMgr = new TxFileManager(); // string filePath = null; // try // { // filePath = result.GetScanFilePath(); // string ftpFilePath = null; // switch (result.PartOfBook) // { // case PartOfBook.FrontCover: // ftpFilePath = Path.Combine(ftpPath, result.FileName); // fileMgr.Copy(filePath, ftpFilePath, true); // break; // case PartOfBook.TableOfContents: // if (result.UseOCR) // { // string txtFilePath = Path.Combine(ftpPath, result.TxtFileName); // fileMgr.WriteAllText(txtFilePath, result.OcrText); // } // string pdfFilePath = result.GetOcrFilePath(); // ftpFilePath = Path.Combine(ftpPath, result.OcrFileName); // fileMgr.Copy(pdfFilePath, ftpFilePath, true); // break; // default: // break; // } // } // catch (Exception ex) // { // throw new ApplicationException(String.Format("Nepodařilo se exportovat soubor '{0}' na FTP: {1}.", filePath, ex.Message)); // } //} public void Delete(int scanFileID, string userName) { //kontrola vstupnich parametru if (scanFileID == 0) throw new ArgumentException("Neplatný parametr identifikátor souboru."); if (String.IsNullOrEmpty(userName)) throw new ArgumentException("Neplatný parametr jméno uživatele."); ScanFileRepository repository = new ScanFileRepository(); //kontrola existence naskenovaneho souboru ScanFile result = repository.Select(scanFileID); if (result == null) throw new ApplicationException(String.Format("Soubor (ID={0}) neexistuje.", scanFileID)); //kontrola ulozenych parametrov if (result.Status == StatusCode.Exported) throw new ApplicationException(String.Format("Soubor (ID={0}) má status exportován.", result.ScanFileID)); //vymazanie suboru naskenovaneho obrazku TxFileManager fileMgr = new TxFileManager(); string filePath = null; //ulozenie operace do databazy using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required)) { try { filePath = result.GetScanFilePath(); if (fileMgr.FileExists(filePath)) fileMgr.Delete(filePath); filePath = result.GetOcrFilePath(); if (fileMgr.FileExists(filePath)) fileMgr.Delete(filePath); } catch (Exception ex) { throw new ApplicationException(String.Format("Nepodařilo se vymazat soubor '{0}' z disku: {1}.", filePath, ex.Message)); } try { repository.Delete(result); Book book = BookComponent.Instance.GetByID(result.BookID); if (book != null && (book.ScanFiles == null || book.ScanFiles.Count == 0)) { BookComponent.Instance.Delete(result.BookID, userName); } ts.Complete(); } catch (Exception ex) { throw new ApplicationException(String.Format("Nepodařilo se vymazat data souboru (ID={0}) z databáze.", scanFileID), ex); } } }
/// <summary> /// Creates the file installer to use to install the mod's ini edits. /// </summary> /// <remarks> /// This returns the regular <see cref="IniInstaller"/>. /// </remarks> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> /// <returns>The file installer to use to install the mod's files.</returns> protected virtual IIniInstaller CreateIniInstaller(TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) { return new IniInstaller(Mod, ModInstallLog, p_tfmFileManager, p_dlgOverwriteConfirmationDelegate); }
/// <summary> /// Runs the install tasks. /// </summary> protected void RunTasks() { //the install process modifies INI and config files. // if multiple sources (i.e., installs) try to modify // these files simultaneously the outcome is not well known // (e.g., one install changes SETTING1 in a config file to valueA // while simultaneously another install changes SETTING1 in the // file to value2 - after each install commits its changes it is // not clear what the value of SETTING1 will be). // as a result, we only allow one mod to be installed at a time, // hence the lock. bool booSuccess = false; string strMessage = "The mod was not activated."; try { lock (objUninstallLock) { using (TransactionScope tsTransaction = new TransactionScope()) { if (!File.Exists(Mod.Filename)) throw new Exception("The selected file was not found: " + Mod.Filename); TxFileManager tfmFileManager = new TxFileManager(); if (!BeginModReadOnlyTransaction()) return; RegisterMod(); booSuccess = RunScript(tfmFileManager); if (booSuccess) { Mod.InstallDate = DateTime.Now.ToString(); tsTransaction.Complete(); strMessage = "The mod was successfully activated."; GC.GetTotalMemory(true); } } } } catch (TransactionException) { throw; } catch (SecurityException) { throw; } catch (ObjectDisposedException) { throw; } //this blobck used to be conditionally excluded from debug builds, // presumably so that the debugger would break on the source of the // exception, however that prevents the full mod install flow from // happening, which lead to missed bugs catch (Exception e) { StringBuilder stbError = new StringBuilder(e.Message); if (e is FileNotFoundException) stbError.Append(" (" + ((FileNotFoundException)e).FileName + ")"); if (e is IllegalFilePathException) stbError.Append(" (" + ((IllegalFilePathException)e).Path + ")"); if (e.InnerException != null) stbError.AppendLine().AppendLine(e.InnerException.Message); if (e is RollbackException) foreach (RollbackException.ExceptedResourceManager erm in ((RollbackException)e).ExceptedResourceManagers) { stbError.AppendLine(erm.ResourceManager.ToString()); stbError.AppendLine(erm.Exception.Message); if (erm.Exception.InnerException != null) stbError.AppendLine(erm.Exception.InnerException.Message); } string strExceptionMessageFormat = "A problem occurred during install: " + Environment.NewLine + "{0}" + Environment.NewLine + "The mod was not installed."; ; strMessage = String.Format(strExceptionMessageFormat, stbError.ToString()); PopupErrorMessage = strMessage; PopupErrorMessageType = "Error"; } finally { Mod.EndReadOnlyTransaction(); } OnTaskSetCompleted(booSuccess, strMessage, Mod); }
/// <summary> /// This executes the install script. /// </summary> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <returns><c>true</c> if the script completed successfully; /// <c>false</c> otherwise.</returns> protected bool RunScript(TxFileManager p_tfmFileManager) { IModFileInstaller mfiFileInstaller = CreateFileInstaller(p_tfmFileManager, m_dlgOverwriteConfirmationDelegate); bool booResult = false; IIniInstaller iniIniInstaller = null; IGameSpecificValueInstaller gviGameSpecificValueInstaller = null; if (Mod.HasInstallScript) { try { IDataFileUtil dfuDataFileUtility = new DataFileUtil(GameMode.GameModeEnvironmentInfo.InstallationPath); iniIniInstaller = CreateIniInstaller(p_tfmFileManager, m_dlgOverwriteConfirmationDelegate); gviGameSpecificValueInstaller = CreateGameSpecificValueInstaller(p_tfmFileManager, m_dlgOverwriteConfirmationDelegate); InstallerGroup ipgInstallers = new InstallerGroup(dfuDataFileUtility, mfiFileInstaller, iniIniInstaller, gviGameSpecificValueInstaller, PluginManager); IScriptExecutor sexScript = Mod.InstallScript.Type.CreateExecutor(Mod, GameMode, EnvironmentInfo, ipgInstallers, UIContext); sexScript.TaskStarted += new EventHandler<EventArgs<IBackgroundTask>>(ScriptExecutor_TaskStarted); sexScript.TaskSetCompleted += new EventHandler<TaskSetCompletedEventArgs>(ScriptExecutor_TaskSetCompleted); booResult = sexScript.Execute(Mod.InstallScript); } catch (Exception ex) { PopupErrorMessage = ex.Message; PopupErrorMessageType = "Error"; } iniIniInstaller.FinalizeInstall(); if (gviGameSpecificValueInstaller != null) gviGameSpecificValueInstaller.FinalizeInstall(); } else booResult = RunBasicInstallScript(mfiFileInstaller, ActiveMods); mfiFileInstaller.FinalizeInstall(); return booResult; }
/// <summary> /// Called to perform the upgrade. /// </summary> /// <remarks> /// Sets up the resources required to upgrade the install log, and then /// call <see cref="DoUpgrade()"/> so implementers can do the upgrade. /// </remarks> /// <returns><lang cref="true"/> if the upgrade completed; <lang cref="false"/> /// if the user cancelled.</returns> internal bool PerformUpgrade() { #if TRACE Trace.WriteLine("Beginning Install Log Upgrade."); #endif m_tfmFileManager = new TxFileManager(); bool booComplete = false; using (TransactionScope tsTransaction = new TransactionScope()) { m_tfmFileManager.Snapshot(InstallLog.Current.InstallLogPath); using (m_pgdProgress = new BackgroundWorkerProgressDialog(DoUpgrade)) { m_pgdProgress.OverallMessage = "Upgrading FOMM Files"; if (m_pgdProgress.ShowDialog() == DialogResult.OK) { booComplete = true; tsTransaction.Complete(); } } m_tfmFileManager = null; } return booComplete; }
/// <summary> /// Runs the basic uninstall script. /// </summary> /// <remarks> /// A basic uninstall uninstalls all of the changes made when the mod was installed. /// </remarks> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <returns><c>true</c> if the uninstallation was successful; /// <c>false</c> otherwise.</returns> protected bool RunBasicUninstallScript(TxFileManager p_tfmFileManager, out string p_strErrorMessage) { p_strErrorMessage = null; IDataFileUtil dfuDataFileUtility = new DataFileUtil(GameMode.GameModeEnvironmentInfo.InstallationPath); IModFileInstaller mfiFileInstaller = new ModFileInstaller(GameMode.GameModeEnvironmentInfo, Mod, ModInstallLog, PluginManager, dfuDataFileUtility, p_tfmFileManager, null, GameMode.UsesPlugins, m_mmModManager); IIniInstaller iniIniInstaller = new IniInstaller(Mod, ModInstallLog, p_tfmFileManager, null); IGameSpecificValueInstaller gviGameSpecificValueInstaller = GameMode.GetGameSpecificValueInstaller(Mod, ModInstallLog, p_tfmFileManager, new NexusFileUtil(EnvironmentInfo), null); InstallerGroup ipgInstallers = new InstallerGroup(dfuDataFileUtility, mfiFileInstaller, iniIniInstaller, gviGameSpecificValueInstaller, PluginManager); BasicUninstallTask butTask = new BasicUninstallTask(Mod, ipgInstallers, ModInstallLog, GameMode, ActiveMods); OnTaskStarted(butTask); bool booResult = butTask.Execute(); if (mfiFileInstaller.InstallErrors.Count > 0) { p_strErrorMessage = Environment.NewLine + "There were issues while installing/uninstalling this mod:" + Environment.NewLine; foreach (string strPath in mfiFileInstaller.InstallErrors) DetailsErrorMessage += strPath + Environment.NewLine; PopupErrorMessage = p_strErrorMessage; PopupErrorMessageType = butTask.strPopupErrorMessageType; } mfiFileInstaller.FinalizeInstall(); iniIniInstaller.FinalizeInstall(); if (gviGameSpecificValueInstaller != null) gviGameSpecificValueInstaller.FinalizeInstall(); return booResult; }
/// <summary> /// Runs the uninstall tasks. /// </summary> protected void RunTasks() { //the install process modifies INI and config files. // if multiple sources (i.e., installs) try to modify // these files simultaneously the outcome is not well known // (e.g., one install changes SETTING1 in a config file to valueA // while simultaneously another install changes SETTING1 in the // file to value2 - after each install commits its changes it is // not clear what the value of SETTING1 will be). // as a result, we only allow one mod to be installed at a time, // hence the lock. bool booSuccess = false; string strErrorMessage = String.Empty; lock (objUninstallLock) { using (TransactionScope tsTransaction = new TransactionScope()) { TxFileManager tfmFileManager = new TxFileManager(); booSuccess = RunBasicUninstallScript(tfmFileManager, out strErrorMessage); if (booSuccess) { Mod.InstallDate = null; ModInstallLog.RemoveMod(Mod); tsTransaction.Complete(); GC.GetTotalMemory(true); } } } if (booSuccess) OnTaskSetCompleted(booSuccess, "The mod was successfully deactivated." + Environment.NewLine + strErrorMessage, Mod); else OnTaskSetCompleted(false, "The mod was not deactivated." + Environment.NewLine + strErrorMessage, Mod); }
/// <summary> /// Gets the installer to use to install game specific values. /// </summary> /// <param name="p_modMod">The mod being installed.</param> /// <param name="p_ilgInstallLog">The install log to use to log the installation of the game specific values.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <returns>The installer to use to manage game specific values, or <c>null</c> if the game mode does not /// install any game specific values.</returns> /// <param name="p_futFileUtility">The file utility class.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> public override IGameSpecificValueInstaller GetGameSpecificValueInstaller(IMod p_modMod, IInstallLog p_ilgInstallLog, TxFileManager p_tfmFileManager, FileUtil p_futFileUtility, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) { return null; }
/// <summary> /// Creates the file installer to use to install the mod's game specific value edits. /// </summary> /// <remarks> /// This returns a regular <see cref="IGameSpecificValueInstaller"/>. /// </remarks> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> /// <returns>The file installer to use to install the mod's files.</returns> protected virtual IGameSpecificValueInstaller CreateGameSpecificValueInstaller(TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) { return GameMode.GetGameSpecificValueInstaller(Mod, ModInstallLog, p_tfmFileManager, new NexusFileUtil(EnvironmentInfo), p_dlgOverwriteConfirmationDelegate); }
/// <summary> /// Gets the installer to use to upgrade game specific values. /// </summary> /// <param name="p_modMod">The mod being upgraded.</param> /// <param name="p_ilgInstallLog">The install log to use to log the installation of the game specific values.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <returns>The installer to use to manage game specific values, or <c>null</c> if the game mode does not /// install any game specific values.</returns> /// <param name="p_futFileUtility">The file utility class.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> public abstract IGameSpecificValueInstaller GetGameSpecificValueUpgradeInstaller(IMod p_modMod, IInstallLog p_ilgInstallLog, TxFileManager p_tfmFileManager, FileUtil p_futFileUtility, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate);
/// <summary> /// A simple constructor that initializes the object with its dependencies. /// </summary> /// <param name="p_modMod">The mod being installed.</param> /// <param name="p_ilgInstallLog">The install log to use to log file installations.</param> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> public IniUpgradeInstaller(IMod p_modMod, IInstallLog p_ilgInstallLog, TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) : base(p_modMod, p_ilgInstallLog, p_tfmFileManager, p_dlgOverwriteConfirmationDelegate) { OriginallyInstalledEdits = new Set<IniEdit>(); OriginallyInstalledEdits.AddRange(InstallLog.GetInstalledIniEdits(Mod)); }
public void ExtensionMethods_WriteToFile_RollbackIfError() { //------------Setup for test-------------------------- var tmpFile = Path.GetTempFileName(); File.WriteAllText(tmpFile, "this is going to be some very long test just to ensure we can over write it"); const string val = "<x><y>1</y></x>"; StringBuilder value = new StringBuilder(val); //------------Execute Test--------------------------- IFileManager fm = new TxFileManager(); value.WriteToFile(tmpFile, Encoding.UTF8, fm); //------------Assert Results------------------------- var result = File.ReadAllText(tmpFile); // clean up ;) File.Delete(tmpFile); Assert.AreEqual(val, result, "WriteToFile did not truncate"); }
/// <summary> /// This performs the mirgration. /// </summary> /// <param name="p_objArgs">The path to the old FOMM installation.</param> protected void DoMigration(object p_objArgs) { string strOldFOMMLocation = (string)p_objArgs; TxFileManager tfmFileManager = new TxFileManager(); //copy the mods //do we need to copy? #if TRACE Trace.Write("Copying Mods ("); #endif if (!Path.Combine(strOldFOMMLocation, "mods").Equals(Program.GameMode.ModDirectory, StringComparison.InvariantCultureIgnoreCase)) { List<string> lstModFiles = new List<string>(); lstModFiles.AddRange(Directory.GetFiles(Path.Combine(strOldFOMMLocation, "mods"), "*.fomod")); lstModFiles.AddRange(Directory.GetFiles(Path.Combine(strOldFOMMLocation, "mods"), "*.xml")); m_bwdProgress.ItemMessage = "Copying mods..."; #if TRACE Trace.WriteLine(lstModFiles.Count + "):"); Trace.Indent(); #endif m_bwdProgress.ItemProgressMaximum = lstModFiles.Count; m_bwdProgress.ItemProgress = 0; string strModFileName = null; foreach (string strMod in lstModFiles) { strModFileName = Path.GetFileName(strMod); m_bwdProgress.ItemMessage = "Copying mods (" + strModFileName + ")..."; #if TRACE Trace.WriteLine(strMod + " => " + Path.Combine(Program.GameMode.ModDirectory, strModFileName)); #endif tfmFileManager.Copy(strMod, Path.Combine(Program.GameMode.ModDirectory, strModFileName), true); //File.Copy(strMod, Path.Combine(Program.GameMode.ModDirectory, Path.GetFileName(strMod))); m_bwdProgress.StepItemProgress(); if (m_bwdProgress.Cancelled()) { #if TRACE Trace.Unindent(); Trace.WriteLine("Cancelled copying Mods."); #endif return; } } } #if TRACE else { Trace.WriteLine("No Need)."); } Trace.Unindent(); Trace.WriteLine("Done copying Mods."); #endif m_bwdProgress.StepOverallProgress(); //copy overwrites folder //do we need to? #if TRACE Trace.WriteLine("Copying overwrite files ("); #endif if (!Path.Combine(strOldFOMMLocation, "overwrites").Equals(((Fallout3GameMode)Program.GameMode).OverwriteDirectory, StringComparison.InvariantCultureIgnoreCase)) { string[] strOverwriteFiles = Directory.GetFiles(Path.Combine(strOldFOMMLocation, "overwrites"), "*.*", SearchOption.AllDirectories); m_bwdProgress.ItemMessage = "Copying overwrites..."; m_bwdProgress.ItemProgressMaximum = strOverwriteFiles.Length; m_bwdProgress.ItemProgress = 0; #if TRACE Trace.WriteLine(strOverwriteFiles.Length + "):"); Trace.Indent(); #endif FileUtil.Copy(tfmFileManager, Path.Combine(strOldFOMMLocation, "overwrites"), ((Fallout3GameMode)Program.GameMode).OverwriteDirectory, OverwriteFileCopied); } #if TRACE else { Trace.WriteLine("No Need)."); } Trace.Unindent(); Trace.WriteLine("Done copying overwrite files."); #endif m_bwdProgress.StepOverallProgress(); //copy install logs //do we need to? #if TRACE Trace.WriteLine("Copying install logs ("); #endif if (!Path.Combine(strOldFOMMLocation, "fomm").Equals(Program.GameMode.InstallInfoDirectory, StringComparison.InvariantCultureIgnoreCase)) { string[] strMiscFiles = Directory.GetFiles(Path.Combine(strOldFOMMLocation, "fomm"), "InstallLog.xml*"); m_bwdProgress.ItemMessage = "Copying info files..."; m_bwdProgress.ItemProgressMaximum = strMiscFiles.Length; m_bwdProgress.ItemProgress = 0; #if TRACE Trace.WriteLine(strMiscFiles.Length + "):"); Trace.Indent(); #endif foreach (string strFile in strMiscFiles) { #if TRACE Trace.WriteLine(strFile + " => " + Path.Combine(Program.GameMode.InstallInfoDirectory, Path.GetFileName(strFile))); #endif tfmFileManager.Copy(strFile, Path.Combine(Program.GameMode.InstallInfoDirectory, Path.GetFileName(strFile)), true); m_bwdProgress.StepItemProgress(); if (m_bwdProgress.Cancelled()) { #if TRACE Trace.Unindent(); Trace.WriteLine("Cancelled copying install logs."); #endif return; } } } #if TRACE else { Trace.WriteLine("No Need)."); } Trace.Unindent(); Trace.WriteLine("Done copying install logs."); #endif m_bwdProgress.StepOverallProgress(); }
/// <summary> /// Creates the file installer to use to install the mod's files. /// </summary> /// <remarks> /// This returns the regular <see cref="ModFileInstaller"/>. /// </remarks> /// <param name="p_tfmFileManager">The transactional file manager to use to interact with the file system.</param> /// <param name="p_dlgOverwriteConfirmationDelegate">The method to call in order to confirm an overwrite.</param> /// <returns>The file installer to use to install the mod's files.</returns> protected virtual IModFileInstaller CreateFileInstaller(TxFileManager p_tfmFileManager, ConfirmItemOverwriteDelegate p_dlgOverwriteConfirmationDelegate) { return new ModFileInstaller(GameMode.GameModeEnvironmentInfo, Mod, ModInstallLog, PluginManager, new DataFileUtil(GameMode.GameModeEnvironmentInfo.InstallationPath), p_tfmFileManager, p_dlgOverwriteConfirmationDelegate, GameMode.UsesPlugins, m_mmModManager); }
public void BuildCatalogFromWorkspace(string workspacePath, params string[] folders) { if (string.IsNullOrEmpty(workspacePath)) { throw new ArgumentNullException("workspacePath"); } if (folders == null) { throw new ArgumentNullException("folders"); } if (folders.Length == 0 || !Directory.Exists(workspacePath)) { return; } var streams = new List<ResourceBuilderTO>(); try { foreach (var path in folders.Where(f => !string.IsNullOrEmpty(f) && !f.EndsWith("VersionControl")).Select(f => Path.Combine(workspacePath, f))) { if (!Directory.Exists(path)) { continue; } var files = Directory.GetFiles(path, "*.xml"); foreach (var file in files) { FileAttributes fa = File.GetAttributes(file); if ((fa & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) { Dev2Logger.Log.Info("Removed READONLY Flag from [ " + file + " ]"); File.SetAttributes(file, FileAttributes.Normal); } // Use the FileStream class, which has an option that causes asynchronous I/O to occur at the operating system level. // In many cases, this will avoid blocking a ThreadPool thread. var sourceStream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096, true); streams.Add(new ResourceBuilderTO { FilePath = file, FileStream = sourceStream }); } } // Use the parallel task library to process file system ;) streams.ForEach(currentItem => { XElement xml = null; try { xml = XElement.Load(currentItem.FileStream); } catch (Exception e) { Dev2Logger.Log.Error("Resource [ " + currentItem.FilePath + " ] caused " + e.Message); } StringBuilder result = xml.ToStringBuilder(); var isValid = xml != null && HostSecurityProvider.Instance.VerifyXml(result); if (isValid) { var resource = new Resource(xml) { FilePath = currentItem.FilePath }; //2013.08.26: Prevent duplicate unassigned folder in save dialog and studio explorer tree by interpreting 'unassigned' as blank if (resource.ResourcePath.ToUpper() == "UNASSIGNED") { resource.ResourcePath = string.Empty; // DON'T FORCE A SAVE HERE - EVER!!!! } xml = _resourceUpgrader.UpgradeResource(xml, Assembly.GetExecutingAssembly().GetName().Version, a => { var fileManager = new TxFileManager(); using (TransactionScope tx = new TransactionScope()) { try { StringBuilder updateXml = a.ToStringBuilder(); var signedXml = HostSecurityProvider.Instance.SignXml(updateXml); signedXml.WriteToFile(currentItem.FilePath, Encoding.UTF8, fileManager); tx.Complete(); } catch { try { Transaction.Current.Rollback(); } catch (Exception err) { Dev2Logger.Log.Error(err); } throw; } } }); if (resource.IsUpgraded) { // Must close the source stream first and then add a new target stream // otherwise the file will be remain locked currentItem.FileStream.Close(); xml = resource.UpgradeXml(xml, resource); StringBuilder updateXml = xml.ToStringBuilder(); var signedXml = HostSecurityProvider.Instance.SignXml(updateXml); var fileManager = new TxFileManager(); using (TransactionScope tx = new TransactionScope()) { try { signedXml.WriteToFile(currentItem.FilePath, Encoding.UTF8,fileManager); tx.Complete(); } catch { Transaction.Current.Rollback(); throw; } } } if (resource.VersionInfo == null) { } lock (_addLock) { AddResource(resource, currentItem.FilePath); } } else { Dev2Logger.Log.Debug(string.Format("'{0}' wasn't loaded because it isn't signed or has modified since it was signed.", currentItem.FilePath)); } }); } finally { // Close all FileStream instances in a finally block after the tasks are complete. // If each FileStream was instead created in a using statement, the FileStream // might be disposed of before the task was complete foreach (var stream in streams) { stream.FileStream.Close(); } } }