private void inititalizeSectors(VirtualDriveParameters parameters)
{
lock (_sectorsLock)
{
var fileTableSector = new SectorInfo
{
StartPosition = FixedPositions.SectorsInformation + parameters.SectorsInformationRegionLength,
Length = parameters.EntriesTableSectorLength,
Mark = ServiceMarks.EntriesSector,
Id = 0
};
var contentSector = new SectorInfo
{
StartPosition = fileTableSector.StartPosition + fileTableSector.Length,
Length = 0,
Mark = ServiceMarks.ContentSector,
Id = 1
};
var fileTableSectorWriteOperation = writeSectorInfo(fileTableSector);
var contentSectorWriteOperation = writeSectorInfo(contentSector);
fileTableSectorWriteOperation.Task.Wait();
contentSectorWriteOperation.Task.Wait();
finalizeSectorRegion().Task.Wait();
}
}
public bool ShowCreateDriveFileDialog(out VirtualDriveParameters parameters, out string filename)
{
parameters = VirtualDriveParameters.Default;
filename = string.Empty;
var sfd = new SaveFileDialog
{
Filter = _fileDialogFilter
};
var result = sfd.ShowDialog(_startWindow);
var retv = result == true;
if (!retv)
{
return(false);
}
filename = sfd.FileName;
try
{
if (File.Exists(filename))
{
using (var t = File.Open(filename, FileMode.Open))
t.SetLength(0);
}
}
catch (Exception e)
{
ReportError("Unable to create file", e);
return(false);
}
return(true);
}
private static RawDataManager InitializeNewDrive(Drive.VirtualDrive drive, VirtualDriveParameters parameters)
{
var synchronizer = new DriveAccessSynchronizer(drive);
var retv = new RawDataManager(synchronizer);
retv.writeVirtualDriveParameters(parameters);
retv._sectorInfoWriter = new SectorInfoRawWriter(parameters, synchronizer);
retv.inititalizeSectors(parameters);
retv.writeAvailableContentBlocks();
synchronizer.DriveAccess.Wait();//wait for writing before initializing
try
{
retv.init();
}
catch (Exception)
{
synchronizer.Dispose();
throw;
}
var rootEntry = new DirectoryEntry
{
Id = 0,
DirectoryId = -1,
Name = string.Empty
};
retv.Write(rootEntry).Task.Wait(); //make sure that root is created
return(retv);
}
protected BaseRawWriter(VirtualDriveParameters virtualDriveParameters, DriveAccessSynchronizer synchronizer, long initialPosition)
{
Synchronizer = synchronizer;
VirtualDriveParameters = virtualDriveParameters;
CurrentPosition = initialPosition;
InitialPosition = initialPosition;
}
private WriteOperation writeVirtualDriveParameters(VirtualDriveParameters parameters)
{
lock (_virtualDriveParametersLock)
{
var bytes = new InternalVirtualDriveParameters(parameters).GetBytes();
return(_driveParametersWriter.Write(bytes));
}
}
public static RawDataManager Create(string storageFile, VirtualDriveParameters parameters)
{
var drive = new Drive.VirtualDrive(storageFile);
return(drive.IsEmpty
? InitializeNewDrive(drive, parameters)
: Initialize(drive));
}
public VirtualFileSystem(string filename, VirtualDriveParameters parameters)
{
File = filename;
_fileSystem = new InternalFileSystem(_synchronizationContext, filename, parameters);
if (_synchronizationContext == null)
{
throw new Exception("Syncronization context is missing");
}
}
private void init()
{
try
{
_parameters = readParameters();
_sectorInfoWriter = new SectorInfoRawWriter(_parameters, _synchronizer);
var sectors = readSectors();
foreach (var sectorInfo in sectors)
{
switch (sectorInfo.Mark)
{
case ServiceMarks.EntriesSector:
_currentFileEntriesSector = sectorInfo;
break;
case ServiceMarks.ContentSector:
_currentContentSector = sectorInfo;
break;
}
}
if (_currentFileEntriesSector == null || _currentContentSector == null)
{
throw new Exception("Sectors read error");
}
var entriesStartPosition = _currentFileEntriesSector.StartPosition;
_entryWriter = new EntryRawWriter(_parameters, _synchronizer, entriesStartPosition);
var contentStartPosition = _currentContentSector.StartPosition;
_contentWriter = new ContentRawWriter(_parameters, _synchronizer, contentStartPosition);
_contentWriter.SetLength(_currentContentSector.Length);
var availableContentBlocks = checkIfDriveIsFinalized()
? readAvailableContentBlocks()
: restoreAvailableContentBlocks();
foreach (var availableContentBlock in availableContentBlocks)
{
_contentWriter.AddAvailableBlock(availableContentBlock);
}
}
catch (Exception e)
{
throw new IOException("Virtual drive is corrupted", e);
}
}
public EntriesTableRawReader(DriveAccessSynchronizer synchronizer, VirtualDriveParameters parameters, long initialPosition)
: base(synchronizer, initialPosition)
{
_parameters = parameters;
}
protected OptimizedRawWriter(VirtualDriveParameters virtualDriveParameters, DriveAccessSynchronizer synchronizer, long initialPosition)
: base(virtualDriveParameters, synchronizer, initialPosition)
{
}
public SectorInfoRawReader(DriveAccessSynchronizer synchronizer, VirtualDriveParameters parameters)
: base(synchronizer, FixedPositions.SectorsInformation)
{
_parameters = parameters;
}
public InternalFileSystem(SynchronizationContext synchronizationContext, string fileName, VirtualDriveParameters parameters)
{
if (string.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException(nameof(fileName));
}
_synchronizationContext = synchronizationContext;
_directoryWatcherSource = new VirtualDirectoryWatcherSource(_synchronizationContext);
_rawDataManager = RawDataManager.Create(fileName, parameters
?? throw new ArgumentNullException(nameof(parameters)));
try
{
var entries = _rawDataManager.ReadEntries();
Indexer.Populate(entries);
}
catch (Exception e)
{
_rawDataManager.Dispose();
throw new Exception("FS initialization failed", e);
}
}
public EntryRawWriter(VirtualDriveParameters virtualDriveParameters, DriveAccessSynchronizer synchronizer, long initialPosition)
: base(virtualDriveParameters, synchronizer, initialPosition)
{
Length = virtualDriveParameters.EntriesTableSectorLength;
}
public SectorInfoRawWriter(VirtualDriveParameters virtualDriveParameters, DriveAccessSynchronizer synchronizer)
: base(virtualDriveParameters, synchronizer, FixedPositions.SectorsInformation)
{
Length = VirtualDriveParameters.SectorsInformationRegionLength;
}
public InternalVirtualDriveParameters(VirtualDriveParameters virtualDriveParameters)
: base(virtualDriveParameters.EntriesTableSectorLength, virtualDriveParameters.SectorsInformationRegionLength)
{
}
public ContentRawWriter(VirtualDriveParameters virtualDriveParameters, DriveAccessSynchronizer synchronizer, long initialPosition)
: base(virtualDriveParameters, synchronizer, initialPosition)
{
}
