private LfsOperationData(LfsOperations operation, LfsEntityType type)
{
Operation = operation;
Type = type;
FileSystemNumber = InvalidFileSystemNumber;
Uid = InvalidUid;
}
/// <summary>
/// Creates a new instance of the exception.
/// </summary>
/// <param name="message">The error message that explains the reason for the exception.</param>
/// <param name="entityType">The kind of file system entity the error pertains to.</param>
/// <param name="globalFileSystemNumber">The file system number (GDN, GFN, GKN) of the entry that the error pertains to.</param>
/// <param name="targetDeviceId">Unique ID of the target device of the operation when the error occurred. If <c>null</c> or empty, target device information is not available, or no target was involved.</param>
/// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no inner exception is specified.</param>
protected FailedOperationException(string message, LfsEntityType entityType, uint globalFileSystemNumber, string targetDeviceId, System.Exception innerException)
: base(message, innerException)
{
EntityType = entityType;
GlobalFileSystemNumber = globalFileSystemNumber;
TargetDeviceId = targetDeviceId;
}
/// <summary>
/// Initializes a new instance of GatherDifferencesDescriptor.
/// </summary>
/// <param name="entityType">The type of the file system entities this descriptor works with.</param>
/// <param name="targetFileSystemTable">The LFS file system table to be compared against a reference version.</param>
/// <param name="comparer">The comparison function to use to determine if a reference and target file system entity are different.</param>
/// <param name="validator">The validation function to use to determine if an entry is valid.</param>
/// <param name="ignorer">The function to use to determine whether to ignore an entry for computing differences.</param>
public GatherDifferencesDescriptor(LfsEntityType entityType, FixedSizeCollection <T> targetFileSystemTable, FileSystemEntryComparer <T> comparer, FileSystemEntryValidator <T> validator, Predicate <T> ignorer)
{
TargetFileSystemTable = targetFileSystemTable;
Compare = comparer;
Validate = validator ?? AlwaysValid;
Ignore = ignorer ?? NeverIgnore;
EntityType = entityType;
}
/// <summary>
/// Initializes a new instance of the <see cref="INTV.LtoFlash.Model.LfsUpdateOperation"/> class.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="operation">The nature of the operation.</param>
/// <param name="entityType">The kind of file system entity involved on the operation.</param>
/// <param name="entityId">The identifier (GDN, GFN, GKN) of the entity involved inthe operation.</param>
public LfsUpdateOperation(FileSystem fileSystem, LfsOperations operation, LfsEntityType entityType, ushort entityId)
{
FileSystem = fileSystem;
Operation = operation;
Directories = new HashSet <byte>();
Files = new HashSet <ushort>();
Forks = new HashSet <ushort>();
Failures = new HashSet <LfsOperationFailure>();
}
/// <summary>
/// Wraps the given exception as the InnerException if it is not already a FailedOperationException.
/// </summary>
/// <param name="error">The error to wrap.</param>
/// <param name="entityType">The kind of file system entity the error pertains to.</param>
/// <param name="globalFileSystemNumber">The file system number (GDN, GFN, GKN) of the entry that the error pertains to.</param>
/// <param name="targetDeviceId">The unique ID of the device involved in the operation. If empty or <c>null</c>, the error is not targeting actual hardware.</param>
/// <returns>If <paramref name="error"/> is a <see cref="FailedOperationException"/>, then it is returned unchanged, otherwise it is the inner exception for a new <see cref="FailedOperationException"/>.</returns>
public static FailedOperationException WrapIfNeeded(System.Exception error, LfsEntityType entityType, uint globalFileSystemNumber, string targetDeviceId)
{
var failedComparison = error as FailedOperationException;
if (failedComparison == null)
{
failedComparison = new FailedOperationException(error.Message, entityType, globalFileSystemNumber, targetDeviceId, error);
}
return(failedComparison);
}
/// <summary>
/// Initializes a new instance of of the InconsistentFileSystemException class.
/// </summary>
/// <param name="entityType">The type of the file system entity that could not be located.</param>
/// <param name="globalFileSystemNumber">The global file system identifier of the entity that could not be located.</param>
/// <param name="targetDeviceId">The unique ID of the device whose file system is in an inconsistent state.</param>
/// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no such exception exists.</param>
public InconsistentFileSystemException(LfsEntityType entityType, uint globalFileSystemNumber, string targetDeviceId, System.Exception innerException)
: this(string.Format(Resources.Strings.FileSystem_InconsistencyError_Format, entityType, globalFileSystemNumber), entityType, globalFileSystemNumber, targetDeviceId, innerException)
{
}
/// <summary>
/// Initializes a new instance of of the InconsistentFileSystemException class.
/// </summary>
/// <param name="entityType">The type of the file system entity that could not be located.</param>
/// <param name="globalFileSystemNumber">The global file system identifier of the entity that could not be located.</param>
/// <param name="targetDeviceId">The unique ID of the device whose file system is in an inconsistent state.</param>
/// <param name="customErrorFormat">Custom error format for the message. Must have {0} for entity type and {1} for global file system number.</param>
public InconsistentFileSystemException(LfsEntityType entityType, uint globalFileSystemNumber, string targetDeviceId, string customErrorFormat)
: this(string.Format(customErrorFormat, entityType, globalFileSystemNumber), entityType, globalFileSystemNumber, targetDeviceId, null)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="INTV.LtoFlash.InconsistentFileSystemException"/> class.
/// </summary>
/// <param name="message">Custom message for the inconsistency.</param>
/// <param name="entityType">The type of the file system entity that could not be located.</param>
/// <param name="globalFileSystemNumber">The global file system identifier of the entity that could not be located.</param>
/// <param name="targetDeviceId">The unique ID of the device whose file system is in an inconsistent state.</param>
public InconsistentFileSystemException(string message, LfsEntityType entityType, uint globalFileSystemNumber, string targetDeviceId)
: this(message, entityType, globalFileSystemNumber, targetDeviceId, null)
{
}
/// <summary>
/// Initializes a new instance of of the InconsistentFileSystemException class.
/// </summary>
/// <param name="entityType">The type of the file system entity that could not be located.</param>
/// <param name="globalFileSystemNumber">The global file system identifier of the entity that could not be located.</param>
/// <param name="targetDeviceId">The unique ID of the device whose file system is in an inconsistent state.</param>
public InconsistentFileSystemException(LfsEntityType entityType, uint globalFileSystemNumber, string targetDeviceId)
: this(entityType, globalFileSystemNumber, targetDeviceId, Resources.Strings.FileSystem_InconsistencyError_Format)
{
}
/// <summary>
/// Initializes a new instance of GatherDifferencesDescriptor.
/// </summary>
/// <param name="entityType">The type of the file system entities this descriptor works with.</param>
/// <param name="targetFileSystemTable">The LFS file system table to be compared against a reference version.</param>
/// <param name="comparer">The comparison function to use to determine if a reference and target file system entity are different.</param>
public GatherDifferencesDescriptor(LfsEntityType entityType, FixedSizeCollection <T> targetFileSystemTable, FileSystemEntryComparer <T> comparer)
: this(entityType, targetFileSystemTable, comparer, AlwaysValid)
{
}
/// <summary>
/// Initializes a new instance of DeleteOperationData.
/// </summary>
/// <param name="taskData">Task data for error reporting.</param>
/// <param name="targetType">The entry type being deleted.</param>
public DeleteOperationData(ExecuteDeviceCommandAsyncTaskData taskData, LfsEntityType targetType)
: base(LfsOperations.Remove, taskData)
{
TargetType = targetType;
}
/// <summary>
/// If the operation should update the file system's dirty flags, and hasn't done so already, do so.
/// </summary>
/// <param name="currentDirtyFlags">The current dirty flags on the file system.</param>
/// <param name="fileSystem">The file system being updated.</param>
/// <param name="taskData">Task data for displaying updates, tracking success, etc.</param>
/// <param name="globalFileSystemNumber">If an error occurs, the entity type and its global file system number value are used to report the error.</param>
/// <param name="operation">The kind of file system operation being done.</param>
/// <param name="targetType">The kind of file system entity involved in the operation.</param>
/// <returns>The new dirty flags.</returns>
private static LfsDirtyFlags UpdateFileSystemDirtyState(this LfsDirtyFlags currentDirtyFlags, FileSystem fileSystem, ExecuteDeviceCommandAsyncTaskData taskData, uint globalFileSystemNumber, LfsOperations operation, LfsEntityType targetType)
{
if (taskData.Succeeded && !currentDirtyFlags.HasFlag(LfsDirtyFlags.FileSystemUpdateInProgress))
{
currentDirtyFlags |= LfsDirtyFlags.FileSystemUpdateInProgress;
taskData.Succeeded = SetDirtyFlags.Create(currentDirtyFlags).Execute <bool>(taskData.Device.Port, taskData);
}
if (!taskData.Succeeded && currentDirtyFlags.HasFlag(LfsDirtyFlags.FileSystemUpdateInProgress))
{
var errorFormatString = Resources.Strings.FileSystem_InconsistencyError_Format;
if (operation == LfsOperations.Remove)
{
errorFormatString = Resources.Strings.FileSystem_InconsistencyError_Deleting_Format;
}
else if (operation == LfsOperations.Add)
{
errorFormatString = Resources.Strings.FileSystem_InconsistencyError_Creating_Format;
}
else if (operation == LfsOperations.Update)
{
errorFormatString = Resources.Strings.FileSystem_InconsistencyError_Updating_Format;
}
throw new InconsistentFileSystemException(targetType, globalFileSystemNumber, errorFormatString);
}
fileSystem.Status = currentDirtyFlags;
return(currentDirtyFlags);
}
private LfsOperationData(LfsOperations operation, LfsEntityType type, IGlobalFileSystemEntry fileSystemEntry)
: this(operation, type)
{
Uid = fileSystemEntry.Uid;
FileSystemNumber = InvalidFileSystemNumber;
}
/// <summary>
/// Initializes a new instance of GatherDifferencesDescriptor.
/// </summary>
/// <param name="entityType">The type of the file system entities this descriptor works with.</param>
/// <param name="targetFileSystemTable">The LFS file system table to be compared against a reference version.</param>
/// <param name="comparer">The comparison function to use to determine if a reference and target file system entity are different.</param>
/// <param name="validator">The validation function to use to determine if an entry is valid.</param>
public GatherDifferencesDescriptor(LfsEntityType entityType, FixedSizeCollection <T> targetFileSystemTable, FileSystemEntryComparer <T> comparer, FileSystemEntryValidator <T> validator)
: this(entityType, targetFileSystemTable, comparer, validator, NeverIgnore)
{
}
/// <summary>
/// Initializes a new instance of of the InconsistentFileSystemException class.
/// </summary>
/// <param name="message">Custom message for the inconsistency.</param>
/// <param name="entityType">The type of the file system entity that could not be located.</param>
/// <param name="globalFileSystemNumber">The global file system identifier of the entity that could not be located.</param>
/// <param name="targetDeviceId">The unique ID of the device whose file system is in an inconsistent state.</param>
/// <param name="innerException">The exception that is the cause of the current exception, or <c>null</c> if no such exception exists.</param>
private InconsistentFileSystemException(string message, LfsEntityType entityType, uint globalFileSystemNumber, string targetDeviceId, System.Exception innerException)
: base(message, entityType, globalFileSystemNumber, targetDeviceId, innerException)
{
}
/// <summary>
/// Record a failed update operation.
/// </summary>
/// <param name="entryType">The kind of entry whose update operation failed.</param>
/// <param name="id">The LFS identifier of the entity.</param>
/// <param name="name">User-facing name of the entity.</param>
/// <param name="exception">The error that occurred.</param>
/// <param name="targetDeviceId">The unique ID of the target device involved in the operation.</param>
public void RecordFailure(LfsEntityType entryType, ushort id, string name, Exception exception, string targetDeviceId)
{
var error = FailedOperationException.WrapIfNeeded(exception, entryType, id, targetDeviceId);
RecordFailure(name, error);
}
/// <summary>
/// Initializes a new instance of of the InconsistentFileSystemException class.
/// </summary>
/// <param name="entityType">The type of the file system entity that could not be located.</param>
/// <param name="targetDeviceId">The unique ID of the device whose file system is in an inconsistent state.</param>
public InconsistentFileSystemException(LfsEntityType entityType, string targetDeviceId)
: this(string.Format(System.Globalization.CultureInfo.CurrentCulture, Resources.Strings.FileSystem_InconsistencyError_MissingEntry_Format, entityType), entityType, uint.MaxValue, targetDeviceId)
{
}
/// <summary>
/// Checks to see if the given destination can accept more items.
/// </summary>
/// <param name="destination">The destination for another file system entry.</param>
/// <param name="entityType">The type if the file system entry (fork, file, directory).</param>
/// <param name="count">The number of new entries of the given type.</param>
/// <param name="addingNewItems">If <c>true</c>, indicates new entries are being added; if <c>false</c>, items are moving from one location to another.</param>
/// <param name="reasonForFailure">Receives error description.</param>
/// <returns><c>true</c> if <paramref name="destination"/> is able to accept at least <paramref name="count"/> new items.</returns>
internal static bool FileSystemCanAcceptMoreItems(IFile destination, LfsEntityType entityType, int count, bool addingNewItems, out string reasonForFailure)
{
reasonForFailure = string.Empty;
var directory = destination as Folder;
var file = destination as FileNode;
var canAccept = (directory != null) || (file != null);
if (canAccept)
{
var destinationType = (directory != null) ? LfsEntityType.Directory : ((file != null) ? LfsEntityType.File : LfsEntityType.Unknown);
System.Diagnostics.Debug.Assert(destinationType != LfsEntityType.Unknown, "Unknown destination for new file system entry.");
var fileSystem = file.FileSystem;
switch (entityType)
{
case LfsEntityType.Directory:
// If we're operating on directories, they must go inside another directory.
canAccept = (count + directory.Size) <= FileSystemConstants.MaxItemCount;
if (!canAccept)
{
reasonForFailure = string.Format(Resources.Strings.AddItemRejected_TooManyFiles_Format, FileSystemConstants.MaxItemCount);
}
if (addingNewItems && canAccept)
{
// New directory requires space in GDT and GFT.
canAccept &= (count + fileSystem.Directories.ItemsInUse) <= GlobalDirectoryTable.TableSize;
if (!canAccept)
{
reasonForFailure = string.Format(Resources.Strings.AddItemRejected_TooManyFolders_Format, GlobalDirectoryTable.TableSize);
}
if (canAccept)
{
canAccept &= (count + fileSystem.Files.ItemsInUse) <= GlobalFileTable.TableSize;
if (!canAccept)
{
reasonForFailure = string.Format(Resources.Strings.AddItemRejected_TooManyFileSystemFiles_Format, GlobalFileTable.TableSize);
}
}
}
break;
case LfsEntityType.File:
// If we're operating on files, they must go inside a directory.
canAccept = (count + directory.Size) <= FileSystemConstants.MaxItemCount;
if (!canAccept)
{
reasonForFailure = string.Format(Resources.Strings.AddItemRejected_TooManyFiles_Format, FileSystemConstants.MaxItemCount);
}
if (addingNewItems && canAccept)
{
// New files require space in the GFT and GKT -- useful files typically use *at least* one fork for our purposes,
// though, strictly speaking, not all files require a fork. (E.g. the file for the root directory.)
canAccept &= (count + fileSystem.Files.ItemsInUse) <= GlobalFileTable.TableSize;
if (!canAccept)
{
reasonForFailure = string.Format(Resources.Strings.AddItemRejected_TooManyFileSystemFiles_Format, GlobalFileTable.TableSize);
}
if (canAccept)
{
canAccept &= (count + fileSystem.Forks.ItemsInUse) <= GlobalForkTable.TableSize;
if (!canAccept)
{
reasonForFailure = string.Format(Resources.Strings.AddItemRejected_TooManyForks_Format, GlobalForkTable.TableSize);
}
}
}
break;
case LfsEntityType.Fork:
// Forks go within files - so we only need to check fork table.
if (addingNewItems)
{
canAccept = (count + fileSystem.Forks.ItemsInUse) <= GlobalForkTable.TableSize;
if (!canAccept)
{
reasonForFailure = string.Format(Resources.Strings.AddItemRejected_TooManyForks_Format, GlobalForkTable.TableSize);
}
}
break;
default:
canAccept = false;
reasonForFailure = string.Format(Resources.Strings.AddItemRejected_UnknownFileSystemEntityType_Format, entityType);
break;
}
}
else
{
if ((directory == null) && (file == null))
{
reasonForFailure = Resources.Strings.AddItemRejected_InvalidFolderAndFile;
}
else if (directory == null)
{
reasonForFailure = Resources.Strings.AddItemRejected_InvalidFolder;
}
else if (file == null)
{
reasonForFailure = Resources.Strings.AddItemRejected_InvalidFile;
}
}
return(canAccept);
}
/// <summary>
/// Initialize a new instance of IncompatibleRomException.
/// </summary>
/// <param name="rom">The ROM that cannot execute on the target device.</param>
/// <param name="requiredDeviceId">Unique ID of the device needed to execute the ROM.</param>
/// <param name="targetDeviceId">Unique ID of the device upon which ROM execution will fail.</param>
/// <param name="entityType">The type of the file system entity that is incompatible.</param>
/// <param name="globalFileSystemNumber">The global file system identifier of the entity that is incompatible.</param>
public IncompatibleRomException(IRom rom, string requiredDeviceId, string targetDeviceId, LfsEntityType entityType, uint globalFileSystemNumber)
: base(string.Format(Resources.Strings.IncompatibleRomException_MessageFormat, rom.RomPath, requiredDeviceId, targetDeviceId), entityType, globalFileSystemNumber, targetDeviceId, null)
{
Rom = rom;
RequiredDeviceId = requiredDeviceId;
}
