/// <summary>
/// Register Node by NodeId
/// </summary>
/// <param name="context">context</param>
/// <param name="request">request</param>
/// <returns>response</returns>
public async Task <RouteRegistrationResponse> Register(IWorkContext context, RouteRegistrationRequest request)
{
request.Verify(nameof(request)).IsNotNull();
request.NodeId.Verify(nameof(request.NodeId)).IsNotNull();
Uri uri = new ResourcePathBuilder()
.SetScheme(ResourceScheme.Queue)
.SetServiceBusName("Default")
.SetEntityName(request.NodeId !)
.Build();
INodeRegistrationActor registgrationActor = await _actorManager.CreateProxy <INodeRegistrationActor>(request.NodeId !);
await registgrationActor.Set(context, request.ConvertTo(uri));
QueueDefinition queueDefinition = new QueueDefinition
{
QueueName = request.NodeId,
};
IQueueManagementActor queueActor = await _actorManager.CreateProxy <IQueueManagementActor>(request.NodeId !);
await queueActor.Set(context, queueDefinition);
return(new RouteRegistrationResponse
{
InputQueueUri = uri.ToString(),
});
}
public CreateQueueState(IQueueManagement queueManagement, QueueDefinition queueDefinition)
{
queueManagement.Verify(nameof(queueManagement)).IsNotNull();
queueDefinition.Verify(nameof(queueDefinition)).IsNotNull();
queueDefinition.QueueName.Verify(nameof(queueDefinition.QueueName)).IsNotNull();
_queueDefinition = queueDefinition;
_managementClient = queueManagement;
}
public async Task <QueueDefinition> CreateQueue(IWorkContext context, QueueDefinition queueDefinition)
{
context.Verify(nameof(context)).IsNotNull();
queueDefinition.Verify(nameof(queueDefinition)).IsNotNull();
QueueDescription createdDescription = await _managementClient.CreateQueueAsync(queueDefinition.ConvertTo(), context.CancellationToken);
return(createdDescription.ConvertTo());
}
public QueueRegistration(string serviceHubNamespace, string nodeId, QueueDefinition queueDefinition)
{
serviceHubNamespace.Verify(nameof(serviceHubNamespace)).IsNotEmpty();
nodeId.Verify(nameof(nodeId)).IsNotEmpty();
queueDefinition.Verify(nameof(queueDefinition)).IsNotNull();
ServiceHubNamespace = serviceHubNamespace;
NodeId = nodeId;
QueueDefinition = queueDefinition;
}
public async Task Set(IWorkContext context, QueueDefinition queueDefinition)
{
context.Telemetry.Verbose(context, $"Set queue {ActorKey.VectorKey}");
bool state = await new StateManagerBuilder()
.Add(new CreateQueueState(_queueManagement, queueDefinition))
.Build()
.Set(context);
if (!state)
{
context.Telemetry.Error(context, $"Failed to create/set queue {ActorKey.VectorKey}");
throw new InvalidOperationException($"Failed to create queue {queueDefinition.QueueName}");
}
_cache.Set(queueDefinition);
}
public static QueueDescription ConvertTo(this QueueDefinition subject)
{
subject.Verify(nameof(subject)).IsNotNull();
subject.QueueName !.Verify(nameof(subject.QueueName)).IsNotEmpty();
return(new QueueDescription(subject.QueueName)
{
LockDuration = subject.LockDuration,
RequiresDuplicateDetection = subject.RequiresDuplicateDetection,
DuplicateDetectionHistoryTimeWindow = subject.DuplicateDetectionHistoryTimeWindow,
RequiresSession = subject.RequiresSession,
DefaultMessageTimeToLive = subject.DefaultMessageTimeToLive,
AutoDeleteOnIdle = subject.AutoDeleteOnIdle,
EnableDeadLetteringOnMessageExpiration = subject.EnableDeadLetteringOnMessageExpiration,
MaxDeliveryCount = subject.MaxDeliveryCount,
EnablePartitioning = subject.EnablePartitioning,
});
}
public async Task <QueueDefinition?> Get(IWorkContext context)
{
if (_cache.TryGetValue(out QueueDefinition model))
{
return(model);
}
bool exist = await _queueManagement.QueueExists(context, ActorKey.VectorKey);
if (!exist)
{
return(null);
}
QueueDefinition subject = await _queueManagement.GetQueue(context, ActorKey.VectorKey);
_cache.Set(subject);
return(subject);
}
