public void MoveFile(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
using (Stream s = fi.Create())
{
for (int i = 0; i < 10; ++i)
{
s.Write(new byte[111], 0, 111);
}
}
fi.Attributes = FileAttributes.Hidden | FileAttributes.System;
fi.MoveTo("foo2.txt");
fi = fs.GetFileInfo("foo2.txt");
Assert.IsTrue(fi.Exists);
Assert.AreEqual(1110, fi.Length);
Assert.AreEqual(FileAttributes.Hidden | FileAttributes.System, fi.Attributes);
fi = fs.GetFileInfo("foo.txt");
Assert.IsFalse(fi.Exists);
}
public void Open_FileNotFound(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Open)) { }
}
public void Attributes_ChangeType(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
using (Stream s = fi.Open(FileMode.Create)) { }
fi.Attributes = fi.Attributes | FileAttributes.Directory;
}
public void Open_DirExists(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory("FOO.TXT");
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Create)) { s.WriteByte(1); }
}
public void Open_FileExists(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Create)) { s.WriteByte(1); }
using (Stream s = di.Open(FileMode.CreateNew)) { }
}
public void Open_Read_Fail(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Create, FileAccess.Read))
{
s.WriteByte(1);
}
}
public void Parent(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory(@"SOMEDIR\ADIR");
using (Stream s = fs.OpenFile(@"SOMEDIR\ADIR\FILE.TXT", FileMode.Create)) { }
DiscFileInfo fi = fs.GetFileInfo(@"SOMEDIR\ADIR\FILE.TXT");
Assert.AreEqual(fs.GetDirectoryInfo(@"SOMEDIR\ADIR"), fi.Parent);
Assert.AreEqual(fs.GetDirectoryInfo(@"SOMEDIR\ADIR"), fi.Directory);
}
public void Open_Write(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo di = fs.GetFileInfo("foo.txt");
using (Stream s = di.Open(FileMode.Create, FileAccess.Write))
{
Assert.IsTrue(s.CanWrite);
Assert.IsFalse(s.CanRead);
s.WriteByte(1);
}
}
public void DeleteFile(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.GetFileInfo("foo.txt").Open(FileMode.Create, FileAccess.ReadWrite)) { }
Assert.AreEqual(1, fs.Root.GetFiles().Length);
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
fi.Delete();
Assert.AreEqual(0, fs.Root.GetFiles().Length);
}
public void Exists(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
Assert.IsFalse(fi.Exists);
using (Stream s = fi.Open(FileMode.Create)) { }
Assert.IsTrue(fi.Exists);
fs.CreateDirectory("dir.txt");
Assert.IsFalse(fs.GetFileInfo("dir.txt").Exists);
}
public void LastWriteTime(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.OpenFile("foo.txt", FileMode.Create)) { }
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
DateTime baseTime = DateTime.Now - TimeSpan.FromMinutes(10);
fi.LastWriteTime = baseTime;
using (Stream s = fs.OpenFile("foo.txt", FileMode.Open)) { s.WriteByte(1); }
Assert.Less(baseTime, fi.LastWriteTime);
}
public void LastAccessTime(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.OpenFile("foo.txt", FileMode.Create)) { }
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
DateTime baseTime = DateTime.Now - TimeSpan.FromDays(2);
fi.LastAccessTime = baseTime;
using (Stream s = fs.OpenFile("foo.txt", FileMode.Open, FileAccess.Read)) { }
Assert.Less(baseTime, fi.LastAccessTime);
}
public void Attributes(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
using (Stream s = fi.Open(FileMode.Create)) { }
// Check default attributes
Assert.AreEqual(FileAttributes.Archive, fi.Attributes);
// Check round-trip
FileAttributes newAttrs = FileAttributes.Hidden | FileAttributes.ReadOnly | FileAttributes.System;
fi.Attributes = newAttrs;
Assert.AreEqual(newAttrs, fi.Attributes);
// And check persistence to disk
Assert.AreEqual(newAttrs, fs.GetFileInfo("foo.txt").Attributes);
}
public void CreateFile(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
using (Stream s = fs.GetFileInfo("foo.txt").Open(FileMode.Create, FileAccess.ReadWrite))
{
s.WriteByte(1);
}
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
Assert.IsTrue(fi.Exists);
Assert.AreEqual(FileAttributes.Archive, fi.Attributes);
Assert.AreEqual(1, fi.Length);
using (Stream s = fs.OpenFile("Foo.txt", FileMode.Open, FileAccess.Read))
{
Assert.AreEqual(1, s.ReadByte());
}
}
public void MoveFile_Overwrite(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscFileInfo fi = fs.GetFileInfo("foo.txt");
using (Stream s = fi.Create())
{
s.WriteByte(1);
}
DiscFileInfo fi2 = fs.GetFileInfo("foo2.txt");
using (Stream s = fi2.Create())
{
}
fs.MoveFile("foo.txt", "foo2.txt", true);
Assert.IsFalse(fi.Exists);
Assert.IsTrue(fi2.Exists);
Assert.AreEqual(1, fi2.Length);
}
public void Add(DiscFileInfo Source, DiscFileInfo Destination, DiscFileInfo Base = null)
{
_queue[Destination] = new Lineage(Source, Base);
}
private static bool FilesMatch(DiscFileInfo A, DiscFileInfo B)
{
const int BufferSize = 2048; // arbitrarily chosen buffer size
byte[] buffA = new byte[BufferSize];
byte[] buffB = new byte[BufferSize];
lock(A.FileSystem)
lock (B.FileSystem)
{
var fileA = A.OpenRead();
var fileB = B.OpenRead();
int numA, numB;
while (fileA.Position < fileA.Length)
{
numA = fileA.Read(buffA, 0, BufferSize);
numB = fileB.Read(buffB, 0, BufferSize);
if (numA != numB)
{
fileA.Close();
fileB.Close();
return false;
}
for (int i = 0; i < numA; i++)
if (buffA[i] != buffB[i])
{
fileA.Close();
fileB.Close();
return false;
}
}
fileA.Close();
fileB.Close();
return true;
}
}
/// <summary>
///
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
/// <param name="Style"></param>
/// <returns>True if A and B are equivalent.</returns>
private static bool CompareFile(DiscFileInfo A, DiscFileInfo B, ComparisonStyle Style = ComparisonStyle.DateTimeOnly)
{
if (A == null || B == null) return A == B;
lock (A.FileSystem)
lock (B.FileSystem)
if (!A.Exists || !B.Exists) return false;
if (Style == ComparisonStyle.Journaled)
if (A.FileSystem is NtfsFileSystem)
{
lock(A.FileSystem)
lock (B.FileSystem)
{
var An = A.FileSystem as NtfsFileSystem;
var Bn = (NtfsFileSystem) (B.FileSystem);
long Aid = (long) (An.GetFileId(A.FullName) & 0x0000ffffffffffff);
long Bid = (long) (Bn.GetFileId(B.FullName) & 0x0000ffffffffffff);
return An.GetMasterFileTable()[Aid].LogFileSequenceNumber ==
Bn.GetMasterFileTable()[Bid].LogFileSequenceNumber;
}
}
else throw new ArgumentException("Journal comparison only functions on NTFS partitions.", "Style");
bool LenCheck, WriteCheck;
lock (A.FileSystem)
lock (B.FileSystem)
{
LenCheck = A.Length == B.Length;
WriteCheck = A.LastWriteTimeUtc == B.LastWriteTimeUtc;
}
return LenCheck &&
(Style == ComparisonStyle.NameOnly || (Style == ComparisonStyle.BinaryOnly
? FilesMatch(A, B)
: (WriteCheck &&
(Style == ComparisonStyle.DateTimeOnly ||
FilesMatch(A, B)))));
}
public Lineage(DiscFileInfo source = null, DiscFileInfo @base = null)
{
Base = @base;
Source = source;
}
private void FileCopy(iSCSI iscsi, DiscFileInfo[] FileInfos, WimFileSystem w, NtfsFileSystem ntfs)
{
foreach (DiscFileInfo file in FileInfos)
{
if (IsExcluded(file.FullName))
{
log.InfoFormat("File Skip {0}", file.FullName);
continue;
}
FileAttributes attr = file.Attributes;
if ((attr & FileAttributes.ReparsePoint) == 0)
{
using (Stream source = w.OpenFile(file.FullName, FileMode.Open, FileAccess.Read))
{
using (Stream destin = ntfs.OpenFile(file.FullName, FileMode.Create, FileAccess.Write))
{
iscsi.WimCopy(source, destin, Path.GetFileName(file.FullName), false, wimFileIndex++, wimFileCount);
}
}
if ((attr & FileAttributes.Temporary) == FileAttributes.Temporary)
attr = attr & ~FileAttributes.Temporary;
if ((attr & FileAttributes.Offline) == FileAttributes.Offline)
attr = attr & ~FileAttributes.Offline;
ntfs.SetAttributes(file.FullName, attr);
}
else
{
traceLog.InfoFormat("Reparse Point: {0}", file.FullName);
ReparsePoint rp = w.GetReparsePoint(file.FullName);
ntfs.SetReparsePoint(file.FullName, rp);
}
}
}
internal void Add(DiscFileInfo Source, DiscFileInfo Destination)
{
_queue[Destination] = Source;
}
