/// <summary>
/// Copy Folder method called by the CopyItem delegate to dequeue a folder copy item
/// This method enumerates the folder enqueues all its children and dequeues the current item
/// </summary>
/// <param name="sourceDir">
/// Source folder to be copied
/// </param>
/// <param name="destinationDir">
/// Destination folder
/// </param>
private void CopyFolder(string sourceDir, string destinationDir)
{
// create the destination folder if it doesn't exist
if (!FabricDirectory.Exists(destinationDir))
{
FabricDirectory.CreateDirectory(destinationDir);
}
// Enumerate source and queue up work items for each child folder
var directoryNames = FabricDirectory.GetDirectories(
sourceDir,
"*",
false, // full path
SearchOption.TopDirectoryOnly);
var fileNames = FabricDirectory.GetFiles(
sourceDir,
"*",
false, // full path
SearchOption.TopDirectoryOnly);
foreach (var directoryName in directoryNames)
{
this.QueueCopyItem(sourceDir, destinationDir, directoryName, true);
}
foreach (var fileName in fileNames)
{
this.QueueCopyItem(sourceDir, destinationDir, fileName, false);
}
}
private bool EnumerateFolders(object context)
{
var folderEnumerateInfo = (FolderEnumerateInfo)context;
folderEnumerateInfo.SubFolders = FabricDirectory.GetDirectories(folderEnumerateInfo.DirectoryPath, "*", folderEnumerateInfo.GetFullPath, SearchOption.TopDirectoryOnly).Where(x => x.CompareTo(folderEnumerateInfo.DirectoryPathContinuationToken) >= 0).ToList();
return(true);
}
public void FabricDirectory_GetDirectoriesNegative()
{
LogHelper.Log("FabricDirectory.GetDirectories {0}", BadPath);
var res = FabricDirectory.GetDirectories(BadPath);
Assert.AreEqual(0, res.Length);
}
/// <summary>
/// Retrieve files and folders under the current folder from SMB
/// </summary>
/// <param name="srcPath"> The SMB path </param>
/// <param name="files">String array of file names in the folder</param>
/// <param name="folders">String array of subfolder names in the folder</param>
private static void GetFilesAndSubfoldersFromSMB(
string srcPath,
out string[] files,
out string[] folders)
{
files = FabricDirectory.GetFiles(srcPath);
folders = FabricDirectory.GetDirectories(srcPath);
}
/// <summary>
/// Generates checksum files for all service package sub-directories (i.e. code/config/data packages) and service manifests found under the application package root directory.
/// </summary>
/// <param name="appPackageRootDirectory">The application package root directory.</param>
/// <param name="progressHandler">An optional handler for tracking progress of the checksum generation.</param>
/// <param name="isImageStoreServiceEnabled">Should be set to true if the cluster's ImageStoreConnectionString is set to "fabric:ImageStore", false otherwise.</param>
/// <remarks>
/// <para>
/// The cluster will automatically generate checksums during application type registration if they're not already part of the application package. This method can be used to incur the cost of checksum file generation while preparing the application package, which will reduce the cost of registering the application type package for large packages.
/// </para>
/// </remarks>
public static void GenerateApplicationPackageChecksumFiles(
string appPackageRootDirectory,
IImageStoreProgressHandler progressHandler,
bool isImageStoreServiceEnabled = true)
{
var layoutSpecification = BuildLayoutSpecification.Create();
var files = new List <string>();
var directories = new List <string>();
foreach (var servicePackageDirectory in FabricDirectory.GetDirectories(appPackageRootDirectory))
{
files.AddRange(FabricDirectory.GetFiles(servicePackageDirectory));
directories.AddRange(FabricDirectory.GetDirectories(servicePackageDirectory));
}
int completedItems = 0;
int totalItems = files.Count + directories.Count;
foreach (var file in files)
{
GenerateChecksumFile(file, layoutSpecification, isImageStoreServiceEnabled);
try
{
if (progressHandler != null)
{
progressHandler.UpdateProgress(++completedItems, totalItems, ProgressUnitType.Files);
}
}
catch (Exception)
{
// Do not fail checksum processing if progress update fails
}
}
foreach (var directory in directories)
{
GenerateChecksumFile(directory, layoutSpecification, isImageStoreServiceEnabled);
try
{
if (progressHandler != null)
{
progressHandler.UpdateProgress(++completedItems, totalItems, ProgressUnitType.Files);
}
}
catch (Exception)
{
// Do not fail checksum processing if progress update fails
}
}
}
// ImageStoreService does not preserve file case when downloading. Hence the hash is always computed on
// lower-cased dir/file name. This causes Test-ServiceFabricApplicationPackage to fail which has FileImageStore
// as source but ImageStoreService as destination ImageStore. imageStoreServiceEnabled is passed in
// so that we always use lowercase dir/file name to compute checksum when ImageStoreService is used and
// support backward compatibility
public static byte[] ComputeHashOnDirectory(string directory, bool imageStoreServiceEnabled)
{
List <Tuple <string, byte[], byte[]> > dirHashes = new List <Tuple <string, byte[], byte[]> >();
List <Tuple <string, byte[], byte[]> > fileHashes = new List <Tuple <string, byte[], byte[]> >();
Parallel.Invoke(() => Parallel.ForEach(FabricDirectory.GetDirectories(directory), subDirectory =>
{
var subDirName = Path.GetFileName(subDirectory.TrimEnd(new char[] { Path.DirectorySeparatorChar }));
byte[] subDirectoryHash = ComputeHashOnDirectory(subDirectory, imageStoreServiceEnabled);
string subDirectoryNameString = imageStoreServiceEnabled ? subDirName.ToLower() : subDirName;
byte[] subDirectoryName = Encoding.GetEncoding(0).GetBytes(subDirectoryNameString);
lock (dirHashes)
{
dirHashes.Add(Tuple.Create(subDirectory, subDirectoryName, subDirectoryHash));
}
}),
() => Parallel.ForEach(FabricDirectory.GetFiles(directory), file =>
{
using (FileStream fileStream = FabricFile.Open(file, FileMode.Open, FileAccess.Read))
{
byte[] fileHash = ComputeHashOnStream(fileStream);
string fileNameString = imageStoreServiceEnabled ? Path.GetFileName(file).ToLower() : Path.GetFileName(file);
byte[] fileName = Encoding.GetEncoding(0).GetBytes(fileNameString);
lock (fileHashes)
{
fileHashes.Add(Tuple.Create(file, fileName, fileHash));
}
}
}));
using (Stream hashStream = new MemoryStream())
{
foreach (var t in dirHashes.OrderBy(t => t.Item1))
{
hashStream.Write(t.Item2, 0, t.Item2.Length);
hashStream.Write(t.Item3, 0, t.Item3.Length);
}
foreach (var t in fileHashes.OrderBy(t => t.Item1))
{
hashStream.Write(t.Item2, 0, t.Item2.Length);
hashStream.Write(t.Item3, 0, t.Item3.Length);
}
hashStream.Seek(0, SeekOrigin.Begin);
return(ComputeHashOnStream(hashStream));
}
}
internal static bool ShouldUseOldWorkLocations(string logDirectory)
{
return(FabricDirectory.GetDirectories(
logDirectory,
"*",
SearchOption.AllDirectories)
.Where(dirFullName =>
{
string dirName = Path.GetFileName(dirFullName);
return dirName.StartsWith(
FileShareUploaderConstants.V2FileShareUploaderPrefix,
StringComparison.OrdinalIgnoreCase);
}).Any());
}
private void EstimateTotalByteCount(string dirFullPath)
{
var fileFullPaths = FabricDirectory.GetFiles(dirFullPath, "*", true, SearchOption.AllDirectories);
this.totalFileCountEstimate += fileFullPaths.Length;
foreach (var fileFullPath in fileFullPaths)
{
this.totalByteCountEstimate += FabricFile.GetSize(fileFullPath);
this.UpdateProgressEstimatingPackageSizeDetails();
}
this.totalFileCountEstimate += FabricDirectory.GetDirectories(dirFullPath, "*", SearchOption.AllDirectories).Length;
++this.totalFileCountEstimate;
}
private ImageStoreContent GetFilesAndSubFolders(string directory, string storeSource, TimeSpan timeout)
{
TimeoutHelper helper = timeout == TimeSpan.MaxValue ? null : new TimeoutHelper(timeout);
var directoryFullNames = FabricDirectory.GetDirectories(directory);
var fileFullNames = FabricDirectory.GetFiles(directory);
var content = new ImageStoreContent();
foreach (var fileFullName in fileFullNames)
{
if (content.Files == null)
{
content.Files = new List <ImageStoreFile>();
}
content.Files.Add(this.ConvertToImageStoreFile(fileFullName, storeSource));
if (helper != null)
{
helper.ThrowIfExpired();
}
}
foreach (var directoryFullName in directoryFullNames)
{
if (content.Folders == null)
{
content.Folders = new List <ImageStoreFolder>();
}
content.Folders.Add(new ImageStoreFolder(
this.GetStoreRelativePathFromFullName(directoryFullName, storeSource),
this.GetFileCount(directoryFullName)));
if (helper != null)
{
helper.ThrowIfExpired();
}
}
return(content);
}
public void FabricFile_EndToEndPositive()
{
var folderPath = this.testPath;
folderPath = this.ExtendPath(folderPath);
var filePath = Path.Combine(folderPath, this.testFileName);
Assert.IsTrue(filePath.Length > 260);
LogHelper.Log("FabricDirectory.Create {0}", folderPath);
FabricDirectory.CreateDirectory(folderPath);
LogHelper.Log("FabricFile.Create {0}", filePath);
using (StreamWriter streamWriter = new StreamWriter(FabricFile.Create(filePath)))
{
LogHelper.Log("Write {0}", this.testString);
streamWriter.WriteLine(this.testString);
}
LogHelper.Log("FabricDirectory.GetDirectories {0}", this.testPath);
var result = FabricDirectory.GetDirectories(this.testPath);
Assert.AreEqual(1, result.Length);
LogHelper.Log("FabricDirectory.GetFiles {0}", this.testPath);
result = FabricDirectory.GetFiles(this.testPath);
Assert.AreEqual(0, result.Length);
LogHelper.Log("FabricDirectory.GetFiles {0}, AllDirectories", this.testPath);
result = FabricDirectory.GetFiles(this.testPath, "*", SearchOption.AllDirectories);
Assert.AreEqual(1, result.Length);
LogHelper.Log("FabricDirectory.GetDirectories {0}", folderPath);
result = FabricDirectory.GetDirectories(folderPath);
Assert.AreEqual(0, result.Length);
LogHelper.Log("FabricDirectory.GetFiles {0}", folderPath);
result = FabricDirectory.GetFiles(folderPath);
Assert.AreEqual(1, result.Length);
LogHelper.Log("FabricFile.Open {0}", filePath);
using (StreamReader streamReader = new StreamReader(FabricFile.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.None)))
{
string actual = streamReader.ReadLine();
LogHelper.Log("Read {0}", actual);
Assert.AreEqual(this.testString, actual);
}
LogHelper.Log("FabricFile.GetSize {0}", filePath);
long size = FabricFile.GetSize(filePath);
Assert.IsTrue(size > 0);
LogHelper.Log("FabricPath.GetDirectoryName {0}", filePath);
string directoryName = FabricPath.GetDirectoryName(filePath);
Assert.AreEqual(folderPath, directoryName);
LogHelper.Log("FabricFile.GetLastWriteTime {0}", filePath);
DateTime oldTime = FabricFile.GetLastWriteTime(filePath);
Thread.Sleep(TimeSpan.FromSeconds(1));
using (StreamWriter streamWriter = new StreamWriter(FabricFile.Open(filePath, FileMode.Open, FileAccess.Write)))
{
LogHelper.Log("Write {0}", this.testString);
streamWriter.WriteLine(this.testString);
}
DateTime newTime = FabricFile.GetLastWriteTime(filePath);
Assert.IsTrue(newTime > oldTime);
}
