private async Task <DeleteContentResponse> DeleteAsync(DeleteContentRequest request, CancellationToken ct)
{
return(await RunFuncNoSessionAsync(
request.TraceId,
async context =>
{
var contentHash = request.ContentHash.ToContentHash((HashType)request.HashType);
var deleteOptions = new DeleteContentOptions()
{
DeleteLocalOnly = request.DeleteLocalOnly
};
var deleteResults = await Task.WhenAll <DeleteResult>(_contentStoreByCacheName.Values.Select(store => store.DeleteAsync(context.OperationContext, contentHash, deleteOptions)));
bool succeeded = true;
long contentSize = 0L;
int code = (int)DeleteResult.ResultCode.ContentNotFound;
var response = new DeleteContentResponse();
foreach (var deleteResult in deleteResults)
{
if (deleteOptions.DeleteLocalOnly)
{
succeeded &= deleteResult.Succeeded;
// Return the most severe result code
code = Math.Max(code, (int)deleteResult.Code);
}
else
{
if (deleteResult is DistributedDeleteResult distributedDeleteResult)
{
foreach (var kvp in distributedDeleteResult.DeleteMapping)
{
response.DeleteResults.Add(kvp.Key, new ResponseHeader(context.StartTime, kvp.Value.Succeeded, (int)kvp.Value.Code, kvp.Value.ErrorMessage, kvp.Value.Diagnostics));
}
}
}
contentSize = Math.Max(deleteResult.ContentSize, contentSize);
}
response.Header = succeeded ? ResponseHeader.Success(context.StartTime) : ResponseHeader.Failure(context.StartTime, string.Join(Environment.NewLine, deleteResults.Select(r => r.ToString())));
response.ContentSize = contentSize;
response.Result = code;
return response;
},
(context, errorMessage) => new DeleteContentResponse()
{
Header = ResponseHeader.Failure(context.StartTime, errorMessage)
},
token : ct
));
}
private async Task <DeleteContentResponse> DeleteAsync(DeleteContentRequest request, CancellationToken ct)
{
OperationStarted();
DateTime startTime = DateTime.UtcNow;
var cacheContext = new Context(new Guid(request.TraceId), Logger);
var contentHash = request.ContentHash.ToContentHash((HashType)request.HashType);
var deleteOptions = new DeleteContentOptions()
{
DeleteLocalOnly = request.DeleteLocalOnly
};
var deleteResults = await Task.WhenAll <DeleteResult>(_contentStoreByCacheName.Values.Select(store => store.DeleteAsync(cacheContext, contentHash, deleteOptions)));
bool succeeded = true;
long evictedSize = 0L;
long pinnedSize = 0L;
int code = (int)DeleteResult.ResultCode.ContentNotFound;
foreach (var deleteResult in deleteResults)
{
succeeded &= deleteResult.Succeeded;
evictedSize += deleteResult.EvictedSize;
pinnedSize += deleteResult.PinnedSize;
// Return the most severe result code
code = Math.Max(code, (int)deleteResult.Code);
}
return(new DeleteContentResponse
{
Header = succeeded ? ResponseHeader.Success(startTime) : ResponseHeader.Failure(startTime, string.Join(Environment.NewLine, deleteResults.Select(r => r.ToString()))),
EvictedSize = evictedSize,
PinnedSize = pinnedSize,
Result = code
});
}
public Task <DeleteResult> DeleteAsync(Context context, ContentHash contentHash, DeleteContentOptions deleteOptions)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public Task <DeleteResult> DeleteAsync(Context context, ContentHash contentHash, DeleteContentOptions deleteOptions)
{
if (_cache is IContentStore contentStore)
{
return(contentStore.DeleteAsync(context, contentHash, deleteOptions));
}
return(Task.FromResult(new DeleteResult(DeleteResult.ResultCode.Error, "Not implemented")));
}
/// <inheritdoc />
public Task <DeleteResult> DeleteAsync(Context context, ContentHash contentHash, DeleteContentOptions deleteOptions = null)
{
return(Store.DeleteAsync(context, contentHash, deleteOptions));
}
/// <inheritdoc />
public Task <DeleteResult> DeleteAsync(Context context, ContentHash contentHash, DeleteContentOptions deleteOptions = null)
{
return(Task.FromResult(new DeleteResult(DeleteResult.ResultCode.ContentNotDeleted, FailureMessage)));
}
/// <inheritdoc />
Task <DeleteResult> IContentStore.DeleteAsync(Context context, ContentHash contentHash, DeleteContentOptions deleteOptions) => Task.FromResult(new DeleteResult(DeleteResult.ResultCode.ContentNotDeleted, $"{nameof(ReadOnlyEmptyContentStore)} cannot contain any content to delete"));
/// <inheritdoc /> public Task <DeleteResult> DeleteAsync(Context context, ContentHash contentHash, DeleteContentOptions deleteOptions = null) => _innerStore.DeleteAsync(context, contentHash, deleteOptions);
/// <inheritdoc />
public Task <DeleteResult> DeleteAsync(Context context, ContentHash contentHash, DeleteContentOptions deleteOptions)
{
var operationContext = OperationContext(context);
deleteOptions ??= new DeleteContentOptions()
{
DeleteLocalOnly = true
};
return(operationContext.PerformOperationAsync(Tracer,
async() =>
{
var deleteResult = await InnerContentStore.DeleteAsync(context, contentHash, deleteOptions);
var contentHashes = new ContentHash[] { contentHash };
if (!deleteResult)
{
return deleteResult;
}
// Tell the event hub that this machine has removed the content locally
var unRegisterResult = await UnregisterAsync(context, contentHashes, operationContext.Token).ThrowIfFailure();
if (!unRegisterResult)
{
return new DeleteResult(unRegisterResult, unRegisterResult.ToString());
}
if (deleteOptions.DeleteLocalOnly)
{
return deleteResult;
}
var result = await _contentLocationStore.GetBulkAsync(context, contentHashes, operationContext.Token, UrgencyHint.Nominal, GetBulkOrigin.Local);
if (!result)
{
return new DeleteResult(result, result.ToString());
}
// Go through each machine that has this content, and delete async locally on each machine.
if (result.ContentHashesInfo.Count == 1 && result.ContentHashesInfo.ElementAt(0).Locations != null)
{
var machineLocations = result.ContentHashesInfo[0].Locations;
return await _distributedCopier.DeleteAsync(operationContext, contentHash, machineLocations);
}
return deleteResult;
}));
}
Task <DeleteResult> IDeleteFileHandler.HandleDeleteAsync(Context context, ContentHash contentHash, DeleteContentOptions deleteOptions) => DeleteAsync(context, contentHash, deleteOptions);
