public void DeleteFolder(string path) { logger.Info("Attempting to send '{0}' to recycling bin", path); var recyclingBin = _configService.RecycleBin; if (String.IsNullOrWhiteSpace(recyclingBin)) { logger.Info("Recycling Bin has not been configured, deleting permanently."); _diskProvider.DeleteFolder(path, true); logger.Debug("Folder has been permanently deleted: {0}", path); } else { var destination = Path.Combine(recyclingBin, new DirectoryInfo(path).Name); logger.Debug("Moving '{0}' to '{1}'", path, destination); _diskProvider.MoveFolder(path, destination); logger.Debug("Setting last accessed: {0}", path); _diskProvider.FolderSetLastWriteTimeUtc(destination, DateTime.UtcNow); foreach (var file in _diskProvider.GetFiles(destination, SearchOption.AllDirectories)) { _diskProvider.FileSetLastWriteTimeUtc(file, DateTime.UtcNow); } logger.Debug("Folder has been moved to the recycling bin: {0}", destination); } }
public TransferMode TransferFolder(string sourcePath, string targetPath, TransferMode mode, DiskTransferVerificationMode verificationMode) { Ensure.That(sourcePath, () => sourcePath).IsValidPath(); Ensure.That(targetPath, () => targetPath).IsValidPath(); if (mode == TransferMode.Move && !_diskProvider.FolderExists(targetPath)) { if (verificationMode == DiskTransferVerificationMode.TryTransactional || verificationMode == DiskTransferVerificationMode.VerifyOnly) { var sourceMount = _diskProvider.GetMount(sourcePath); var targetMount = _diskProvider.GetMount(targetPath); // If we're on the same mount, do a simple folder move. if (sourceMount != null && targetMount != null && sourceMount.RootDirectory == targetMount.RootDirectory) { _logger.Debug("Move Directory [{0}] > [{1}]", sourcePath, targetPath); _diskProvider.MoveFolder(sourcePath, targetPath); return(mode); } } } if (!_diskProvider.FolderExists(targetPath)) { _diskProvider.CreateFolder(targetPath); _diskProvider.CopyPermissions(sourcePath, targetPath); } var result = mode; foreach (var subDir in _diskProvider.GetDirectoryInfos(sourcePath)) { if (ShouldIgnore(subDir)) { continue; } result &= TransferFolder(subDir.FullName, Path.Combine(targetPath, subDir.Name), mode, verificationMode); } foreach (var sourceFile in _diskProvider.GetFileInfos(sourcePath)) { if (ShouldIgnore(sourceFile)) { continue; } var destFile = Path.Combine(targetPath, sourceFile.Name); result &= TransferFile(sourceFile.FullName, destFile, mode, true, verificationMode); } if (mode.HasFlag(TransferMode.Move)) { _diskProvider.DeleteFolder(sourcePath, true); } return(result); }
public void DeleteFolder(string path) { _logger.Info("Attempting to send '{0}' to recycling bin", path); var recyclingBin = _configService.RecycleBin; if (string.IsNullOrWhiteSpace(recyclingBin)) { _logger.Info("Recycling Bin has not been configured, deleting permanently. {0}", path); _diskProvider.DeleteFolder(path, true); _logger.Debug("Folder has been permanently deleted: {0}", path); } else { var destination = Path.Combine(recyclingBin, new DirectoryInfo(path).Name); _logger.Debug("Moving '{0}' to '{1}'", path, destination); _diskTransferService.TransferFolder(path, destination, TransferMode.Move); _logger.Debug("Setting last accessed: {0}", path); _diskProvider.FolderSetLastWriteTime(destination, DateTime.UtcNow); foreach (var file in _diskProvider.GetFiles(destination, SearchOption.AllDirectories)) { if (OsInfo.IsWindows) { //TODO: Better fix than this for non-Windows? _diskProvider.FileSetLastWriteTime(file, DateTime.UtcNow); } } _logger.Debug("Folder has been moved to the recycling bin: {0}", destination); } }
public List <ImportResult> ProcessFolder(DirectoryInfo directoryInfo, DownloadClientItem downloadClientItem) { var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name); var series = _parsingService.GetSeries(cleanedUpName); var quality = QualityParser.ParseQuality(cleanedUpName); _logger.Debug("{0} folder quality: {1}", cleanedUpName, quality); if (series == null) { _logger.Debug("Unknown Series {0}", cleanedUpName); return(new List <ImportResult>()); } var videoFiles = _diskScanService.GetVideoFiles(directoryInfo.FullName); var decisions = _importDecisionMaker.GetImportDecisions(videoFiles.ToList(), series, true, quality); var importResults = _importApprovedEpisodes.Import(decisions, true, downloadClientItem); if (!downloadClientItem.IsReadOnly && importResults.Any() && ShouldDeleteFolder(directoryInfo)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(directoryInfo.FullName, true); } return(importResults); }
public TransferMode TransferFolder(string sourcePath, string targetPath, TransferMode mode, DiskTransferVerificationMode verificationMode) { Ensure.That(sourcePath, () => sourcePath).IsValidPath(); Ensure.That(targetPath, () => targetPath).IsValidPath(); if (!_diskProvider.FolderExists(targetPath)) { _diskProvider.CreateFolder(targetPath); } var result = mode; foreach (var subDir in _diskProvider.GetDirectoryInfos(sourcePath)) { result &= TransferFolder(subDir.FullName, Path.Combine(targetPath, subDir.Name), mode, verificationMode); } foreach (var sourceFile in _diskProvider.GetFileInfos(sourcePath)) { var destFile = Path.Combine(targetPath, sourceFile.Name); result &= TransferFile(sourceFile.FullName, destFile, mode, true, verificationMode); } if (mode.HasFlag(TransferMode.Move)) { _diskProvider.DeleteFolder(sourcePath, true); } return(result); }
private void InstallUpdate(UpdatePackage updatePackage) { EnsureAppDataSafety(); if (OsInfo.IsWindows || _configFileProvider.UpdateMechanism != UpdateMechanism.Script) { if (!_diskProvider.FolderWritable(_appFolderInfo.StartUpFolder)) { throw new UpdateFolderNotWritableException("Cannot install update because startup folder '{0}' is not writable by the user '{1}'.", _appFolderInfo.StartUpFolder, Environment.UserName); } } var updateSandboxFolder = _appFolderInfo.GetUpdateSandboxFolder(); var packageDestination = Path.Combine(updateSandboxFolder, updatePackage.FileName); if (_diskProvider.FolderExists(updateSandboxFolder)) { _logger.Info("Deleting old update files"); _diskProvider.DeleteFolder(updateSandboxFolder, true); } _logger.ProgressInfo("Downloading update {0}", updatePackage.Version); _logger.Debug("Downloading update package from [{0}] to [{1}]", updatePackage.Url, packageDestination); _httpClient.DownloadFile(updatePackage.Url, packageDestination); _logger.ProgressInfo("Verifying update package"); if (!_updateVerifier.Verify(updatePackage, packageDestination)) { _logger.Error("Update package is invalid"); throw new UpdateVerificationFailedException("Update file '{0}' is invalid", packageDestination); } _logger.Info("Update package verified successfully"); _logger.ProgressInfo("Extracting Update package"); _archiveService.Extract(packageDestination, updateSandboxFolder); _logger.Info("Update package extracted successfully"); EnsureValidBranch(updatePackage); _backupService.Backup(BackupType.Update); if (OsInfo.IsNotWindows && _configFileProvider.UpdateMechanism == UpdateMechanism.Script) { InstallUpdateWithScript(updateSandboxFolder); return; } _logger.Info("Preparing client"); _diskProvider.MoveFolder(_appFolderInfo.GetUpdateClientFolder(), updateSandboxFolder); _logger.Info("Starting update client {0}", _appFolderInfo.GetUpdateClientExePath()); _logger.ProgressInfo("Sonarr will restart shortly."); _processProvider.Start(_appFolderInfo.GetUpdateClientExePath(), GetUpdaterArgs(updateSandboxFolder)); }
public void HandleAsync(AuthorDeletedEvent message) { var path = GetAuthorCoverPath(message.Author.Id); if (_diskProvider.FolderExists(path)) { _diskProvider.DeleteFolder(path, true); } }
private void InstallUpdate(UpdatePackage updatePackage) { try { EnsureAppDataSafety(); var updateSandboxFolder = _appFolderInfo.GetUpdateSandboxFolder(); var packageDestination = Path.Combine(updateSandboxFolder, updatePackage.FileName); if (_diskProvider.FolderExists(updateSandboxFolder)) { _logger.Info("Deleting old update files"); _diskProvider.DeleteFolder(updateSandboxFolder, true); } _logger.ProgressInfo("Downloading update {0}", updatePackage.Version); _logger.Debug("Downloading update package from [{0}] to [{1}]", updatePackage.Url, packageDestination); _httpClient.DownloadFile(updatePackage.Url, packageDestination); _logger.ProgressInfo("Verifying update package"); if (!_updateVerifier.Verify(updatePackage, packageDestination)) { _logger.Error("Update package is invalid"); throw new UpdateVerificationFailedException("Update file '{0}' is invalid", packageDestination); } _logger.Info("Update package verified successfully"); _logger.ProgressInfo("Extracting Update package"); _archiveService.Extract(packageDestination, updateSandboxFolder); _logger.Info("Update package extracted successfully"); _backupService.Backup(BackupType.Update); if (OsInfo.IsMono && _configFileProvider.UpdateMechanism == UpdateMechanism.Script) { InstallUpdateWithScript(updateSandboxFolder); return; } _logger.Info("Preparing client"); _diskProvider.MoveFolder(_appFolderInfo.GetUpdateClientFolder(), updateSandboxFolder); _logger.Info("Starting update client {0}", _appFolderInfo.GetUpdateClientExePath()); _logger.ProgressInfo("NzbDrone will restart shortly."); _processProvider.Start(_appFolderInfo.GetUpdateClientExePath(), GetUpdaterArgs(updateSandboxFolder)); } catch (Exception ex) { _logger.ErrorException("Update process failed", ex); } }
public void HandleAsync(ArtistsDeletedEvent message) { foreach (var artist in message.Artists) { var path = GetArtistCoverPath(artist.Id); if (_diskProvider.FolderExists(path)) { _diskProvider.DeleteFolder(path, true); } } }
public void Handle(MovieFileDeletedEvent message) { if (_configService.DeleteEmptyFolders) { var movie = message.MovieFile.Movie; var moviePath = movie.Path; var folder = message.MovieFile.Path.GetParentPath(); while (moviePath.IsParentPath(folder)) { if (_diskProvider.FolderExists(folder)) { _diskProvider.RemoveEmptySubfolders(folder); } folder = folder.GetParentPath(); } _diskProvider.RemoveEmptySubfolders(moviePath); if (_diskProvider.FolderEmpty(moviePath)) { _diskProvider.DeleteFolder(moviePath, true); } } }
private void ProcessFolder(string path) { Ensure.That(path, () => path).IsValidPath(); try { if (_seriesService.SeriesPathExists(path)) { _logger.Warn("Unable to process folder that contains sorted TV Shows"); return; } var directoryFolderInfo = new DirectoryInfo(path); var importedFiles = ProcessFolder(directoryFolderInfo); if (importedFiles.Any() && ShouldDeleteFolder(directoryFolderInfo)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(path, true); } } catch (Exception e) { _logger.ErrorException("An error has occurred while importing folder: " + path, e); } }
private void RemoveCompleted(TrackedDownload trackedDownload, IDownloadClient downloadClient) { if (trackedDownload.State == TrackedDownloadState.Imported && !trackedDownload.DownloadItem.IsReadOnly) { try { _logger.Debug("[{0}] Removing completed download from history.", trackedDownload.DownloadItem.Title); downloadClient.RemoveItem(trackedDownload.DownloadItem.DownloadClientId); if (_diskProvider.FolderExists(trackedDownload.DownloadItem.OutputPath)) { _logger.Debug("Removing completed download directory: {0}", trackedDownload.DownloadItem.OutputPath); _diskProvider.DeleteFolder(trackedDownload.DownloadItem.OutputPath, true); } else if (_diskProvider.FileExists(trackedDownload.DownloadItem.OutputPath)) { _logger.Debug("Removing completed download file: {0}", trackedDownload.DownloadItem.OutputPath); _diskProvider.DeleteFile(trackedDownload.DownloadItem.OutputPath); } trackedDownload.State = TrackedDownloadState.Removed; } catch (NotSupportedException) { UpdateStatusMessage(trackedDownload, LogLevel.Debug, "Removing item not supported by your download client."); } } }
public void Handle(EpisodeFileDeletedEvent message) { if (_configService.DeleteEmptyFolders) { var series = message.EpisodeFile.Series.Value; var seriesPath = series.Path; var folder = message.EpisodeFile.Path.GetParentPath(); while (seriesPath.IsParentPath(folder)) { if (_diskProvider.FolderExists(folder)) { _diskProvider.RemoveEmptySubfolders(folder); } folder = folder.GetParentPath(); } _diskProvider.RemoveEmptySubfolders(seriesPath); if (_diskProvider.FolderEmpty(seriesPath)) { _diskProvider.DeleteFolder(seriesPath, true); } } }
public void HandleAsync(SeriesDeletedEvent message) { var path = GetSeriesCoverPath(message.Series.Id); if (_diskProvider.FolderExists(path)) { _diskProvider.DeleteFolder(path, true); } }
public void HandleAsync(MovieDeletedEvent message) { var path = GetMovieCoverPath(message.Movie.Id); if (_diskProvider.FolderExists(path)) { _diskProvider.DeleteFolder(path, true); } }
public void Clean() { var updateSandboxFolder = _appFolderInfo.GetUpdateSandboxFolder(); if (_diskProvider.FolderExists(updateSandboxFolder)) { _diskProvider.DeleteFolder(updateSandboxFolder, true); } }
private void ProcessDownloadedEpisodesFolder() { //TODO: We should also process the download client's category folder var downloadedEpisodesFolder = _configService.DownloadedEpisodesFolder; if (String.IsNullOrEmpty(downloadedEpisodesFolder)) { _logger.Warn("Drone Factory folder is not configured"); return; } if (!_diskProvider.FolderExists(downloadedEpisodesFolder)) { _logger.Warn("Drone Factory folder [{0}] doesn't exist.", downloadedEpisodesFolder); return; } foreach (var subFolder in _diskProvider.GetDirectories(downloadedEpisodesFolder)) { try { if (_seriesService.SeriesPathExists(subFolder)) { continue; } var importedFiles = ProcessSubFolder(new DirectoryInfo(subFolder)); if (importedFiles.Any()) { if (_diskProvider.GetFolderSize(subFolder) < NotSampleSpecification.SampleSizeLimit) { _diskProvider.DeleteFolder(subFolder, true); } } } catch (Exception e) { _logger.ErrorException("An error has occurred while importing folder: " + subFolder, e); } } foreach (var videoFile in _diskScanService.GetVideoFiles(downloadedEpisodesFolder, false)) { try { ProcessVideoFile(videoFile); } catch (Exception ex) { _logger.ErrorException("An error has occurred while importing video file" + videoFile, ex); } } }
private List <ImportResult> ProcessFolder(DirectoryInfo directoryInfo, ImportMode importMode, Movie movie, DownloadClientItem downloadClientItem) { if (_movieService.MoviePathExists(directoryInfo.FullName)) { _logger.Warn("Unable to process folder that is mapped to an existing show"); return(new List <ImportResult>()); } var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name); var historyItems = _historyService.FindByDownloadId(downloadClientItem?.DownloadId ?? ""); var firstHistoryItem = historyItems?.OrderByDescending(h => h.Date).FirstOrDefault(); var folderInfo = _parsingService.ParseMovieInfo(cleanedUpName, new List <object> { firstHistoryItem }); if (folderInfo != null) { _logger.Debug("{0} folder quality: {1}", cleanedUpName, folderInfo.Quality); } var videoFiles = _diskScanService.FilterPaths(directoryInfo.FullName, _diskScanService.GetVideoFiles(directoryInfo.FullName)); if (downloadClientItem == null) { foreach (var videoFile in videoFiles) { if (_diskProvider.IsFileLocked(videoFile)) { return(new List <ImportResult> { FileIsLockedResult(videoFile) }); } } } var decisions = _importDecisionMaker.GetImportDecisions(videoFiles.ToList(), movie, downloadClientItem, folderInfo, true); var importResults = _importApprovedMovie.Import(decisions, true, downloadClientItem, importMode); if (importMode == ImportMode.Auto) { importMode = (downloadClientItem == null || downloadClientItem.CanMoveFiles) ? ImportMode.Move : ImportMode.Copy; } if (importMode == ImportMode.Move && importResults.Any(i => i.Result == ImportResultType.Imported) && ShouldDeleteFolder(directoryInfo, movie)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(directoryInfo.FullName, true); } return(importResults); }
private void RemoveEmptySeriesFolder(string path) { if (_configService.DeleteEmptyFolders) { _diskProvider.RemoveEmptySubfolders(path); if (_diskProvider.FolderEmpty(path)) { _diskProvider.DeleteFolder(path, true); } } }
public List <ImportResult> ProcessFolder(DirectoryInfo directoryInfo, DownloadClientItem downloadClientItem = null) { if (_seriesService.SeriesPathExists(directoryInfo.FullName)) { _logger.Warn("Unable to process folder that contains sorted TV Shows"); return(new List <ImportResult>()); } var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name); var series = _parsingService.GetSeries(cleanedUpName); var quality = QualityParser.ParseQuality(cleanedUpName); _logger.Debug("{0} folder quality: {1}", cleanedUpName, quality); if (series == null) { _logger.Debug("Unknown Series {0}", cleanedUpName); return(new List <ImportResult> { new ImportResult(new ImportDecision(null, "Unknown Series"), "Unknown Series") }); } var videoFiles = _diskScanService.GetVideoFiles(directoryInfo.FullName); foreach (var videoFile in videoFiles) { if (_diskProvider.IsFileLocked(videoFile)) { _logger.Debug("[{0}] is currently locked by another process, skipping", videoFile); return(new List <ImportResult> { new ImportResult(new ImportDecision(new LocalEpisode { Path = videoFile }, "Locked file, try again later"), "Locked file, try again later") }); } } var decisions = _importDecisionMaker.GetImportDecisions(videoFiles.ToList(), series, true, quality); var importResults = _importApprovedEpisodes.Import(decisions, true, downloadClientItem); if ((downloadClientItem == null || !downloadClientItem.IsReadOnly) && importResults.Any() && ShouldDeleteFolder(directoryInfo)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(directoryInfo.FullName, true); } return(importResults); }
private void RemoveEmptyArtistFolder(string path) { if (_configService.DeleteEmptyFolders) { if (_diskProvider.GetFiles(path, SearchOption.AllDirectories).Empty()) { _diskProvider.DeleteFolder(path, true); } else { _diskProvider.RemoveEmptySubfolders(path); } } }
private List <ImportResult> ProcessFolder(DirectoryInfo directoryInfo, ImportMode importMode, Series series, DownloadClientItem downloadClientItem) { if (_seriesService.SeriesPathExists(directoryInfo.FullName)) { _logger.Warn("Unable to process folder that is mapped to an existing show"); return(new List <ImportResult>()); } var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name); var folderInfo = Parser.Parser.ParseTitle(directoryInfo.Name); if (folderInfo != null) { _logger.Debug("{0} folder quality: {1}", cleanedUpName, folderInfo.Quality); } var videoFiles = _diskScanService.FilterFiles(directoryInfo.FullName, _diskScanService.GetVideoFiles(directoryInfo.FullName)); if (downloadClientItem == null) { foreach (var videoFile in videoFiles) { if (_diskProvider.IsFileLocked(videoFile)) { return(new List <ImportResult> { FileIsLockedResult(videoFile) }); } } } var decisions = _importDecisionMaker.GetImportDecisions(videoFiles.ToList(), series, downloadClientItem, folderInfo, true); var importResults = _importApprovedEpisodes.Import(decisions, true, downloadClientItem, importMode); if (importMode == ImportMode.Auto) { importMode = (downloadClientItem == null || downloadClientItem.CanMoveFiles) ? ImportMode.Move : ImportMode.Copy; } if (importMode == ImportMode.Move && importResults.Any(i => i.Result == ImportResultType.Imported) && ShouldDeleteFolder(directoryInfo, series)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(directoryInfo.FullName, true); } return(importResults); }
private List <ImportResult> ProcessFolder(DirectoryInfo directoryInfo, ImportMode importMode, Movie movie, DownloadClientItem downloadClientItem) { if (_movieService.MoviePathExists(directoryInfo.FullName)) { _logger.Warn("Unable to process folder that is mapped to an existing show"); return(new List <ImportResult>()); } var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name); var folderInfo = Parser.Parser.ParseMovieTitle(directoryInfo.Name, _config.ParsingLeniency > 0); if (folderInfo != null) { _logger.Debug("{0} folder quality: {1}", cleanedUpName, folderInfo.Quality); } var videoFiles = _diskScanService.GetVideoFiles(directoryInfo.FullName); if (downloadClientItem == null) { foreach (var videoFile in videoFiles) { if (_diskProvider.IsFileLocked(videoFile)) { return(new List <ImportResult> { FileIsLockedResult(videoFile) }); } } } var decisions = _importDecisionMaker.GetImportDecisions(videoFiles.ToList(), movie, folderInfo, true, false); var importResults = _importApprovedMovie.Import(decisions, true, downloadClientItem, importMode); if ((downloadClientItem == null || !downloadClientItem.IsReadOnly) && importResults.Any(i => i.Result == ImportResultType.Imported) && ShouldDeleteFolder(directoryInfo, movie)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(directoryInfo.FullName, true); } return(importResults); }
protected virtual void DeleteItemData(string downloadId) { if (downloadId.IsNullOrWhiteSpace()) { return; } var item = GetItems().FirstOrDefault(v => v.DownloadId == downloadId); if (item == null) { _logger.Trace("DownloadItem {0} in {1} history not found, skipping delete data.", downloadId, Name); return; } if (item.OutputPath.IsEmpty) { _logger.Trace("[{0}] Doesn't have an outputPath, skipping delete data.", item.Title); return; } try { if (_diskProvider.FolderExists(item.OutputPath.FullPath)) { _logger.Debug("[{0}] Deleting folder '{1}'.", item.Title, item.OutputPath); _diskProvider.DeleteFolder(item.OutputPath.FullPath, true); } else if (_diskProvider.FileExists(item.OutputPath.FullPath)) { _logger.Debug("[{0}] Deleting file '{1}'.", item.Title, item.OutputPath); _diskProvider.DeleteFile(item.OutputPath.FullPath); } else { _logger.Trace("[{0}] File or folder '{1}' doesn't exist, skipping cleanup.", item.Title, item.OutputPath); } } catch (Exception ex) { _logger.Warn(ex, string.Format("[{0}] Error occurred while trying to delete data from '{1}'.", item.Title, item.OutputPath)); } }
public void Restore(string backupFileName) { if (backupFileName.EndsWith(".zip")) { var restoredFile = false; var temporaryPath = Path.Combine(_appFolderInfo.TempFolder, "radarr_backup_restore"); _archiveService.Extract(backupFileName, temporaryPath); foreach (var file in _diskProvider.GetFiles(temporaryPath, SearchOption.TopDirectoryOnly)) { var fileName = Path.GetFileName(file); if (fileName.Equals("Config.xml", StringComparison.InvariantCultureIgnoreCase)) { _diskProvider.MoveFile(file, _appFolderInfo.GetConfigPath(), true); restoredFile = true; } if (fileName.Equals("nzbdrone.db", StringComparison.InvariantCultureIgnoreCase)) { _diskProvider.MoveFile(file, _appFolderInfo.GetDatabaseRestore(), true); restoredFile = true; } if (fileName.Equals("radarr.db", StringComparison.InvariantCultureIgnoreCase)) { _diskProvider.MoveFile(file, _appFolderInfo.GetDatabaseRestore(), true); restoredFile = true; } } if (!restoredFile) { throw new RestoreBackupFailedException(HttpStatusCode.NotFound, "Unable to restore database file from backup"); } _diskProvider.DeleteFolder(temporaryPath, true); return; } _diskProvider.MoveFile(backupFileName, _appFolderInfo.GetDatabaseRestore(), true); }
private List <ImportResult> ProcessFolder(DirectoryInfo directoryInfo, Series series, DownloadClientItem downloadClientItem = null) { if (_seriesService.SeriesPathExists(directoryInfo.FullName)) { _logger.Warn("Unable to process folder that is mapped to an existing show"); return(new List <ImportResult>()); } var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name); var quality = QualityParser.ParseQuality(cleanedUpName); _logger.Debug("{0} folder quality: {1}", cleanedUpName, quality); var videoFiles = _diskScanService.GetVideoFiles(directoryInfo.FullName); if (downloadClientItem == null) { foreach (var videoFile in videoFiles) { if (_diskProvider.IsFileLocked(videoFile)) { return(new List <ImportResult> { FileIsLockedResult(videoFile) }); } } } var decisions = _importDecisionMaker.GetImportDecisions(videoFiles.ToList(), series, true, quality); var importResults = _importApprovedEpisodes.Import(decisions, true, downloadClientItem); if ((downloadClientItem == null || !downloadClientItem.IsReadOnly) && importResults.Any() && ShouldDeleteFolder(directoryInfo, series)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(directoryInfo.FullName, true); } return(importResults); }
public void Handle(BookFileDeletedEvent message) { if (message.Reason == DeleteMediaFileReason.Upgrade) { return; } if (_configService.DeleteEmptyFolders) { var author = message.BookFile.Author.Value; var bookFolder = message.BookFile.Path.GetParentPath(); if (_diskProvider.GetFiles(author.Path, SearchOption.AllDirectories).Empty()) { _diskProvider.DeleteFolder(author.Path, true); } else if (_diskProvider.GetFiles(bookFolder, SearchOption.AllDirectories).Empty()) { _diskProvider.RemoveEmptySubfolders(bookFolder); } } }
protected virtual void DeleteItemData(DownloadClientItem item) { if (item == null) { return; } if (item.OutputPath.IsEmpty) { _logger.Trace("[{0}] Doesn't have an outputPath, skipping delete data.", item.Title); return; } try { if (_diskProvider.FolderExists(item.OutputPath.FullPath)) { _logger.Debug("[{0}] Deleting folder '{1}'.", item.Title, item.OutputPath); _diskProvider.DeleteFolder(item.OutputPath.FullPath, true); } else if (_diskProvider.FileExists(item.OutputPath.FullPath)) { _logger.Debug("[{0}] Deleting file '{1}'.", item.Title, item.OutputPath); _diskProvider.DeleteFile(item.OutputPath.FullPath); } else { _logger.Trace("[{0}] File or folder '{1}' doesn't exist, skipping cleanup.", item.Title, item.OutputPath); } } catch (Exception ex) { _logger.Warn(ex, string.Format("[{0}] Error occurred while trying to delete data from '{1}'.", item.Title, item.OutputPath)); } }
private void InstallUpdate(UpdatePackage updatePackage) { try { var updateSandboxFolder = _appFolderInfo.GetUpdateSandboxFolder(); var packageDestination = Path.Combine(updateSandboxFolder, updatePackage.FileName); if (_diskProvider.FolderExists(updateSandboxFolder)) { _logger.Info("Deleting old update files"); _diskProvider.DeleteFolder(updateSandboxFolder, true); } _logger.ProgressInfo("Downloading update {0} [{1}]", updatePackage.Version, updatePackage.Branch); _logger.Debug("Downloading update package from [{0}] to [{1}]", updatePackage.Url, packageDestination); _httpProvider.DownloadFile(updatePackage.Url, packageDestination); _logger.ProgressInfo("Extracting Update package"); _archiveService.Extract(packageDestination, updateSandboxFolder); _logger.Info("Update package extracted successfully"); _logger.Info("Preparing client"); _diskProvider.MoveFolder(_appFolderInfo.GetUpdateClientFolder(), updateSandboxFolder); _logger.Info("Starting update client {0}", _appFolderInfo.GetUpdateClientExePath()); _logger.ProgressInfo("NzbDrone will restart shortly."); _processProvider.Start(_appFolderInfo.GetUpdateClientExePath(), _processProvider.GetCurrentProcess().Id.ToString()); } catch (Exception ex) { _logger.ErrorException("Update process failed", ex); } }
private List <ImportResult> ProcessFolder(IDirectoryInfo directoryInfo, ImportMode importMode, Author author, DownloadClientItem downloadClientItem) { if (_authorService.AuthorPathExists(directoryInfo.FullName)) { _logger.Warn("Unable to process folder that is mapped to an existing author"); return(new List <ImportResult>()); } var cleanedUpName = GetCleanedUpFolderName(directoryInfo.Name); var folderInfo = Parser.Parser.ParseBookTitle(directoryInfo.Name); var trackInfo = new ParsedTrackInfo { }; if (folderInfo != null) { _logger.Debug("{0} folder quality: {1}", cleanedUpName, folderInfo.Quality); trackInfo = new ParsedTrackInfo { AlbumTitle = folderInfo.BookTitle, ArtistTitle = folderInfo.AuthorName, Quality = folderInfo.Quality, ReleaseGroup = folderInfo.ReleaseGroup, ReleaseHash = folderInfo.ReleaseHash, }; } else { trackInfo = null; } var audioFiles = _diskScanService.FilterFiles(directoryInfo.FullName, _diskScanService.GetBookFiles(directoryInfo.FullName)); if (downloadClientItem == null) { foreach (var audioFile in audioFiles) { if (_diskProvider.IsFileLocked(audioFile.FullName)) { return(new List <ImportResult> { FileIsLockedResult(audioFile.FullName) }); } } } var idOverrides = new IdentificationOverrides { Author = author }; var idInfo = new ImportDecisionMakerInfo { DownloadClientItem = downloadClientItem, ParsedTrackInfo = trackInfo }; var idConfig = new ImportDecisionMakerConfig { Filter = FilterFilesType.None, NewDownload = true, SingleRelease = false, IncludeExisting = false, AddNewAuthors = false }; var decisions = _importDecisionMaker.GetImportDecisions(audioFiles, idOverrides, idInfo, idConfig); var importResults = _importApprovedTracks.Import(decisions, true, downloadClientItem, importMode); if (importMode == ImportMode.Auto) { importMode = (downloadClientItem == null || downloadClientItem.CanMoveFiles) ? ImportMode.Move : ImportMode.Copy; } if (importMode == ImportMode.Move && importResults.Any(i => i.Result == ImportResultType.Imported) && ShouldDeleteFolder(directoryInfo, author)) { _logger.Debug("Deleting folder after importing valid files"); _diskProvider.DeleteFolder(directoryInfo.FullName, true); } return(importResults); }