internal static void CreateDirectoryTree(DiscDirectoryInfo source, DiscDirectoryInfo destination)
{
try
{
if (source == null)
throw new ArgumentNullException("source");
if (destination == null)
throw new ArgumentNullException("destination");
if (destination.Exists) return;
if (!destination.Parent.Exists)
CreateDirectoryTree(source.Parent, destination.Parent);
destination.Create();
destination.Attributes = source.Attributes;
if (destination.FileSystem is NtfsFileSystem)
{
var D = (NtfsFileSystem) destination.FileSystem;
var S = (NtfsFileSystem) source.FileSystem;
D.SetSecurity(destination.FullName, S.GetSecurity(source.FullName));
D.SetFileStandardInformation(destination.FullName, S.GetFileStandardInformation(source.FullName));
}
else
{
destination.CreationTimeUtc = source.CreationTimeUtc;
destination.LastWriteTimeUtc = source.LastWriteTimeUtc;
destination.LastAccessTimeUtc = source.LastAccessTimeUtc;
}
}
catch (Exception e)
{
throw;
}
}
public void GetDirectories(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory(@"SOMEDIR\CHILD\GCHILD");
fs.CreateDirectory(@"A.DIR");
Assert.AreEqual(2, fs.Root.GetDirectories().Length);
DiscDirectoryInfo someDir = fs.Root.GetDirectories(@"SoMeDir")[0];
Assert.AreEqual(1, fs.Root.GetDirectories("SOMEDIR").Length);
Assert.AreEqual("SOMEDIR", someDir.Name);
Assert.AreEqual(1, someDir.GetDirectories("*.*").Length);
Assert.AreEqual("CHILD", someDir.GetDirectories("*.*")[0].Name);
Assert.AreEqual(2, someDir.GetDirectories("*.*", SearchOption.AllDirectories).Length);
Assert.AreEqual(4, fs.Root.GetDirectories("*.*", SearchOption.AllDirectories).Length);
Assert.AreEqual(2, fs.Root.GetDirectories("*.*", SearchOption.TopDirectoryOnly).Length);
Assert.AreEqual(1, fs.Root.GetDirectories("*.DIR", SearchOption.AllDirectories).Length);
Assert.AreEqual(@"A.DIR\", fs.Root.GetDirectories("*.DIR", SearchOption.AllDirectories)[0].FullName);
Assert.AreEqual(1, fs.Root.GetDirectories("GCHILD", SearchOption.AllDirectories).Length);
Assert.AreEqual(@"SOMEDIR\CHILD\GCHILD\", fs.Root.GetDirectories("GCHILD", SearchOption.AllDirectories)[0].FullName);
}
public void ExtractDirectory(DiscDirectoryInfo Dinfo, string RootPath, string PathinISO)
{
if (!string.IsNullOrWhiteSpace(PathinISO))
{
PathinISO += "\\" + Dinfo.Name;
}
RootPath += "\\" + Dinfo.Name;
AppendDirectory(RootPath);
Form1 form1 = new Form1();
foreach (DiscDirectoryInfo dinfo in Dinfo.GetDirectories())
{
ExtractDirectory(dinfo, RootPath, PathinISO);
}
foreach (DiscFileInfo finfo in Dinfo.GetFiles())
{
using (Stream FileStr = finfo.OpenRead())
{
using (FileStream Fs = File.Create(RootPath + "\\" + finfo.Name)) // Here you can Set the BufferSize Also e.g. File.Create(RootPath + "\\" + finfo.Name, 4 * 1024)
{
FileStr.CopyTo(Fs, 4 * 1024); // Buffer Size is 4 * 1024 but you can modify it in your code as per your need
}
}
}
}
public void CreateInvalid_Characters(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo("SOME\0DIR");
dirInfo.Create();
}
public void CreateInvalid_Long(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo(new String('X', 256));
dirInfo.Create();
}
public void Create(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo("SOMEDIR");
dirInfo.Create();
Assert.AreEqual(1, fs.Root.GetDirectories().Length);
}
public void CreateRecursive(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR");
dirInfo.Create();
Assert.AreEqual(1, fs.Root.GetDirectories().Length);
Assert.AreEqual(1, fs.GetDirectoryInfo(@"SOMEDIR").GetDirectories().Length);
Assert.AreEqual("CHILDDIR", fs.GetDirectoryInfo(@"SOMEDIR").GetDirectories()[0].Name);
}
public void Exists(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR");
dirInfo.Create();
Assert.IsTrue(fs.GetDirectoryInfo(@"\").Exists);
Assert.IsTrue(fs.GetDirectoryInfo(@"SOMEDIR").Exists);
Assert.IsTrue(fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR").Exists);
Assert.IsTrue(fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR\").Exists);
Assert.IsFalse(fs.GetDirectoryInfo(@"NONDIR").Exists);
Assert.IsFalse(fs.GetDirectoryInfo(@"SOMEDIR\NONDIR").Exists);
}
public void LastWriteTime(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory("DIR");
DiscDirectoryInfo di = fs.GetDirectoryInfo("DIR");
DateTime baseTime = DateTime.Now - TimeSpan.FromMinutes(10);
di.LastWriteTime = baseTime;
fs.CreateDirectory(@"DIR\CHILD");
Assert.Less(baseTime, di.LastWriteTime);
}
public void CreateDeleteLeakTest(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
for (int i = 0; i < 2000; ++i)
{
fs.CreateDirectory(@"Fred");
fs.Root.GetDirectories(@"Fred")[0].Delete();
}
fs.CreateDirectory(@"SOMEDIR");
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo(@"SOMEDIR");
Assert.IsNotNull(dirInfo);
for (int i = 0; i < 2000; ++i)
{
fs.CreateDirectory(@"SOMEDIR\Fred");
dirInfo.GetDirectories(@"Fred")[0].Delete();
}
}
private static void ExtractDirectory(DiscDirectoryInfo Dinfo, string RootPath, string PathinISO)
{
if (!string.IsNullOrWhiteSpace(PathinISO))
{
PathinISO += "\\" + Dinfo.Name;
}
RootPath += "\\" + Dinfo.Name;
AppendDirectory(RootPath);
foreach (DiscDirectoryInfo dinfo in Dinfo.GetDirectories())
{
ExtractDirectory(dinfo, RootPath, PathinISO);
}
foreach (DiscFileInfo finfo in Dinfo.GetFiles())
{
using (Stream FileStr = finfo.OpenRead())
{
using (FileStream Fs = File.Create(RootPath + "\\" + finfo.Name))
{
FileStr.CopyTo(Fs, 4 * 1024);
}
}
}
}
private void FileCopy(iSCSI iscsi, DiscDirectoryInfo[] DirInfos, WimFileSystem w, NtfsFileSystem ntfs)
{
foreach (DiscDirectoryInfo dir in DirInfos)
{
if (IsExcluded(dir.FullName))
{
log.InfoFormat("Directory Skip {0}", dir.FullName);
continue;
}
FileAttributes attr = dir.Attributes;
if ((dir.Attributes & FileAttributes.ReparsePoint) == 0)
{
ntfs.CreateDirectory(dir.FullName);
if ((attr & FileAttributes.Temporary) == FileAttributes.Temporary)
attr = attr & ~FileAttributes.Temporary;
if ((attr & FileAttributes.Offline) == FileAttributes.Offline)
attr = attr & ~FileAttributes.Offline;
ntfs.SetAttributes(dir.FullName, attr);
FileCopy(iscsi, dir.GetDirectories(), w, ntfs);
FileCopy(iscsi, dir.GetFiles(), w, ntfs);
}
else
{
traceLog.InfoFormat("Directory ReparsePoint {0}", dir.FullName);
ReparsePoint rp = w.GetReparsePoint(dir.FullName);
ntfs.CreateDirectory(dir.FullName);
ntfs.SetReparsePoint(dir.FullName, rp);
}
}
}
private static Task CompTree(DiscDirectoryInfo A, DiscDirectoryInfo B, DiscDirectoryInfo Out,
CopyQueue WriteQueue, ComparisonStyle Style = ComparisonStyle.DateTimeOnly)
{
if (WriteQueue == null) throw new ArgumentNullException("WriteQueue");
List<Task> tasks = new List<Task>();
DiscFileSystem Alock = A.FileSystem;
DiscFileSystem Block = B.FileSystem;
DiscFileSystem Olock = Out.FileSystem;
ParallelQuery<DiscFileInfo> BFiles;
lock(Block)
BFiles = B.GetFiles("*.*", SearchOption.AllDirectories).ToArray().AsParallel();
BFiles = BFiles.Where(file =>
!ExcludeFiles.Contains(file.FullName.ToUpperInvariant())
).AsParallel();
BFiles = ExclusionRules.Aggregate(BFiles, (current, rule) => current.Where(file => !rule.IsMatch(file.FullName)));
BFiles = BFiles.Where(file =>
{
DiscFileInfo Atmp;
lock (Alock)
Atmp = Alock.GetFileInfo(file.FullName);
return !CompareFile(Atmp, file, Style);
}).ToArray().AsParallel();
foreach (var file in BFiles)
{
DiscFileInfo outFile;
lock (Olock)
outFile = Out.FileSystem.GetFileInfo(Path.Combine(Out.FullName, file.FullName));
lock (Alock)
WriteQueue.Add(file, outFile, Alock.GetFileInfo(file.FullName));
}
return Task.Factory.StartNew(() => Task.WaitAll(tasks.ToArray()), TaskCreationOptions.AttachedToParent);
}
private static void CompareTree(DiscDirectoryInfo A, DiscDirectoryInfo B, DiscDirectoryInfo Out,
CopyQueue WriteQueue, ComparisonStyle Style = ComparisonStyle.DateTimeOnly)
{
CompTree(A, B, Out, WriteQueue, Style).Wait();
}
private static void ShowDir(DiscDirectoryInfo dirInfo, int indent)
{
Console.WriteLine("{0}{1,-50} [{2}]", new String(' ', indent), CleanName(dirInfo.FullName), dirInfo.CreationTimeUtc);
foreach (DiscDirectoryInfo subDir in dirInfo.GetDirectories())
{
ShowDir(subDir, indent + 0);
}
foreach (DiscFileInfo file in dirInfo.GetFiles())
{
Console.WriteLine("{0}{1,-50} [{2}]", new String(' ', indent), CleanName(file.FullName), file.CreationTimeUtc);
}
}
private void CopyDirectory(DiscDirectoryInfo source, DirectoryInfo target, bool recurse)
{
if (recurse)
{
foreach (var childDiscDirectory in source.GetDirectories())
{
DirectoryInfo childDirectory = target.CreateSubdirectory(childDiscDirectory.Name);
CopyDirectory(childDiscDirectory, childDirectory, recurse);
}
}
Console.WriteLine("{0}", source.Name);
foreach (var childFile in source.GetFiles())
{
using (Stream sourceStream = childFile.OpenRead())
using (Stream targetStream = File.OpenWrite(Path.Combine(target.FullName, childFile.Name)))
{
sourceStream.CopyTo(targetStream);
}
}
}
