public List <RootFolder> AllWithUnmappedFolders()
{
var rootFolders = _rootFolderRepository.All().ToList();
rootFolders.ForEach(folder =>
{
try
{
if (folder.Path.IsPathValid() && _diskProvider.FolderExists(folder.Path))
{
folder.FreeSpace = _diskProvider.GetAvailableSpace(folder.Path);
folder.UnmappedFolders = GetUnmappedFolders(folder.Path);
}
}
//We don't want an exception to prevent the root folders from loading in the UI, so they can still be deleted
catch (Exception ex)
{
_logger.Error(ex, "Unable to get free space and unmapped folders for root folder {0}", folder.Path);
folder.FreeSpace = 0;
folder.UnmappedFolders = new List <UnmappedFolder>();
}
});
return(rootFolders);
}
public List <RootFolder> AllWithUnmappedFolders()
{
var rootFolders = _rootFolderRepository.All().ToList();
rootFolders.ForEach(folder =>
{
if (folder.Path.IsPathValid() && _diskProvider.FolderExists(folder.Path))
{
folder.FreeSpace = _diskProvider.GetAvailableSpace(folder.Path);
folder.UnmappedFolders = GetUnmappedFolders(folder.Path);
}
});
return(rootFolders);
}
public bool IsSatisfiedBy(LocalEpisode localEpisode)
{
try
{
if (localEpisode.ExistingFile)
{
_logger.Trace("Skipping free space check for existing episode");
return(true);
}
var path = Directory.GetParent(localEpisode.Series.Path);
var freeSpace = _diskProvider.GetAvailableSpace(path.FullName);
if (!freeSpace.HasValue)
{
_logger.Trace("Free space check returned an invalid result for: {0}", path);
return(true);
}
if (freeSpace < localEpisode.Size + 100.Megabytes())
{
_logger.Warn("Not enough free space to import: {0}", localEpisode);
return(false);
}
}
catch (Exception ex)
{
_logger.ErrorException("Unable to check free disk space while importing: " + localEpisode.Path, ex);
}
return(true);
}
private IEnumerable <DiskSpace> GetDiskSpace(IEnumerable <String> paths)
{
foreach (var path in paths)
{
DiskSpace diskSpace = null;
try
{
var freeSpace = _diskProvider.GetAvailableSpace(path).Value;
var totalSpace = _diskProvider.GetTotalSize(path).Value;
diskSpace = new DiskSpace
{
Path = path,
FreeSpace = freeSpace,
TotalSpace = totalSpace
};
diskSpace.Label = _diskProvider.GetVolumeLabel(path);
}
catch (Exception ex)
{
_logger.WarnException("Unable to get free space for: " + path, ex);
}
if (diskSpace != null)
{
yield return(diskSpace);
}
}
}
public Decision IsSatisfiedBy(LocalEpisode localEpisode)
{
if (_configService.SkipFreeSpaceCheckWhenImporting)
{
_logger.Debug("Skipping free space check when importing");
return(Decision.Accept());
}
try
{
if (localEpisode.ExistingFile)
{
_logger.Debug("Skipping free space check for existing episode");
return(Decision.Accept());
}
var path = Directory.GetParent(localEpisode.Series.Path);
var freeSpace = _diskProvider.GetAvailableSpace(path.FullName);
if (!freeSpace.HasValue)
{
_logger.Debug("Free space check returned an invalid result for: {0}", path);
return(Decision.Accept());
}
if (freeSpace < localEpisode.Size + 100.Megabytes())
{
_logger.Warn("Not enough free space ({0}) to import: {1} ({2})", freeSpace, localEpisode, localEpisode.Size);
return(Decision.Reject("Not enough free space"));
}
}
catch (DirectoryNotFoundException ex)
{
_logger.Error("Unable to check free disk space while importing. " + ex.Message);
}
catch (Exception ex)
{
_logger.Error(ex, "Unable to check free disk space while importing: " + localEpisode.Path);
}
return(Decision.Accept());
}
private void GetDetails(RootFolder rootFolder)
{
Task.Run(() =>
{
if (_diskProvider.FolderExists(rootFolder.Path))
{
rootFolder.Accessible = true;
rootFolder.FreeSpace = _diskProvider.GetAvailableSpace(rootFolder.Path);
rootFolder.TotalSpace = _diskProvider.GetTotalSize(rootFolder.Path);
}
}).Wait(5000);
}
private void GetDetails(RootFolder rootFolder, List <string> moviePaths, bool timeout)
{
Task.Run(() =>
{
if (_diskProvider.FolderExists(rootFolder.Path))
{
rootFolder.Accessible = true;
rootFolder.FreeSpace = _diskProvider.GetAvailableSpace(rootFolder.Path);
rootFolder.TotalSpace = _diskProvider.GetTotalSize(rootFolder.Path);
rootFolder.UnmappedFolders = GetUnmappedFolders(rootFolder.Path, moviePaths);
}
}).Wait(timeout ? 5000 : -1);
}
public Decision IsSatisfiedBy(LocalBook item, DownloadClientItem downloadClientItem)
{
if (_configService.SkipFreeSpaceCheckWhenImporting)
{
_logger.Debug("Skipping free space check when importing");
return(Decision.Accept());
}
try
{
if (item.ExistingFile)
{
_logger.Debug("Skipping free space check for existing book");
return(Decision.Accept());
}
var path = Directory.GetParent(item.Author.Path);
var freeSpace = _diskProvider.GetAvailableSpace(path.FullName);
if (!freeSpace.HasValue)
{
_logger.Debug("Free space check returned an invalid result for: {0}", path);
return(Decision.Accept());
}
if (freeSpace < item.Size + _configService.MinimumFreeSpaceWhenImporting.Megabytes())
{
_logger.Warn("Not enough free space ({0}) to import: {1} ({2})", freeSpace, item, item.Size);
return(Decision.Reject("Not enough free space"));
}
}
catch (DirectoryNotFoundException ex)
{
_logger.Error(ex, "Unable to check free disk space while importing.");
}
catch (Exception ex)
{
_logger.Error(ex, "Unable to check free disk space while importing. {0}", item.Path);
}
return(Decision.Accept());
}
private IEnumerable <DiskSpace> GetDiskSpace(IEnumerable <string> paths, bool suppressWarnings = false)
{
foreach (var path in paths)
{
DiskSpace diskSpace = null;
try
{
var freeSpace = _diskProvider.GetAvailableSpace(path);
var totalSpace = _diskProvider.GetTotalSize(path);
if (!freeSpace.HasValue || !totalSpace.HasValue)
{
continue;
}
diskSpace = new DiskSpace
{
Path = path,
FreeSpace = freeSpace.Value,
TotalSpace = totalSpace.Value
};
diskSpace.Label = _diskProvider.GetVolumeLabel(path);
}
catch (Exception ex)
{
if (!suppressWarnings)
{
_logger.Warn(ex, "Unable to get free space for: " + path);
}
}
if (diskSpace != null)
{
yield return(diskSpace);
}
}
}
