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 deleteResults = await Task.WhenAll <DeleteResult>(_contentStoreByCacheName.Values.Select(store => store.DeleteAsync(cacheContext, contentHash)));
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
});
}
/// <inheritdoc />
public async Task <DeleteResult> DeleteContentAsync(Context context, ContentHash hash)
{
try
{
DeleteContentRequest request = new DeleteContentRequest()
{
TraceId = context.Id.ToString(),
HashType = (int)hash.HashType,
ContentHash = hash.ToByteString()
};
DeleteContentResponse response = await _client.DeleteAsync(request);
if (response.Header.Succeeded)
{
return(new DeleteResult((DeleteResult.ResultCode)response.Result, hash, response.EvictedSize, response.PinnedSize));
}
else
{
return(new DeleteResult((DeleteResult.ResultCode)response.Result, response.Header.ErrorMessage, response.Header.Diagnostics));
}
}
catch (RpcException r)
{
if (r.StatusCode == StatusCode.Unavailable)
{
return(new DeleteResult(DeleteResult.ResultCode.ServerError, r));
}
else
{
return(new DeleteResult(DeleteResult.ResultCode.Error, r));
}
}
}
/// <summary>
/// Delete a content file from the title
/// </summary>
public static void DeleteContent(DeleteContentRequest request, Action <BlankResult> resultCallback, Action <PlayFabError> errorCallback, object customData = null)
{
if (PlayFabSettings.DeveloperSecretKey == null)
{
throw new Exception("Must have PlayFabSettings.DeveloperSecretKey set to call this method");
}
PlayFabHttp.MakeApiCall("/Admin/DeleteContent", request, AuthType.DevSecretKey, resultCallback, errorCallback, customData);
}
/// <inheritdoc />
public async Task <DeleteResult> DeleteContentAsync(OperationContext context, ContentHash hash, bool deleteLocalOnly)
{
try
{
DeleteContentRequest request = new DeleteContentRequest()
{
TraceId = context.TracingContext.Id.ToString(),
HashType = (int)hash.HashType,
ContentHash = hash.ToByteString(),
DeleteLocalOnly = deleteLocalOnly
};
DeleteContentResponse response = await Client.DeleteAsync(request, options : GetCallOptions(Configuration.Deadline, context.Token));
if (!deleteLocalOnly)
{
var deleteResultsMapping = new Dictionary <string, DeleteResult>();
foreach (var kvp in response.DeleteResults)
{
var header = kvp.Value;
var deleteResult = string.IsNullOrEmpty(header.ErrorMessage)
? new DeleteResult(
(DeleteResult.ResultCode)header.Result,
hash,
response.ContentSize)
: new DeleteResult((DeleteResult.ResultCode)header.Result, header.ErrorMessage, header.Diagnostics);
deleteResultsMapping.Add(kvp.Key, deleteResult);
}
return(new DistributedDeleteResult(hash, response.ContentSize, deleteResultsMapping));
}
if (response.Header.Succeeded)
{
return(new DeleteResult((DeleteResult.ResultCode)response.Result, hash, response.ContentSize));
}
else
{
return(new DeleteResult((DeleteResult.ResultCode)response.Result, response.Header.ErrorMessage, response.Header.Diagnostics));
}
}
catch (RpcException r)
{
if (r.StatusCode == StatusCode.Unavailable)
{
return(new DeleteResult(DeleteResult.ResultCode.ServerError, r));
}
else
{
return(new DeleteResult(DeleteResult.ResultCode.Error, r));
}
}
}
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
));
}
async public void DeleteFile(string titleId, DownloadedFile fileInfo)
{
var currentPlayFabTitleId = PlayFabSettings.TitleId;
var currentDevKey = PlayFabSettings.DeveloperSecretKey;
var title = FindTitle(titleId);
PlayFabSettings.TitleId = titleId;
PlayFabSettings.DeveloperSecretKey = title.SecretKey;
var key = fileInfo.FilePath.Split('/').ToList()[fileInfo.FilePath.Split('/').ToList().Count - 1];
var type = MimeMapping.GetMimeMapping(key);
var file = new DeleteContentRequest();
var result = await PlayFabAdminAPI.DeleteContentAsync(file);
}
/// <inheritdoc /> public override Task <DeleteContentResponse> Delete(DeleteContentRequest request, ServerCallContext context) => _contentServer.DeleteAsync(request, context.CancellationToken);
