private async Task <int> UpdateGroupConnectionsFromServerAsync(string groupId, bool ignoreCache, CancellationToken cancellationToken)
{
return(await _groupServerSemaphore.LockAsync(
async() => {
if (!ignoreCache)
{
var serverId = TryGetCachedGroupServerId(groupId, Configuration.CacheExpiration);
if (serverId.HasValue)
{
return serverId.Value;
}
}
Log.Info(() => LogEvent.Create($"Router refreshing servers for group {groupId}"));
var request = new GroupCoordinatorRequest(groupId);
try {
var response = await this.SendToAnyAsync(request, cancellationToken).ConfigureAwait(false);
if (response != null)
{
await UpdateConnectionCacheAsync(new [] { response }, cancellationToken);
}
UpdateGroupServerCache(request, response);
// ReSharper disable once PossibleNullReferenceException
return response.Id;
} catch (Exception ex) {
throw new RoutingException($"Unable to refresh servers for group {groupId}", ex);
}
}, cancellationToken).ConfigureAwait(false));
}
public async Task OffsetCommitShouldStoreAndReturnSuccess()
{
const int partitionId = 0;
var router = new BrokerRouter(_options);
await router.GetTopicMetadataAsync(TestConfig.TopicName(), CancellationToken.None);
var conn = router.GetBrokerRoute(TestConfig.TopicName(), partitionId);
// ensure the group exists
var group = new GroupCoordinatorRequest(TestConfig.ConsumerName());
var groupResponse = await conn.Connection.SendAsync(group, CancellationToken.None);
Assert.That(groupResponse, Is.Not.Null);
Assert.That(groupResponse.ErrorCode, Is.EqualTo(ErrorResponseCode.None));
var commit = new OffsetCommitRequest(group.GroupId, new [] { new OffsetCommitRequest.Topic(TestConfig.TopicName(), partitionId, 10, null) });
var response = await conn.Connection.SendAsync(commit, CancellationToken.None);
var topic = response.Topics.FirstOrDefault();
Assert.That(topic, Is.Not.Null);
Assert.That(topic.ErrorCode, Is.EqualTo(ErrorResponseCode.None));
router.Dispose();
}
public async Task OffsetCommitShouldStoreOffsetValue()
{
const int partitionId = 0;
const long offset = 99;
using (var router = await TestConfig.IntegrationOptions.CreateRouterAsync()) {
await router.TemporaryTopicAsync(async topicName => {
await router.GetTopicMetadataAsync(topicName, CancellationToken.None);
var conn = router.GetTopicConnection(topicName, partitionId);
// ensure the group exists
var groupId = TestConfig.GroupId();
var group = new GroupCoordinatorRequest(groupId);
var groupResponse = await conn.Connection.SendAsync(group, CancellationToken.None);
Assert.That(groupResponse, Is.Not.Null);
Assert.That(groupResponse.error_code, Is.EqualTo(ErrorCode.NONE));
var commit = new OffsetCommitRequest(group.group_id, new [] { new OffsetCommitRequest.Topic(topicName, partitionId, offset, null) });
var commitResponse = await conn.Connection.SendAsync(commit, CancellationToken.None);
var commitTopic = commitResponse.responses.SingleOrDefault();
Assert.That(commitTopic, Is.Not.Null);
Assert.That(commitTopic.error_code, Is.EqualTo(ErrorCode.NONE));
var fetch = new OffsetFetchRequest(groupId, new TopicPartition(topicName, partitionId));
var fetchResponse = await conn.Connection.SendAsync(fetch, CancellationToken.None);
var fetchTopic = fetchResponse.responses.SingleOrDefault();
Assert.That(fetchTopic, Is.Not.Null);
Assert.That(fetchTopic.error_code, Is.EqualTo(ErrorCode.NONE));
Assert.That(fetchTopic.offset, Is.EqualTo(offset));
});
}
}
public async Task OffsetCommitShouldStoreAndReturnSuccess()
{
const int partitionId = 0;
using (var router = await TestConfig.IntegrationOptions.CreateRouterAsync()) {
await router.TemporaryTopicAsync(async topicName => {
await router.GetTopicMetadataAsync(topicName, CancellationToken.None);
var conn = router.GetTopicConnection(topicName, partitionId);
// ensure the group exists
var groupId = TestConfig.GroupId();
var group = new GroupCoordinatorRequest(groupId);
var groupResponse = await conn.Connection.SendAsync(group, CancellationToken.None);
Assert.That(groupResponse, Is.Not.Null);
Assert.That(groupResponse.error_code, Is.EqualTo(ErrorCode.NONE));
var commit = new OffsetCommitRequest(group.group_id, new [] { new OffsetCommitRequest.Topic(topicName, partitionId, 10, null) });
var response = await conn.Connection.SendAsync(commit, CancellationToken.None);
var topic = response.responses.FirstOrDefault();
Assert.That(topic, Is.Not.Null);
Assert.That(topic.error_code, Is.EqualTo(ErrorCode.NONE));
});
}
}
public Broker GroupCoordinator(String groupId)
{
var request = new GroupCoordinatorRequest(groupId);
var brokerUri = _client.ExistingBrokerDispatcher.SequentialSelect();
var response = (GroupCoordinatorResponse)_client.SubmitRequest(brokerUri, request);
response.TryThrowFirstErrorOccured();
return(new Broker(response.CoordinatorId, response.CoordinatorHost, response.CoordinatorPort));
}
private void UpdateGroupServerCache(GroupCoordinatorRequest request, GroupCoordinatorResponse response)
{
if (request == null || response == null)
{
return;
}
_groupServerCache = _groupServerCache.SetItem(request.group_id, new Tuple <int, DateTimeOffset>(response.Id, DateTimeOffset.UtcNow));
Log.Verbose(() => LogEvent.Create($"Router set serverId to {response.Id} for group {request.group_id}"));
}
public async Task ConsumerMetadataRequestShouldReturnWithoutError()
{
using (var router = new BrokerRouter(_options))
{
var conn = await router.GetBrokerRouteAsync(TestConfig.TopicName(), 0, CancellationToken.None);
var request = new GroupCoordinatorRequest(TestConfig.ConsumerName());
var response = await conn.Connection.SendAsync(request, CancellationToken.None);
Assert.That(response, Is.Not.Null);
Assert.That(response.ErrorCode, Is.EqualTo(ErrorResponseCode.None));
}
}
public async Task ConsumerMetadataRequestShouldReturnWithoutError()
{
using (var router = await TestConfig.IntegrationOptions.CreateRouterAsync()) {
await router.TemporaryTopicAsync(async topicName => {
var conn = await router.GetTopicConnectionAsync(topicName, 0, CancellationToken.None);
var groupId = TestConfig.GroupId();
var request = new GroupCoordinatorRequest(groupId);
var response = await conn.Connection.SendAsync(request, CancellationToken.None);
Assert.That(response, Is.Not.Null);
Assert.That(response.error_code, Is.EqualTo(ErrorCode.NONE));
});
}
}
public void GroupCoordinatorRequest()
{
var request = new GroupCoordinatorRequest();
request.GroupId = Guid.NewGuid().ToString();
Stream binary1 = new MemoryStream();
request.Serialize(binary1);
binary1.Seek(0L, SeekOrigin.Begin);
var request2 = new GroupCoordinatorRequest();
request2.Deserialize(binary1);
var compareLogic = new CompareLogic();
var result = compareLogic.Compare(request, request2);
Assert.True(result.AreEqual);
Stream binary2 = new MemoryStream();
request.Serialize(binary2);
Assert.Equal(binary1.Length, binary2.Length);
using (var stream1 = new MemoryStream())
using (var stream2 = new MemoryStream()) {
binary1.Seek(0L, SeekOrigin.Begin);
binary1.CopyTo(stream1);
binary2.Seek(0L, SeekOrigin.Begin);
binary2.CopyTo(stream2);
Assert.Equal(stream1.Length, stream2.Length);
stream1.Seek(0L, SeekOrigin.Begin);
var bytes1 = stream1.ToArray();
stream2.Seek(0L, SeekOrigin.Begin);
var bytes2 = stream2.ToArray();
Assert.Equal(bytes1.Length, bytes2.Length);
for (int i = 0; i < bytes1.Length; i++)
{
Assert.Equal(bytes1[i], bytes2[i]);
}
}
}
public async Task OffsetCommitShouldStoreOffsetValue()
{
const int partitionId = 0;
const long offset = 99;
var router = new BrokerRouter(_options);
await router.GetTopicMetadataAsync(TestConfig.TopicName(), CancellationToken.None);
var conn = router.GetBrokerRoute(TestConfig.TopicName(), partitionId);
// ensure the group exists
var group = new GroupCoordinatorRequest(TestConfig.ConsumerName());
var groupResponse = await conn.Connection.SendAsync(group, CancellationToken.None);
Assert.That(groupResponse, Is.Not.Null);
Assert.That(groupResponse.ErrorCode, Is.EqualTo(ErrorResponseCode.None));
var commit = new OffsetCommitRequest(group.GroupId, new [] { new OffsetCommitRequest.Topic(TestConfig.TopicName(), partitionId, offset, null) });
var commitResponse = await conn.Connection.SendAsync(commit, CancellationToken.None);
var commitTopic = commitResponse.Topics.SingleOrDefault();
Assert.That(commitTopic, Is.Not.Null);
Assert.That(commitTopic.ErrorCode, Is.EqualTo(ErrorResponseCode.None));
var fetch = new OffsetFetchRequest(TestConfig.ConsumerName(), new TopicPartition(TestConfig.TopicName(), partitionId));
var fetchResponse = await conn.Connection.SendAsync(fetch, CancellationToken.None);
var fetchTopic = fetchResponse.Topics.SingleOrDefault();
Assert.That(fetchTopic, Is.Not.Null);
Assert.That(fetchTopic.ErrorCode, Is.EqualTo(ErrorResponseCode.None));
Assert.That(fetchTopic.Offset, Is.EqualTo(offset));
router.Dispose();
}
public void GroupCoordinatorRequest([Values("group1", "group2")] string groupId)
{
var request = new GroupCoordinatorRequest(groupId);
request.AssertCanEncodeDecodeRequest(0);
}
