internal async Task UploadAsync(
AgentTaskPluginExecutionContext context,
Fingerprint fingerprint,
string path,
CancellationToken cancellationToken)
{
VssConnection connection = context.VssConnection;
BlobStoreClientTelemetry clientTelemetry;
DedupManifestArtifactClient dedupManifestClient = DedupManifestArtifactClientFactory.CreateDedupManifestClient(context, connection, cancellationToken, out clientTelemetry);
PipelineCacheClient pipelineCacheClient = this.CreateClient(clientTelemetry, context, connection);
using (clientTelemetry)
{
// Check if the key exists.
PipelineCacheActionRecord cacheRecordGet = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, PipelineArtifactConstants.RestoreCache, context));
PipelineCacheArtifact getResult = await pipelineCacheClient.GetPipelineCacheArtifactAsync(new [] { fingerprint }, cancellationToken, cacheRecordGet);
// Send results to CustomerIntelligence
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: cacheRecordGet);
//If cache exists, return.
if (getResult != null)
{
context.Output($"Cache with fingerprint `{getResult.Fingerprint}` already exists.");
return;
}
//Upload the pipeline artifact.
PipelineCacheActionRecord uploadRecord = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, nameof(dedupManifestClient.PublishAsync), context));
PublishResult result = await clientTelemetry.MeasureActionAsync(
record : uploadRecord,
actionAsync : async() =>
{
return(await dedupManifestClient.PublishAsync(path, cancellationToken));
});
CreatePipelineCacheArtifactOptions options = new CreatePipelineCacheArtifactOptions
{
Fingerprint = fingerprint,
RootId = result.RootId,
ManifestId = result.ManifestId,
ProofNodes = result.ProofNodes.ToArray(),
};
// Cache the artifact
PipelineCacheActionRecord cacheRecord = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, PipelineArtifactConstants.SaveCache, context));
CreateStatus status = await pipelineCacheClient.CreatePipelineCacheArtifactAsync(options, cancellationToken, cacheRecord);
// Send results to CustomerIntelligence
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: uploadRecord);
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: cacheRecord);
context.Output("Saved item.");
}
}
public static string GetInfo(this CreateStatus status)
{
switch (status)
{
case CreateStatus.ReachCharLimit:
return("Too many characters");
case CreateStatus.OK:
return("OK");
}
throw new ArgumentException("status");
}
private static void HandleCreateResult(string resourceType, string key, CreateStatus status)
{
switch (status)
{
case CreateStatus.Created:
break;
case CreateStatus.AlreadyExists:
throw new CommandException(string.Format("The {0} \"{1}\" already exists", resourceType, key));
default:
throw new ApiException();
}
}
internal async Task UploadAsync(
AgentTaskPluginExecutionContext context,
IEnumerable <string> key,
string path,
string salt,
CancellationToken cancellationToken)
{
VssConnection connection = context.VssConnection;
BlobStoreClientTelemetry clientTelemetry;
DedupManifestArtifactClient dedupManifestClient = DedupManifestArtifactClientFactory.CreateDedupManifestClient(context, connection, out clientTelemetry);
PipelineCacheClient pipelineCacheClient = this.CreateClient(clientTelemetry, context, connection);
using (clientTelemetry)
{
//Upload the pipeline artifact.
PipelineCacheActionRecord uploadRecord = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, nameof(dedupManifestClient.PublishAsync), context));
PublishResult result = await clientTelemetry.MeasureActionAsync(
record : uploadRecord,
actionAsync : async() =>
{
return(await dedupManifestClient.PublishAsync(path, cancellationToken));
});
CreatePipelineCacheArtifactOptions options = new CreatePipelineCacheArtifactOptions
{
Key = key,
RootId = result.RootId,
ManifestId = result.ManifestId,
ProofNodes = result.ProofNodes.ToArray(),
Salt = salt
};
// Cache the artifact
PipelineCacheActionRecord cacheRecord = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, PipelineArtifactConstants.SaveCache, context));
CreateStatus status = await pipelineCacheClient.CreatePipelineCacheArtifactAsync(options, cancellationToken, cacheRecord);
// Send results to CustomerIntelligence
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: uploadRecord);
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: cacheRecord);
context.Output("Saved item.");
}
}
protected override void HandlePacket(Client client, CREATE packet)
{
int skin = client.Account.OwnedSkins.Contains(packet.SkinType) ? packet.SkinType : 0;
DbChar character;
CreateStatus status = client.Manager.Database.CreateCharacter(client.Manager.GameData, client.Account, (ushort)packet.ClassType, skin, out character);
if (status == CreateStatus.ReachCharLimit)
{
client.SendMessage(new FAILURE
{
ErrorDescription = "Failed to Load character."
});
client.Disconnect(DisconnectReason.FAILED_TO_LOAD_CHARACTER);
return;
}
client.Character = character;
World target = client.Manager.Worlds[client.TargetWorld];
target.Timers.Add(new WorldTimer(5000, (w, t) =>
{
if (status == CreateStatus.OK)
{
client.SendMessage(new CREATE_SUCCESS
{
CharacterID = client.Character.CharId,
ObjectID =
client.Manager.Worlds[client.TargetWorld].EnterWorld(
client.Player = new Player(client.Manager, client))
});
client.State = ProtocolState.Ready;
}
else
{
client.SendMessage(new FAILURE
{
ErrorDescription = "Failed to Load character."
});
}
}));
}
private void Handle(Client client, CREATE message)
{
int skin = client.Account.OwnedSkins.Contains(message.SkinType) ? message.SkinType : 0;
CreateStatus status = Manager.Database.CreateCharacter(Manager.GameData, client.Account, (ushort)message.ClassType, skin, out DbChar character);
if (status == CreateStatus.ReachCharLimit)
{
client.SendMessage(new FAILURE
{
ErrorDescription = "Failed to Load character."
});
Manager.TryDisconnect(client, DisconnectReason.FAILED_TO_LOAD_CHARACTER);
return;
}
client.Character = character;
if (status == CreateStatus.OK)
{
client.SendMessage(new CREATE_SUCCESS
{
CharacterID = client.Character.CharId,
ObjectID =
Manager.Worlds[client.TargetWorld].EnterWorld(
client.Player = new Player(client))
});
client.State = ProtocolState.Ready;
}
else
{
client.SendMessage(new FAILURE
{
ErrorDescription = "Failed to Load character."
});
}
}
private static void HandleCreateResult(string resourceType, string key, CreateStatus status)
{
switch (status)
{
case CreateStatus.Created:
break;
case CreateStatus.AlreadyExists:
throw new CommandException(string.Format("The {0} \"{1}\" already exists", resourceType, key));
default:
throw new ApiException();
}
}
public void ExplicitResponseMapperTest()
{
// Error.
ResponseError srcError = new ResponseError {
Code = 123, Description = "Err desc", Id = "42", Message = "Error occurred", Scope = "request"
};
errorType destError = MapperFactory.CreateInstance <ResponseError, errorType>(srcError);
// Create.
CreateStatus srcCreateStatus = new CreateStatus {
AdvisoryId = "src456", Error = srcError, Id = "cr8", StatusCode = "200"
};
createType destCreateStatus = MapperFactory.CreateInstance <CreateStatus, createType>(srcCreateStatus);
MultipleCreateResponse srcCreateResponse = new MultipleCreateResponse {
StatusRecords = new List <CreateStatus> {
srcCreateStatus
}
};
createResponseType destCreateResponse = MapperFactory.CreateInstance <MultipleCreateResponse, createResponseType>(srcCreateResponse);
int index = 0;
// Assert that the mapping was successful.
foreach (CreateStatus record in srcCreateResponse.StatusRecords)
{
Assert.AreEqual(record.AdvisoryId, destCreateResponse.creates[index].advisoryId);
Assert.AreEqual(record.Error.Code, destCreateResponse.creates[index].error.code);
Assert.AreEqual(record.Error.Description, destCreateResponse.creates[index].error.description);
Assert.AreEqual(record.Error.Id, destCreateResponse.creates[index].error.id);
Assert.AreEqual(record.Error.Message, destCreateResponse.creates[index].error.message);
Assert.AreEqual(record.Error.Scope, destCreateResponse.creates[index].error.scope);
Assert.AreEqual(record.Id, destCreateResponse.creates[index].id);
Assert.AreEqual(record.StatusCode, destCreateResponse.creates[index].statusCode);
index++;
}
// Delete.
DeleteStatus srcDeleteStatus = new DeleteStatus {
Error = srcError, Id = "del8", StatusCode = "300"
};
deleteStatus destDeleteStatus = MapperFactory.CreateInstance <DeleteStatus, deleteStatus>(srcDeleteStatus);
MultipleDeleteResponse srcDeleteResponse = new MultipleDeleteResponse {
StatusRecords = new List <DeleteStatus> {
srcDeleteStatus
}
};
deleteResponseType destDeleteResponse = MapperFactory.CreateInstance <MultipleDeleteResponse, deleteResponseType>(srcDeleteResponse);
index = 0;
// Assert that the mapping was successful.
foreach (DeleteStatus record in srcDeleteResponse.StatusRecords)
{
Assert.AreEqual(record.Error.Code, destDeleteResponse.deletes[index].error.code);
Assert.AreEqual(record.Error.Description, destDeleteResponse.deletes[index].error.description);
Assert.AreEqual(record.Error.Id, destDeleteResponse.deletes[index].error.id);
Assert.AreEqual(record.Error.Message, destDeleteResponse.deletes[index].error.message);
Assert.AreEqual(record.Error.Scope, destDeleteResponse.deletes[index].error.scope);
Assert.AreEqual(record.Id, destDeleteResponse.deletes[index].id);
Assert.AreEqual(record.StatusCode, destDeleteResponse.deletes[index].statusCode);
index++;
}
// Update.
UpdateStatus srcUpdateStatus = new UpdateStatus {
Error = srcError, Id = "up8", StatusCode = "400"
};
updateType destUpdateStatus = MapperFactory.CreateInstance <UpdateStatus, updateType>(srcUpdateStatus);
MultipleUpdateResponse srcUpdateResponse = new MultipleUpdateResponse {
StatusRecords = new List <UpdateStatus> {
srcUpdateStatus
}
};
updateResponseType destUpdateResponse = MapperFactory.CreateInstance <MultipleUpdateResponse, updateResponseType>(srcUpdateResponse);
index = 0;
// Assert that the mapping was successful.
foreach (UpdateStatus record in srcUpdateResponse.StatusRecords)
{
Assert.AreEqual(record.Error.Code, destUpdateResponse.updates[index].error.code);
Assert.AreEqual(record.Error.Description, destUpdateResponse.updates[index].error.description);
Assert.AreEqual(record.Error.Id, destUpdateResponse.updates[index].error.id);
Assert.AreEqual(record.Error.Message, destUpdateResponse.updates[index].error.message);
Assert.AreEqual(record.Error.Scope, destUpdateResponse.updates[index].error.scope);
Assert.AreEqual(record.Id, destUpdateResponse.updates[index].id);
Assert.AreEqual(record.StatusCode, destUpdateResponse.updates[index].statusCode);
index++;
}
}
internal async Task UploadAsync(
AgentTaskPluginExecutionContext context,
Fingerprint fingerprint,
string path,
CancellationToken cancellationToken,
ContentFormat contentFormat)
{
VssConnection connection = context.VssConnection;
var(dedupManifestClient, clientTelemetry) = await DedupManifestArtifactClientFactory.Instance
.CreateDedupManifestClientAsync(context.IsSystemDebugTrue(), (str) => context.Output(str), connection, cancellationToken);
PipelineCacheClient pipelineCacheClient = this.CreateClient(clientTelemetry, context, connection);
using (clientTelemetry)
{
// Check if the key exists.
PipelineCacheActionRecord cacheRecordGet = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, PipelineArtifactConstants.RestoreCache, context));
PipelineCacheArtifact getResult = await pipelineCacheClient.GetPipelineCacheArtifactAsync(new [] { fingerprint }, cancellationToken, cacheRecordGet);
// Send results to CustomerIntelligence
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: cacheRecordGet);
//If cache exists, return.
if (getResult != null)
{
context.Output($"Cache with fingerprint `{getResult.Fingerprint}` already exists.");
return;
}
string uploadPath = await this.GetUploadPathAsync(contentFormat, context, path, cancellationToken);
//Upload the pipeline artifact.
PipelineCacheActionRecord uploadRecord = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, nameof(dedupManifestClient.PublishAsync), context));
PublishResult result = await clientTelemetry.MeasureActionAsync(
record : uploadRecord,
actionAsync : async() =>
await AsyncHttpRetryHelper.InvokeAsync(
async() =>
{
return(await dedupManifestClient.PublishAsync(uploadPath, cancellationToken));
},
maxRetries: 3,
tracer: tracer,
canRetryDelegate: e => true, // this isn't great, but failing on upload stinks, so just try a couple of times
cancellationToken: cancellationToken,
continueOnCapturedContext: false)
);
CreatePipelineCacheArtifactContract options = new CreatePipelineCacheArtifactContract
{
Fingerprint = fingerprint,
RootId = result.RootId,
ManifestId = result.ManifestId,
ProofNodes = result.ProofNodes.ToArray(),
ContentFormat = contentFormat.ToString(),
};
// delete archive file if it's tar.
if (contentFormat == ContentFormat.SingleTar)
{
try
{
if (File.Exists(uploadPath))
{
File.Delete(uploadPath);
}
}
catch { }
}
// Cache the artifact
PipelineCacheActionRecord cacheRecord = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, PipelineArtifactConstants.SaveCache, context));
CreateStatus status = await pipelineCacheClient.CreatePipelineCacheArtifactAsync(options, cancellationToken, cacheRecord);
// Send results to CustomerIntelligence
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: uploadRecord);
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: cacheRecord);
context.Output("Saved item.");
}
}
internal async Task UploadAsync(
AgentTaskPluginExecutionContext context,
Fingerprint fingerprint,
string path,
CancellationToken cancellationToken,
string preferredContentFormat = ContentFormatConstants.Files)
{
VssConnection connection = context.VssConnection;
BlobStoreClientTelemetry clientTelemetry;
DedupManifestArtifactClient dedupManifestClient = DedupManifestArtifactClientFactory.CreateDedupManifestClient(context, connection, cancellationToken, out clientTelemetry);
PipelineCacheClient pipelineCacheClient = this.CreateClient(clientTelemetry, context, connection);
using (clientTelemetry)
{
// Check if the key exists.
PipelineCacheActionRecord cacheRecordGet = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, PipelineArtifactConstants.RestoreCache, context));
PipelineCacheArtifact getResult = await pipelineCacheClient.GetPipelineCacheArtifactAsync(new [] { fingerprint }, cancellationToken, cacheRecordGet);
// Send results to CustomerIntelligence
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: cacheRecordGet);
//If cache exists, return.
if (getResult != null)
{
context.Output($"Cache with fingerprint `{getResult.Fingerprint}` already exists.");
return;
}
string uploadPath = await this.GetUploadPathAsync(preferredContentFormat, context, path, cancellationToken);
//Upload the pipeline artifact.
PipelineCacheActionRecord uploadRecord = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, nameof(dedupManifestClient.PublishAsync), context));
PublishResult result = await clientTelemetry.MeasureActionAsync(
record : uploadRecord,
actionAsync : async() =>
{
return(await dedupManifestClient.PublishAsync(uploadPath, cancellationToken));
});
CreatePipelineCacheArtifactContract options = new CreatePipelineCacheArtifactContract
{
Fingerprint = fingerprint,
RootId = result.RootId,
ManifestId = result.ManifestId,
ProofNodes = result.ProofNodes.ToArray(),
ContentFormat = preferredContentFormat
};
// delete archive file if it's tar.
if (string.Equals(preferredContentFormat, ContentFormatConstants.SingleTar, StringComparison.OrdinalIgnoreCase))
{
try
{
if (File.Exists(uploadPath))
{
File.Delete(uploadPath);
}
}
catch { }
}
// Cache the artifact
PipelineCacheActionRecord cacheRecord = clientTelemetry.CreateRecord <PipelineCacheActionRecord>((level, uri, type) =>
new PipelineCacheActionRecord(level, uri, type, PipelineArtifactConstants.SaveCache, context));
CreateStatus status = await pipelineCacheClient.CreatePipelineCacheArtifactAsync(options, cancellationToken, cacheRecord);
// Send results to CustomerIntelligence
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: uploadRecord);
context.PublishTelemetry(area: PipelineArtifactConstants.AzurePipelinesAgent, feature: PipelineArtifactConstants.PipelineCache, record: cacheRecord);
context.Output("Saved item.");
}
}
private TestSuiteDefinition GetOrCreateSuiteDefinition(TestSuiteDefinition suite, out CreateStatus createStatus)
{
lock (_suiteLock)
{
TestSuiteDefinition result = null;
createStatus = CreateStatus.Existing;
if (!string.IsNullOrEmpty(suite.Uuid))
{
result = (TestSuiteDefinition)Repository.Retrieve(typeof(TestSuiteDefinition), suite.Uuid);
}
if (result == null && suite.Id > 0)
{
result = Repository.Retrieve <TestSuiteDefinition>(suite.Id);
}
if (result == null)
{
result = Repository.Query <TestSuiteDefinition>(Query.Where("Title") == suite.Title).FirstOrDefault();
if (result != null)
{
result = (TestSuiteDefinition)Repository.Retrieve(typeof(TestSuiteDefinition), result.Uuid);
}
}
if (result == null)
{
Meta.SetAuditFields(suite);
result = Repository.Create(suite);
createStatus = CreateStatus.Created;
}
return(result);
}
}
private TestDefinition GetOrCreateTestDefinition(string suiteTitle, string testTitle, out CreateStatus createStatus)
{
lock (_testLock)
{
createStatus = CreateStatus.Existing;
TestSuiteDefinition suite = Repository.Query <TestSuiteDefinition>(Query.Where("Title") == suiteTitle).FirstOrDefault();
if (suite == null)
{
suite = GetOrCreateSuiteDefinition(new TestSuiteDefinition {
Title = suiteTitle
});
}
TestDefinition result = Repository.Query <TestDefinition>(Query.Where("Title") == testTitle && Query.Where("SuiteDefinitionId") == suite.Id).FirstOrDefault();
if (result == null)
{
result = new TestDefinition()
{
Title = testTitle,
SuiteDefinitionId = suite.Id
};
Meta.SetAuditFields(result);
result = Repository.Create(result);
createStatus = CreateStatus.Created;
}
return(result);
}
}
private TestDefinition GetOrCreateTestDefinition(string suiteTitle, TestDefinition testDefinition, out CreateStatus createStatus)
{
lock (_testLock)
{
createStatus = CreateStatus.Existing;
TestSuiteDefinition suite = TestingRepository.Query <TestSuiteDefinition>(Query.Where(nameof(TestSuiteDefinition.Title)) == suiteTitle).FirstOrDefault();
if (suite == null)
{
suite = GetOrCreateSuiteDefinition(new TestSuiteDefinition {
Title = suiteTitle
});
}
string testTitle = testDefinition.Title;
TestDefinition result = TestingRepository.Query <TestDefinition>(
Query.Where(nameof(TestDefinition.Title)) == testTitle &&
Query.Where(nameof(TestDefinition.TestSuiteDefinitionId)) == suite.Id).FirstOrDefault();
if (result == null)
{
result = testDefinition;
result.TestSuiteDefinitionId = suite.Id;
Meta.SetAuditFields(result);
result = TestingRepository.Create(result);
createStatus = CreateStatus.Created;
}
return(result);
}
}
