/// <summary>
/// Run the call.
/// </summary>
public static async Task <PlaceFileResult> RunAsync(
TTracer tracer,
OperationContext context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
Func <Task <PlaceFileResult> > funcAsync)
{
using (var call = new PlaceFileCall <TTracer>(tracer, context, contentHash, path, accessMode, replacementMode, realizationMode))
{
return(await call.RunSafeAsync(funcAsync));
}
}
public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
Context context,
IReadOnlyList <ContentHashWithPath> hashesWithPaths,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken cts,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
return(MultiLevelUtilities.RunManyLevelAsync(
GetSessionsInOrder <IReadOnlyContentSession>().ToArray(),
hashesWithPaths,
(session, hashes) => session.PlaceFileAsync(context, hashes, accessMode, replacementMode, realizationMode, cts, urgencyHint),
p => p.Succeeded));
}
protected override async Task <PlaceFileResult> PlaceFileCoreAsync(
OperationContext context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
UrgencyHint urgencyHint,
Counter retryCounter)
{
try
{
if (replacementMode != FileReplacementMode.ReplaceExisting && File.Exists(path.Path))
{
return(new PlaceFileResult(PlaceFileResult.ResultCode.NotPlacedAlreadyExists));
}
if (ImplicitPin.HasFlag(ImplicitPin.Get))
{
var pinResult = await PinAsync(context, contentHash, context.Token, urgencyHint).ConfigureAwait(false);
if (!pinResult.Succeeded)
{
return(pinResult.Code == PinResult.ResultCode.ContentNotFound
? new PlaceFileResult(PlaceFileResult.ResultCode.NotPlacedContentNotFound)
: new PlaceFileResult(pinResult));
}
}
var fileMode = replacementMode == FileReplacementMode.ReplaceExisting
? FileMode.Create
: FileMode.CreateNew;
var possibleLength =
await PlaceFileInternalAsync(context, contentHash, path.Path, fileMode).ConfigureAwait(false);
return(possibleLength.HasValue
? new PlaceFileResult(PlaceFileResult.ResultCode.PlacedWithCopy, possibleLength.Value)
: new PlaceFileResult(PlaceFileResult.ResultCode.NotPlacedContentNotFound));
}
catch (IOException e) when(IsErrorFileExists(e))
{
return(new PlaceFileResult(PlaceFileResult.ResultCode.NotPlacedAlreadyExists));
}
catch (Exception e)
{
return(new PlaceFileResult(e));
}
}
/// <inheritdoc />
public Task <PlaceFileResult> PlaceFileAsync(
Context context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken cts,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
return(PerformAggregateSessionOperationAsync <IReadOnlyContentSession, PlaceFileResult>(
session => session.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint),
(r1, r2) => r1.Succeeded ? r1 : r2,
shouldBreak: r => r.Succeeded,
pathHint: path));
}
public override void PlaceFileStart(
Context context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode)
{
if (_eventSource.IsEnabled())
{
_eventSource.PlaceFileStart(
context.TraceId, contentHash.ToString(), path.Path, (int)accessMode, (int)replacementMode, (int)realizationMode);
}
base.PlaceFileStart(context, contentHash, path, accessMode, replacementMode, realizationMode);
}
public Task <PlaceFileResult> PlaceFileAsync(
Context context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken cts,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
if (_session == null)
{
return(Task.FromResult(new PlaceFileResult(PlaceFileResult.ResultCode.NotPlacedContentNotFound, ErrorMsg)));
}
return(_session.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint));
}
/// <inheritdoc />
public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
Context context,
IReadOnlyList <ContentHashWithPath> hashesWithPaths,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken cts,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
return(Workflows.RunWithFallback(
hashesWithPaths,
inputHashesWithPaths =>
_sessionForPath.PlaceFileAsync(context, inputHashesWithPaths, accessMode, replacementMode, realizationMode, cts, urgencyHint),
inputHashesWithPaths =>
_sessionForStream.PlaceFileAsync(context, inputHashesWithPaths, accessMode, replacementMode, realizationMode, cts, urgencyHint),
result => result.Code != PlaceFileResult.ResultCode.NotPlacedContentNotFound));
}
/// <inheritdoc />
public async Task <PlaceFileResult> PlaceFileAsync(
Context context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode)
{
var sessionContext = await CreateSessionContextAsync(context);
if (!sessionContext)
{
return(new PlaceFileResult(sessionContext));
}
return(await PlaceFileAsync(sessionContext.Value, contentHash, path, accessMode, replacementMode, realizationMode));
}
/// <summary>
/// Initializes a new instance of the <see cref="PlaceFileCall{TTracer}"/> class.
/// </summary>
private PlaceFileCall(
TTracer tracer,
OperationContext context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode)
: base(tracer, context, contentHash)
{
_path = path;
_accessMode = accessMode;
_replacementMode = replacementMode;
_realizationMode = realizationMode;
Tracer.PlaceFileStart(Context, contentHash, path, accessMode, replacementMode, realizationMode);
}
private async Task <PlaceFileResult> PlaceFileAsync(
Context context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
int sessionId)
{
var startTime = DateTime.UtcNow;
PlaceFileResponse response = await RunClientActionAndThrowIfFailedAsync(context, async() => await _client.PlaceFileAsync(
new PlaceFileRequest
{
Header = new RequestHeader(context.Id, sessionId),
HashType = (int)contentHash.HashType,
ContentHash = contentHash.ToByteString(),
Path = path.Path,
FileAccessMode = (int)accessMode,
FileRealizationMode = (int)realizationMode,
FileReplacementMode = (int)replacementMode
}));
long ticksWaited = response.Header.ServerReceiptTimeUtcTicks - startTime.Ticks;
_tracer.TrackClientWaitForServerTicks(ticksWaited);
// Workaround: Handle the service returning negative result codes in error cases
PlaceFileResult.ResultCode resultCode = response.Header.Result < 0
? PlaceFileResult.ResultCode.Error
: (PlaceFileResult.ResultCode)response.Header.Result;
if (!response.Header.Succeeded)
{
await ResetOnUnknownSessionAsync(context, response.Header, sessionId);
var message = string.IsNullOrEmpty(response.Header.ErrorMessage)
? resultCode.ToString()
: response.Header.ErrorMessage;
return(new PlaceFileResult(resultCode, message, response.Header.Diagnostics));
}
else
{
return(new PlaceFileResult(resultCode, response.ContentSize));
}
}
/// <inheritdoc />
public async Task <PlaceFileResult> PlaceFileAsync(
Context context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode)
{
StructResult <int> sessionResult = await _sessionState.GetIdAsync();
if (!sessionResult.Succeeded)
{
return(new PlaceFileResult(sessionResult));
}
int sessionId = sessionResult.Data;
return(await PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, sessionId));
}
/// <inheritdoc />
public async Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
Context context,
IReadOnlyList <ContentHashWithPath> hashesWithPaths,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken token,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
// TODO: add support for PerformOperation with Task<IEnumerable<Task<Indexed<ResultBase>>>>
using (var cancellableContext = TrackShutdown(context, token))
{
using (_counters[ContentSessionBaseCounters.PlaceFileBulk].Start())
{
return(await PlaceFileCoreAsync(cancellableContext, hashesWithPaths, accessMode, replacementMode, realizationMode, urgencyHint, _counters[ContentSessionBaseCounters.PlaceFileBulkRetries]));
}
}
}
/// <inheritdoc />
public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
Context context,
IReadOnlyList <ContentHashWithPath> hashesWithPaths,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken token,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
return(WithOperationContext(
context,
token,
operationContext => operationContext.PerformNonResultOperationAsync(
Tracer,
() => PlaceFileCoreAsync(operationContext, hashesWithPaths, accessMode, replacementMode, realizationMode, urgencyHint, _counters[ContentSessionBaseCounters.PlaceFileBulkRetries]),
traceOperationStarted: false,
traceOperationFinished: false,
counter: _counters[ContentSessionBaseCounters.PlaceFileBulk])));
}
private Task <PlaceFileResult> PlaceFileAsync(
OperationContext operationContext,
SessionContext context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode)
{
return(PerformOperationAsync(
context,
_ => Client.PlaceFileAsync(
new PlaceFileRequest
{
Header = context.CreateHeader(),
HashType = (int)contentHash.HashType,
ContentHash = contentHash.ToByteString(),
Path = path.Path,
FileAccessMode = (int)accessMode,
FileRealizationMode = (int)realizationMode,
FileReplacementMode = (int)replacementMode
},
options: GetCallOptions(Configuration.PlaceDeadline, operationContext.Token)),
response =>
{
// Workaround: Handle the service returning negative result codes in error cases
PlaceFileResult.ResultCode resultCode = response.Header.Result < 0
? PlaceFileResult.ResultCode.Error
: (PlaceFileResult.ResultCode)response.Header.Result;
if (!response.Header.Succeeded)
{
var message = string.IsNullOrEmpty(response.Header.ErrorMessage)
? resultCode.ToString()
: response.Header.ErrorMessage;
return new PlaceFileResult(resultCode, message, response.Header.Diagnostics);
}
else
{
return new PlaceFileResult(resultCode, response.ContentSize);
}
}));
}
/// <inheritdoc />
public Task <PlaceFileResult> PlaceFileAsync(
Context context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken token,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
return(WithOperationContext(
context,
token,
operationContext => operationContext.PerformOperationAsync(
Tracer,
() => PlaceFileCoreAsync(operationContext, contentHash, path, accessMode, replacementMode, realizationMode, urgencyHint, _counters[ContentSessionBaseCounters.PlaceFileRetries]),
extraStartMessage: $"({contentHash.ToShortString()},{path},{accessMode},{replacementMode},{realizationMode})",
extraEndMessage: (_) => $"input={contentHash.ToShortString()}",
counter: _counters[ContentSessionBaseCounters.PlaceFile])));
}
public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(
Context context,
IReadOnlyList <ContentHashWithPath> hashesWithPaths,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken cts,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
// NOTE: this goes around the FileSystemContentStore's bulk place, rendering it useless. The reason
// we do it this way is so that the hardlink logic stays consistent. This means that multiple place
// operations from the same request may run at a higher rate than estipulated by the store.
IEnumerable <Task <Indexed <PlaceFileResult> > > materializations = hashesWithPaths.Select(async(hashWithPath, index) =>
{
var result = await PlaceFileAsync(context, hashWithPath.Hash, hashWithPath.Path, accessMode, replacementMode, realizationMode, cts, urgencyHint);
return(new Indexed <PlaceFileResult>(result, index));
});
return(Task.FromResult(materializations.ToList().AsEnumerable()));
}
/// <nodoc />
public static Task <PlaceFileResult> PlaceFileAsync <TTracer>(
this TTracer tracer,
OperationContext context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
Func <Task <PlaceFileResult> > func) where TTracer : ContentSessionTracer
{
return(PlaceFileCall <TTracer> .RunAsync(
tracer,
context,
contentHash,
path,
accessMode,
replacementMode,
realizationMode,
func));
}
/// <inheritdoc />
public Task <PlaceFileResult> PlaceFileAsync(
Context context,
ContentHash contentHash,
AbsolutePath path,
FileAccessMode accessMode,
FileReplacementMode replacementMode,
FileRealizationMode realizationMode,
CancellationToken cts,
UrgencyHint urgencyHint)
{
return(PlaceFileCall <ContentSessionTracer> .RunAsync(Tracer.ContentSessionTracer, new OperationContext(context), contentHash, path, accessMode, replacementMode, realizationMode, async() =>
{
if (WriteThroughContentSession != null)
{
var result = await WriteThroughContentSession.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint).ConfigureAwait(false);
if (result.Succeeded || result.Code != PlaceFileResult.ResultCode.NotPlacedContentNotFound)
{
return result;
}
}
return await BackingContentSession.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint);
}));
}
public override void PlaceFileStop(Context context, ContentHash contentHash, PlaceFileResult result, AbsolutePath path, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, Severity successSeverity)
{
if (_eventSource.IsEnabled())
{
_eventSource.PlaceFileStop(context.TraceId, (int)result.Code, result.ErrorMessage);
}
base.PlaceFileStop(context, contentHash, result, path, accessMode, replacementMode, realizationMode, successSeverity: DiagnosticLevelSeverity(result.Duration));
}
/// <inheritdoc /> public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(Context context, IReadOnlyList <ContentHashWithPath> hashesWithPaths, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal) => Task.FromResult(hashesWithPaths.Select((hash, i) => Task.FromResult(new PlaceFileResult(PlaceFileResult.ResultCode.NotPlacedContentNotFound).WithIndex(i))));
/// <inheritdoc />
protected override Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileCoreAsync(OperationContext operationContext, IReadOnlyList <ContentHashWithPath> hashesWithPaths, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, UrgencyHint urgencyHint, Counter retryCounter)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(Context context, IReadOnlyList <ContentHashWithPath> hashesWithPaths, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
// Also not implemented in BlobReadOnlyContentSession.
throw new NotImplementedException();
}
/// <inheritdoc />
public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(Context context, IReadOnlyList <ContentHashWithPath> hashesWithPaths, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
return(_innerCacheSession.PlaceFileAsync(context, hashesWithPaths, accessMode, replacementMode, realizationMode, cts, urgencyHint));
}
/// <inheritdoc />
public Task <PlaceFileResult> PlaceFileAsync(Context context, ContentHash contentHash, AbsolutePath path, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, CancellationToken cts, UrgencyHint urgencyHint)
{
return(_innerCacheSession.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint));
}
public virtual void PlaceFileStop(Context context, ContentHash contentHash, PlaceFileResult result, AbsolutePath path, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode)
{
if (context.IsEnabled)
{
TracerOperationFinished(context, result, $"{Name}.{PlaceFileCallName}({contentHash.ToShortString()},{path},{accessMode},{replacementMode},{realizationMode}) stop {result.DurationMs}ms result=[{result}]");
}
_placeFileCallCounter.Completed(result.Duration.Ticks);
}
/// <inheritdoc /> protected override Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileCoreAsync(OperationContext operationContext, IReadOnlyList <ContentHashWithPath> hashesWithPaths, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, UrgencyHint urgencyHint, Counter retryCounter) => Task.FromResult(hashesWithPaths.Select((hash, i) => Task.FromResult(new PlaceFileResult(PlaceFileResult.ResultCode.NotPlacedContentNotFound).WithIndex(i))));
/// <inheritdoc /> protected override Task <PlaceFileResult> PlaceFileCoreAsync(OperationContext operationContext, ContentHash contentHash, AbsolutePath path, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, UrgencyHint urgencyHint, Counter retryCounter) => Task.FromResult(new PlaceFileResult(PlaceFileResult.ResultCode.NotPlacedContentNotFound));
public Task <PlaceFileResult> PlaceFileAsync(Context context, ContentHash contentHash, AbsolutePath path, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal) => _local.PlaceFileAsync(context, contentHash, path, accessMode, replacementMode, realizationMode, cts, urgencyHint);
public Task <IEnumerable <Task <Indexed <PlaceFileResult> > > > PlaceFileAsync(Context context, IReadOnlyList <ContentHashWithPath> placeFileArgs, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, PinRequest?pinRequest = null)
{
throw new NotImplementedException();
}
public Task <PlaceFileResult> PlaceFileAsync(Context context, ContentHash contentHash, AbsolutePath destinationPath, FileAccessMode accessMode, FileReplacementMode replacementMode, FileRealizationMode realizationMode, PinRequest?pinRequest = null)
{
throw new NotImplementedException();
}
