/// <summary>
/// 根据文件大小创建文件。
/// 注意：多个用户同时上传相同文件时，可能会同时创建相同文件。
/// </summary>
public void make(string filePath, long len)
{
//文件不存在则创建
if (string.IsNullOrEmpty(filePath))
{
return;
}
if (!LongPathFile.Exists(filePath))
{
var pos = filePath.LastIndexOf('\\');
if (-1 == pos)
{
pos = filePath.LastIndexOf('/');
}
var dir = filePath.Substring(0, pos);
//自动创建目录
if (!LongPathDirectory.Exists(dir))
{
System.Diagnostics.Debug.WriteLine(string.Format("路径不存在：{0}", dir));
PathTool.createDirectory(dir);
}
else
{
System.Diagnostics.Debug.WriteLine(string.Format("路径存在：{0}", dir));
}
var fs = LongPathFile.Open(filePath, FileMode.Create, FileAccess.Write);
fs.SetLength(len);
fs.Close();
}
}
public override void Delete()
{
if (LongPathFile.Exists(Path))
{
LongPathFile.Delete(Path);
}
}
private void ThrowIfProjectPathDoesNotExist()
{
if (!LongPathFile.Exists(ProjectPath))
{
string message = string.Format(
CultureInfo.CurrentCulture,
LocalizedStrings.BuildComponentTool_InvalidProjectPath,
ProjectPath);
throw new CommandLineOperationException(message, showToolHelp: true);
}
}
public static bool Exists(string path)
{
if (path.Length < MAX_PATH)
{
return(System.IO.File.Exists(path));
}
else
{
return(LongPathFile.Exists(path));
}
}
///<summary>
/// Returns whether the specified file exists or not.
///</summary>
///<param name = "filePath">The file path.</param>
///<returns></returns>
public bool Exists(string filePath)
{
AssertAllowed(filePath);
#if !MONO
var mTx = CurrentTransaction();
if (mTx.HasValue)
{
return(((IFileAdapter)mTx.Value).Exists(filePath));
}
#endif
return(LongPathFile.Exists(filePath));
}
/// <summary>
/// Deletes a junction point at the specified source directory along with the directory itself.
/// Does nothing if the junction point does not exist.
/// </summary>
/// <remarks>
/// Only works on NTFS.
/// </remarks>
/// <param name = "junctionPoint">The junction point path</param>
public static void Delete(Path junctionPoint)
{
if (!LongPathDirectory.Exists(junctionPoint))
{
if (LongPathFile.Exists(junctionPoint))
{
throw new IOException("Path is not a junction point.");
}
return;
}
using (var handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite))
{
var reparseDataBuffer = new REPARSE_DATA_BUFFER();
reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
reparseDataBuffer.ReparseDataLength = 0;
reparseDataBuffer.PathBuffer = new byte[0x3ff0];
var inBufferSize = Marshal.SizeOf(reparseDataBuffer);
var inBuffer = Marshal.AllocHGlobal(inBufferSize);
try
{
Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false);
int bytesReturned;
var result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_DELETE_REPARSE_POINT,
inBuffer, 8, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero);
if (!result)
{
ThrowLastWin32Error("Unable to delete junction point.");
}
}
finally
{
Marshal.FreeHGlobal(inBuffer);
}
try
{
LongPathDirectory.Delete(junctionPoint);
}
catch (IOException ex)
{
throw new IOException("Unable to delete junction point.", ex);
}
}
}
protected override async Task <bool> DoWorkInternalAsync()
{
status = Status.Started;
await Task.Run(
() =>
{
if (this.TransferJob.Source.Type == TransferLocationType.AzureBlob &&
this.TransferJob.Destination.Type == TransferLocationType.FilePath)
{
// Dummy transfer for downloading dummy blobs.
var filePath = (this.TransferJob.Destination as FileLocation).FilePath.ToLongPath();
if (LongPathFile.Exists(filePath))
{
string exceptionMessage = string.Format(
CultureInfo.CurrentCulture,
Resources.FailedToCreateDirectoryException,
filePath);
throw new TransferException(
TransferErrorCode.FailedToCreateDirectory,
exceptionMessage);
}
else
{
LongPathDirectory.CreateDirectory(filePath);
}
}
// Hint: adding new dummy directions here.
else
{
string exceptionMessage = string.Format(
CultureInfo.CurrentCulture,
Resources.UnsupportedDummyTransferException);
throw new TransferException(
TransferErrorCode.UnsupportedDummyTransfer,
exceptionMessage);
}
status = Status.Finished;
}, this.CancellationToken);
return(status == Status.Finished || status == Status.ErrorOccured);
}
public static void Delete(string path)
{
if (path.Length < MAX_PATH)
{
if (File.Exists(path))
{
System.IO.File.Delete(path);
}
}
else
{
if (LongPathFile.Exists(path))
{
LongPathFile.Delete(path);
}
}
}
/// <summary>
/// Generates unique file name in the <paramref name="parentDirectory"/>.
/// </summary>
/// <param name="parentDirectory">Directory, where the file will be stored into.</param>
/// <param name="prefix">File prefix. May be <see langword="null"/>.</param>
/// <param name="extension">File extension. May be <see langword="null"/>.</param>
/// <returns>Path to the file.</returns>
/// <exception cref="ArgumentNullException"><paramref name="parentDirectory"/> is <see langword="null"/>.</exception>
/// <remarks>
/// The result file name will look like the following: <c><prefix><GUID>.<extension></c><br/>
/// For example:<br/>
/// <code>
/// PathHelper.GenerateUniqueFileName(@"C:\Temp\", "a_", "bin"); // C:\Temp\a_8F3C680522E0457896837ADF38ED8E6A.bin
/// PathHelper.GenerateUniqueFileName(@"C:\Temp\", "b_", ".txt"); // C:\Temp\b_BF3C086BE0C444B4906E4A36CBC16551.txt
/// </code>
/// </remarks>
public static string GenerateUniqueFileName(string parentDirectory, string prefix, string extension)
{
if (string.IsNullOrEmpty(parentDirectory))
{
throw new ArgumentNullException(nameof(parentDirectory));
}
prefix = string.IsNullOrWhiteSpace(prefix) ? string.Empty : prefix.Trim();
extension = extension?.Trim().TrimStart('.') ?? string.Empty;
extension = string.IsNullOrEmpty(extension) ? string.Empty : "." + extension;
string result;
do
{
result = Path.Combine(parentDirectory, prefix + Guid.NewGuid().ToString("N") + extension);
}while (LongPathFile.Exists(result));
return(result);
}
public void Run_PathIsVeryLong_DoesCopy()
{
//we're adding this guid because teh normal tempfolder code can't handle this super deap thing, can't clear it out for us
//as we re-run this test
var guid = Guid.NewGuid().ToString();
using (var from = new TemporaryFolder("synctest_source" + guid))
using (var to = new TemporaryFolder("synctest_dest" + guid))
{
string sub = from.Path;
for (int i = 0; i < 10; i++)
{
sub = sub + Path.DirectorySeparatorChar + "OnePartOfTheDirectory" + i;
Microsoft.Experimental.IO.LongPathDirectory.Create(sub);
}
var fileName = "1.txt";
using (var file = Microsoft.Experimental.IO.LongPathFile.Open(sub.CombineForPath(fileName), FileMode.CreateNew,
FileAccess.ReadWrite))
{
}
var source = new RawDirectoryGroup("Group1", from.Path, null, null);
var groups = new List <FileGroup>(new[] { source });
var progress = new ConsoleProgress()
{
ShowVerbose = true
};
var sync = new MirrorController(to.Path, groups, 100, progress);
sync.Run();
string path = sub.Replace("synctest_source" + guid, "synctest_dest" + guid + Path.DirectorySeparatorChar + "Group1").CombineForPath("1.txt");
Assert.That(LongPathFile.Exists(path), path);
}
}
private async Task HandleOutputStreamAsync()
{
this.hasWork = false;
await Task.Run(async() =>
{
// Only do calculation related to transfer window when the file contains multiple chunks.
if (!this.EnableOneChunkFileOptimization)
{
// We do check point consistancy validation in reader, and directly use it in writer.
if ((null != this.TransferJob.CheckPoint.TransferWindow) &&
this.TransferJob.CheckPoint.TransferWindow.Any())
{
this.TransferJob.CheckPoint.TransferWindow.Sort();
this.expectOffset = this.TransferJob.CheckPoint.TransferWindow[0];
}
else
{
this.expectOffset = this.TransferJob.CheckPoint.EntryTransferOffset;
}
}
if (TransferLocationType.Stream == this.TransferJob.Destination.Type)
{
Stream streamInDestination = (this.TransferJob.Destination as StreamLocation).Stream;
if (!streamInDestination.CanWrite)
{
throw new NotSupportedException(string.Format(
CultureInfo.CurrentCulture,
Resources.StreamMustSupportWriteException,
"outputStream"));
}
if (!streamInDestination.CanSeek)
{
throw new NotSupportedException(string.Format(
CultureInfo.CurrentCulture,
Resources.StreamMustSupportSeekException,
"outputStream"));
}
this.outputStream = streamInDestination;
}
else
{
string filePath = (this.TransferJob.Destination as FileLocation).FilePath;
if (!this.Controller.IsForceOverwrite)
{
await this.Controller.CheckOverwriteAsync(
LongPathFile.Exists(filePath),
this.TransferJob.Source.Instance,
filePath);
}
this.Controller.CheckCancellation();
try
{
FileMode fileMode = 0 == this.expectOffset ? FileMode.OpenOrCreate : FileMode.Open;
#if DOTNET5_4
string longFilePath = filePath;
if (Interop.CrossPlatformHelpers.IsWindows)
{
longFilePath = LongPath.ToUncPath(longFilePath);
}
// Attempt to open the file first so that we throw an exception before getting into the async work
this.outputStream = new FileStream(
longFilePath,
fileMode,
FileAccess.ReadWrite,
FileShare.None);
#else
this.outputStream = LongPathFile.Open(
filePath,
fileMode,
FileAccess.ReadWrite,
FileShare.None);
#endif
this.ownsStream = true;
}
catch (Exception ex)
{
string exceptionMessage = string.Format(
CultureInfo.CurrentCulture,
Resources.FailedToOpenFileException,
filePath,
ex.Message);
throw new TransferException(
TransferErrorCode.OpenFileFailed,
exceptionMessage,
ex);
}
}
this.outputStream.SetLength(this.SharedTransferData.TotalLength);
this.md5HashStream = new MD5HashStream(
this.outputStream,
this.expectOffset,
!this.SharedTransferData.DisableContentMD5Validation);
if (this.md5HashStream.FinishedSeparateMd5Calculator)
{
this.state = State.Write;
}
else
{
this.state = State.CalculateMD5;
}
this.PreProcessed = true;
// Switch state internal for one chunk small file.
if (this.EnableOneChunkFileOptimization &&
State.Write == this.state &&
((this.SharedTransferData.TotalLength == this.expectOffset) || this.SharedTransferData.AvailableData.ContainsKey(this.expectOffset)))
{
this.isStateSwitchedInternal = true;
await this.WriteChunkDataAsync().ConfigureAwait(false);
}
else
{
this.hasWork = true;
}
});
}
public override bool Exists()
{
return(LongPathFile.Exists(Path));
}
public override bool FileExists(string filePath)
{
return(LongPathFile.Exists(filePath));
}
