public async Task ShouldBackoffRequestOnMultipleFailures(ErrorResponseCode errorCode) { var conn = Substitute.For<IKafkaConnection>(); conn.SendAsync(Arg.Any<IKafkaRequest<MetadataResponse>>()) .Returns(x => CreateMetadataResponse(errorCode), x => CreateMetadataResponse(errorCode), x => CreateMetadataResponse(errorCode), x => CreateMetadataResponse(ErrorResponseCode.NoError)); using (var provider = new KafkaMetadataProvider(_log)) { var response = await provider.Get(new[] { conn }, new[] { "Test" }); } Received.InOrder(() => { conn.SendAsync(Arg.Any<IKafkaRequest<MetadataResponse>>()).Wait(); _log.WarnFormat("Backing off metadata request retry. Waiting for {0}ms.", 100); conn.SendAsync(Arg.Any<IKafkaRequest<MetadataResponse>>()).Wait(); _log.WarnFormat("Backing off metadata request retry. Waiting for {0}ms.", 400); conn.SendAsync(Arg.Any<IKafkaRequest<MetadataResponse>>()).Wait(); _log.WarnFormat("Backing off metadata request retry. Waiting for {0}ms.", 900); conn.SendAsync(Arg.Any<IKafkaRequest<MetadataResponse>>()).Wait(); }); }
public async Task ShouldTryToRefreshMataDataIfCanRecoverByRefreshMetadata(ErrorResponseCode code) { var routerProxy = new BrokerRouterProxy(_kernel); routerProxy._cacheExpiration = new TimeSpan(10); var router = routerProxy.Create(); int partitionId = 0; ProtocolGateway protocolGateway = new ProtocolGateway(router); var fetchRequest = new FetchRequest(); bool sendExOnFirstTime = true; Func<Task<FetchResponse>> ShouldReturnErrorAndThenNoError = async () => { Task.Delay(routerProxy._cacheExpiration).Wait(); Task.Delay(1).Wait(); if (sendExOnFirstTime) { sendExOnFirstTime = false; return new FetchResponse() { Error = (short)code }; } return new FetchResponse() { Error = (short)ErrorResponseCode.NoError }; }; routerProxy.BrokerConn0.FetchResponseFunction = ShouldReturnErrorAndThenNoError; routerProxy.BrokerConn0.MetadataResponseFunction = BrokerRouterProxy.DefaultMetadataResponse; await protocolGateway.SendProtocolRequest(fetchRequest, BrokerRouterProxy.TestTopic, partitionId); Assert.That(routerProxy.BrokerConn0.MetadataRequestCallCount, Is.EqualTo(2)); Assert.That(routerProxy.BrokerConn0.FetchRequestCallCount, Is.EqualTo(2)); }
private Partition(ErrorResponseCode errorCode, int partitionId, int leaderId, int[] replicas, int[] isrs) { this.ErrorCode = errorCode; this.PartitionId = partitionId; this.LeaderId = leaderId; this.Replicas = replicas; this.Isrs = isrs; }
public static bool IsFromStaleMetadata(this ErrorResponseCode code) { return(code == ErrorResponseCode.UnknownTopicOrPartition || code == ErrorResponseCode.LeaderNotAvailable || code == ErrorResponseCode.NotLeaderForPartition || code == ErrorResponseCode.GroupLoadInProgress || code == ErrorResponseCode.GroupCoordinatorNotAvailable || code == ErrorResponseCode.NotCoordinatorForGroup); }
public Partition(int partitionId, int leaderId, ErrorResponseCode errorCode = ErrorResponseCode.None, IEnumerable <int> replicas = null, IEnumerable <int> isrs = null) { ErrorCode = errorCode; PartitionId = partitionId; LeaderId = leaderId; Replicas = ImmutableList <int> .Empty.AddNotNullRange(replicas); Isrs = ImmutableList <int> .Empty.AddNotNullRange(isrs); }
public Group(ErrorResponseCode errorCode, string groupId, string state, string protocolType, string protocol, IEnumerable <Member> members) { ErrorCode = errorCode; GroupId = groupId; State = state; ProtocolType = protocolType; Protocol = protocol; Members = ImmutableList <Member> .Empty.AddNotNullRange(members); }
public void LeaveGroupResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.OffsetMetadataTooLarge )] ErrorResponseCode errorCode) { var response = new LeaveGroupResponse(errorCode); response.AssertCanEncodeDecodeResponse(0); }
public JoinGroupResponse(ErrorResponseCode errorCode, int generationId, string groupProtocol, string leaderId, string memberId, IEnumerable <Member> members) { ErrorCode = errorCode; Errors = ImmutableList <ErrorResponseCode> .Empty.Add(ErrorCode); GenerationId = generationId; GroupProtocol = groupProtocol; LeaderId = leaderId; MemberId = memberId; Members = ImmutableList <Member> .Empty.AddNotNullRange(members); }
public async Task ShouldThrowExceptionWhenNotARetriableErrorCode(ErrorResponseCode errorCode) { var conn = Substitute.For <IKafkaConnection>(); conn.SendAsync(Arg.Any <IKafkaRequest <MetadataResponse> >()).Returns(x => CreateMetadataResponse(errorCode)); using (var provider = new KafkaMetadataProvider(_log)) { var response = await provider.Get(new[] { conn }, new[] { "Test" }); } }
public async Task ShouldThrowExceptionWhenNotARetriableErrorCode(ErrorResponseCode errorCode) { var conn = Substitute.For <IConnection>(); conn.SendAsync(Arg.Any <IRequest <MetadataResponse> >(), Arg.Any <CancellationToken>()).Returns(x => CreateMetadataResponse(errorCode)); _brokerRouter.Connections.ReturnsForAnyArgs(new List <IConnection> { conn }); Assert.ThrowsAsync <RequestException>(() => _brokerRouter.GetMetadataAsync(new [] { "Test" }, CancellationToken.None)); }
public async Task SendProtocolRequestShouldNotTryToRefreshMataDataIfCanNotRecoverByRefreshMetadata( ErrorResponseCode code) { var routerProxy = new BrokerRouterProxy(); routerProxy.CacheExpiration = TimeSpan.FromMilliseconds(10); var router = routerProxy.Create(); routerProxy.Connection1.FetchResponseFunction = FailedInFirstMessageError(code, routerProxy.CacheExpiration); routerProxy.Connection1.MetadataResponseFunction = BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers; Assert.ThrowsAsync <RequestException>(async() => await router.SendAsync(new FetchRequest(), BrokerRouterProxy.TestTopic, PartitionId, CancellationToken.None)); }
public void SaslHandshakeResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.OffsetMetadataTooLarge )] ErrorResponseCode errorCode, [Range(1, 11)] int count) { var mechanisms = new[] { "EXTERNAL", "ANONYMOUS", "PLAIN", "OTP", "SKEY", "CRAM-MD5", "DIGEST-MD5", "SCRAM", "NTLM", "GSSAPI", "OAUTHBEARER" }; var response = new SaslHandshakeResponse(errorCode, mechanisms.Take(count)); response.AssertCanEncodeDecodeResponse(0); }
public void SyncGroupResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.OffsetMetadataTooLarge )] ErrorResponseCode errorCode) { var bytes = new byte[1000]; _randomizer.NextBytes(bytes); var response = new SyncGroupResponse(errorCode, new ByteMember(bytes)); response.AssertCanEncodeDecodeResponse(0); }
public async Task SendProtocolRequestShouldNoTryToRefreshMataDataIfCanNotRecoverByRefreshMetadata( ErrorResponseCode code) { var routerProxy = new BrokerRouterProxy(_kernel); routerProxy._cacheExpiration = TimeSpan.FromMilliseconds(10); var router = routerProxy.Create(); ProtocolGateway protocolGateway = new ProtocolGateway(router); routerProxy.BrokerConn0.FetchResponseFunction = FailedInFirstMessageError(code, routerProxy._cacheExpiration); routerProxy.BrokerConn0.MetadataResponseFunction = BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers; await protocolGateway.SendProtocolRequest(new FetchRequest(), BrokerRouterProxy.TestTopic, _partitionId); }
public void GroupCoordinatorResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.GroupCoordinatorNotAvailable, ErrorResponseCode.GroupAuthorizationFailed )] ErrorResponseCode errorCode, [Values(0, 1)] int coordinatorId ) { var response = new GroupCoordinatorResponse(errorCode, coordinatorId, "broker-" + coordinatorId, 9092 + coordinatorId); response.AssertCanEncodeDecodeResponse(0); }
/// <summary> /// See http://kafka.apache.org/protocol.html#protocol_error_codes for details /// </summary> public static bool IsRetryable(this ErrorResponseCode code) { return(code == ErrorResponseCode.CorruptMessage || code == ErrorResponseCode.UnknownTopicOrPartition || code == ErrorResponseCode.LeaderNotAvailable || code == ErrorResponseCode.NotLeaderForPartition || code == ErrorResponseCode.RequestTimedOut || code == ErrorResponseCode.NetworkException || code == ErrorResponseCode.GroupLoadInProgress || code == ErrorResponseCode.GroupCoordinatorNotAvailable || code == ErrorResponseCode.NotCoordinatorForGroup || code == ErrorResponseCode.NotEnoughReplicas || code == ErrorResponseCode.NotEnoughReplicasAfterAppend || code == ErrorResponseCode.NotController); }
public async Task ShouldTryToRefreshMataDataIfCanRecoverByRefreshMetadata(ErrorResponseCode code) { var routerProxy = new BrokerRouterProxy(); routerProxy.CacheExpiration = new TimeSpan(10); var router = routerProxy.Create(); routerProxy.Connection1.FetchResponseFunction = FailedInFirstMessageError(code, routerProxy.CacheExpiration); routerProxy.Connection1.MetadataResponseFunction = BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers; await router.SendAsync(new FetchRequest(), BrokerRouterProxy.TestTopic, PartitionId, CancellationToken.None); Assert.That(routerProxy.Connection1.MetadataRequestCallCount, Is.EqualTo(2)); Assert.That(routerProxy.Connection1.FetchRequestCallCount, Is.EqualTo(2)); }
public async Task ShouldTryToRefreshMataDataIfCanRecoverByRefreshMetadata(ErrorResponseCode code) { var routerProxy = new BrokerRouterProxy(_kernel); routerProxy._cacheExpiration = new TimeSpan(10); var router = routerProxy.Create(); ProtocolGateway protocolGateway = new ProtocolGateway(router); routerProxy.BrokerConn0.FetchResponseFunction = FailedInFirstMessageError(code, routerProxy._cacheExpiration); routerProxy.BrokerConn0.MetadataResponseFunction = BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers; await protocolGateway.SendProtocolRequest(new FetchRequest(), BrokerRouterProxy.TestTopic, _partitionId); Assert.That(routerProxy.BrokerConn0.MetadataRequestCallCount, Is.EqualTo(2)); Assert.That(routerProxy.BrokerConn0.FetchRequestCallCount, Is.EqualTo(2)); }
public async Task ShouldTryToRefreshMataDataIfCanRecoverByRefreshMetadata(ErrorResponseCode code) { var routerProxy = new BrokerRouterProxy(_kernel); routerProxy._cacheExpiration = new TimeSpan(10); var router = routerProxy.Create(); ProtocolGateway protocolGateway = new ProtocolGateway(router); routerProxy.BrokerConn0.FetchResponseFunction = FailedInFirstMessageError(code, routerProxy._cacheExpiration); routerProxy.BrokerConn0.MetadataResponseFunction = BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers; await protocolGateway.SendProtocolRequest(new FetchRequest(), BrokerRouterProxy.TestTopic, _partitionId); Assert.That(routerProxy.BrokerConn0.MetadataRequestCallCount, Is.EqualTo(2)); Assert.That(routerProxy.BrokerConn0.FetchRequestCallCount, Is.EqualTo(2)); }
public void ApiVersionsResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.BrokerNotAvailable )] ErrorResponseCode errorCode ) { var supported = new List <ApiVersionsResponse.VersionSupport>(); for (short apiKey = 0; apiKey <= 18; apiKey++) { supported.Add(new ApiVersionsResponse.VersionSupport((ApiKeyRequestType)apiKey, 0, (short)_randomizer.Next(0, 2))); } var response = new ApiVersionsResponse(errorCode, supported); response.AssertCanEncodeDecodeResponse(0); }
public void DeleteTopicsResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.NotController )] ErrorResponseCode errorCode, [Values("test", "anotherNameForATopic")] string topicName, [Range(1, 11)] int count) { var topics = new TopicsResponse.Topic[count]; for (var t = 0; t < count; t++) { topics[t] = new TopicsResponse.Topic(topicName + t, errorCode); } var response = new DeleteTopicsResponse(topics); response.AssertCanEncodeDecodeResponse(0); }
private static Func <Task <FetchResponse> > FailedInFirstMessageError(ErrorResponseCode errorResponseCode, TimeSpan delay) { bool firstTime = true; Func <Task <FetchResponse> > result = async() => { if (firstTime) { await Task.Delay(delay); await Task.Delay(1); firstTime = false; return(new FetchResponse(new [] { new FetchResponse.Topic("foo", 1, 0, errorResponseCode) })); } return(new FetchResponse()); }; return(result); }
private async Task <List <MetadataResponse> > CreateMetadataResponse(ErrorResponseCode errorCode) { return(new List <MetadataResponse> { new MetadataResponse { Brokers = new List <Broker>(), Topics = new List <Topic> { new Topic { ErrorCode = (short)errorCode, Name = "Test", Partitions = new List <Partition>() } } } }); }
public async Task ShouldRetryWhenReceiveAnRetryErrorCode(ErrorResponseCode errorCode) { var conn = Substitute.For <IKafkaConnection>(); conn.SendAsync(Arg.Any <IKafkaRequest <MetadataResponse> >()) .Returns(x => CreateMetadataResponse(errorCode), x => CreateMetadataResponse(errorCode)); using (var provider = new KafkaMetadataProvider(_log)) { var response = await provider.Get(new[] { conn }, new[] { "Test" }); } Received.InOrder(() => { conn.SendAsync(Arg.Any <IKafkaRequest <MetadataResponse> >()); _log.WarnFormat("Backing off metadata request retry. Waiting for {0}ms.", 100); conn.SendAsync(Arg.Any <IKafkaRequest <MetadataResponse> >()); }); }
public void ListGroupsResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.OffsetMetadataTooLarge )] ErrorResponseCode errorCode, [Values("test", "a groupId")] string groupId, [Range(2, 3)] int count, [Values("consumer")] string protocolType) { var groups = new ListGroupsResponse.Group[count]; for (var g = 0; g < count; g++) { groups[g] = new ListGroupsResponse.Group(groupId + g, protocolType); } var response = new ListGroupsResponse(errorCode, groups); response.AssertCanEncodeDecodeResponse(0); }
public void SyncConsumerGroupResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.OffsetMetadataTooLarge )] ErrorResponseCode errorCode, [Values(1, 10)] int memberCount) { var encoder = new ConsumerEncoder(); var topics = new List <TopicPartition>(); for (var t = 0; t < memberCount; t++) { topics.Add(new TopicPartition("topic foo" + t, t)); } var assignment = new ConsumerMemberAssignment(0, topics); var response = new SyncGroupResponse(errorCode, assignment); response.AssertCanEncodeDecodeResponse(0, encoder); }
public void MetadataResponse( [Values(0, 1, 2)] short version, [Values(1, 15)] int brokersPerRequest, [Values("test", "a really long name, with spaces and punctuation!")] string topicName, [Values(1, 10)] int topicsPerRequest, [Values(1, 5)] int partitionsPerTopic, [Values( ErrorResponseCode.None, ErrorResponseCode.UnknownTopicOrPartition )] ErrorResponseCode errorCode) { var brokers = new List <Broker>(); for (var b = 0; b < brokersPerRequest; b++) { string rack = null; if (version >= 1) { rack = "Rack" + b; } brokers.Add(new Broker(b, "broker-" + b, 9092 + b, rack)); } var topics = new List <MetadataResponse.Topic>(); for (var t = 0; t < topicsPerRequest; t++) { var partitions = new List <MetadataResponse.Partition>(); for (var partitionId = 0; partitionId < partitionsPerTopic; partitionId++) { var leader = _randomizer.Next(0, brokersPerRequest - 1); var replica = 0; var replicas = _randomizer.Next(0, brokersPerRequest - 1).Repeat(() => replica++); var isr = 0; var isrs = _randomizer.Next(0, replica).Repeat(() => isr++); partitions.Add(new MetadataResponse.Partition(partitionId, leader, errorCode, replicas, isrs)); } topics.Add(new MetadataResponse.Topic(topicName + t, errorCode, partitions, version >= 1 ? topicsPerRequest % 2 == 0 : (bool?)null)); } var response = new MetadataResponse(brokers, topics, version >= 1 ? brokersPerRequest : (int?)null, version >= 2 ? $"cluster-{version}" : null); response.AssertCanEncodeDecodeResponse(version); }
private Task <List <MetadataResponse> > CreateMetadataResponse(ErrorResponseCode errorCode) { var tcs = new TaskCompletionSource <List <MetadataResponse> >(); tcs.SetResult(new List <MetadataResponse> { new MetadataResponse { Brokers = new List <Broker>(), Topics = new List <Topic> { new Topic { ErrorCode = (short)errorCode, Name = "Test", Partitions = new List <Partition>() } } } }); return(tcs.Task); }
public void DescribeConsumerGroupsResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.OffsetMetadataTooLarge )] ErrorResponseCode errorCode, [Values("test", "a groupId")] string groupId, [Range(2, 3)] int count, [Values(KafkaClient.Protocol.DescribeGroupsResponse.Group.States.Stable, KafkaClient.Protocol.DescribeGroupsResponse.Group.States.AwaitingSync)] string state, [Values("consumer")] string protocolType, [Values("good", "bad", "ugly")] string protocol) { var encoder = new ConsumerEncoder(); var groups = new DescribeGroupsResponse.Group[count]; for (var g = 0; g < count; g++) { var members = new List <DescribeGroupsResponse.Member>(); for (var m = 0; m < count; m++) { var memberId = "member" + m; var userData = new byte[count * 100]; _randomizer.NextBytes(userData); var metadata = new ConsumerProtocolMetadata(0, new [] { protocol, memberId, memberId }, userData); var topics = new List <TopicPartition>(); for (var t = 0; t < count; t++) { topics.Add(new TopicPartition("topic foo" + t, t)); } var assignment = new ConsumerMemberAssignment(0, topics); members.Add(new DescribeGroupsResponse.Member(memberId, "client" + m, "host-" + m, metadata, assignment)); } groups[g] = new DescribeGroupsResponse.Group(errorCode, groupId + g, state, protocolType, protocol, members); } var response = new DescribeGroupsResponse(groups); response.AssertCanEncodeDecodeResponse(0, encoder); }
public void ProduceResponse( [Values(0, 1, 2)] short version, [Values(-1, 0, 10000000)] long timestampMilliseconds, [Values("test", "a really long name, with spaces and punctuation!")] string topicName, [Values(1, 10)] int topicsPerRequest, [Values(1, 5)] int totalPartitions, [Values( ErrorResponseCode.None, ErrorResponseCode.CorruptMessage )] ErrorResponseCode errorCode, [Values(0, 100000)] int throttleTime) { var topics = new List <ProduceResponse.Topic>(); for (var t = 0; t < topicsPerRequest; t++) { topics.Add(new ProduceResponse.Topic(topicName + t, t % totalPartitions, errorCode, _randomizer.Next(), version >= 2 ? timestampMilliseconds.FromUnixEpochMilliseconds() : (DateTime?)null)); } var response = new ProduceResponse(topics, version >= 1 ? TimeSpan.FromMilliseconds(throttleTime) : (TimeSpan?)null); response.AssertCanEncodeDecodeResponse(version); }
public override void DealWithParserError(string p_Error) { // TODO: 如果 enum parse 失敗,會丟出Exception ErrorResponseCode parserError = (ErrorResponseCode)Enum.Parse(typeof(ErrorResponseCode), p_Error); char[] errorResopnse = new char[1 + 1]; switch (parserError) { case ErrorResponseCode.CRCError: errorResopnse[0] = (char)ReplyCommand.ErrorResponse; errorResopnse[1] = (char)ErrorResponseCode.CRCError; m_Interface.ReplyMessage(new string(errorResopnse)); break; case ErrorResponseCode.UnknowCommandError: errorResopnse[0] = (char)ReplyCommand.ErrorResponse; errorResopnse[1] = (char)ErrorResponseCode.UnknowCommandError; m_Interface.ReplyMessage(new string(errorResopnse)); break; } }
public void OffsetCommitResponse( [Values("test", "a really long name, with spaces and punctuation!")] string topicName, [Values(1, 10)] int topicsPerRequest, [Values(1, 5)] int partitionsPerTopic, [Values( ErrorResponseCode.None, ErrorResponseCode.OffsetMetadataTooLarge )] ErrorResponseCode errorCode) { var topics = new List <TopicResponse>(); for (var t = 0; t < topicsPerRequest; t++) { for (var partitionId = 0; partitionId < partitionsPerTopic; partitionId++) { topics.Add(new TopicResponse(topicName + t, partitionId, errorCode)); } } var response = new OffsetCommitResponse(topics); response.AssertCanEncodeDecodeResponse(0); }
public void JoinGroupResponse( [Values( ErrorResponseCode.None, ErrorResponseCode.OffsetMetadataTooLarge )] ErrorResponseCode errorCode, [Values(0, 1, 20000)] int generationId, [Values("consumer", "other")] string protocol, [Values("test", "a groupId")] string leaderId, [Values("", "an existing member")] string memberId, [Values(1, 10)] int memberCount) { var members = new List <JoinGroupResponse.Member>(); for (var m = 0; m < memberCount; m++) { var bytes = new byte[memberCount * 100]; _randomizer.NextBytes(bytes); members.Add(new JoinGroupResponse.Member(memberId + m, new ByteMember(bytes))); } var response = new JoinGroupResponse(errorCode, generationId, protocol, leaderId, memberId, members); response.AssertCanEncodeDecodeResponse(0); }
public async Task ShouldThrowExceptionWhenNotARetriableErrorCode(ErrorResponseCode errorCode) { var conn = Substitute.For<IKafkaConnection>(); conn.SendAsync(Arg.Any<IKafkaRequest<MetadataResponse>>()).Returns(x => CreateMetadataResponse(errorCode)); using (var provider = new KafkaMetadataProvider(_log)) { var response = await provider.Get(new[] { conn }, new[] { "Test" }); } }
private async Task<List<MetadataResponse>> CreateMetadataResponse(ErrorResponseCode errorCode) { return new List<MetadataResponse> { new MetadataResponse { Brokers = new List<Broker>(), Topics = new List<Topic> { new Topic { ErrorCode = (short) errorCode, Name = "Test", Partitions = new List<Partition>() } } } }; }
public Topic(string topic, int partitionId, long highWaterMark, ErrorResponseCode errorCode = ErrorResponseCode.None, IEnumerable <Message> messages = null) : base(topic, partitionId, errorCode) { HighWaterMark = highWaterMark; Messages = ImmutableList <Message> .Empty.AddNotNullRange(messages); }
public InvalidTopicMetadataException(SerializationInfo info, StreamingContext context) : base(info, context) { ErrorResponseCode = (ErrorResponseCode)info.GetInt16("ErrorResponseCode"); }
private Task<List<MetadataResponse>> CreateMetadataResponse(ErrorResponseCode errorCode) { var tcs = new TaskCompletionSource<List<MetadataResponse>>(); tcs.SetResult(new List<MetadataResponse>{ new MetadataResponse { Brokers = new List<Broker>(), Topics = new List<Topic> { new Topic { ErrorCode = (short) errorCode, Name = "Test", Partitions = new List<Partition>() } } }}); return tcs.Task; }
private Topic(ErrorResponseCode errorCode, string name, Partition[] partitions) { this.ErrorCode = errorCode; this.Name = name; this.Partitions = partitions; }
public async Task SendProtocolRequestShouldNoTryToRefreshMataDataIfCanNotRecoverByRefreshMetadata(ErrorResponseCode code) { var routerProxy = new BrokerRouterProxy(_kernel); routerProxy._cacheExpiration = TimeSpan.FromMilliseconds(10); var router = routerProxy.Create(); int partitionId = 0; ProtocolGateway protocolGateway = new ProtocolGateway(router); var fetchRequest = new FetchRequest(); bool firstTime = true; Func<Task<FetchResponse>> ShouldReturnError = async () => { if (firstTime) { firstTime = !firstTime; return new FetchResponse() { Error = (short)code }; } return new FetchResponse() { Error = (short)ErrorResponseCode.NoError }; }; routerProxy.BrokerConn0.FetchResponseFunction = ShouldReturnError; routerProxy.BrokerConn0.MetadataResponseFunction = BrokerRouterProxy.DefaultMetadataResponse; await protocolGateway.SendProtocolRequest(fetchRequest, BrokerRouterProxy.TestTopic, partitionId); }
public async Task SendProtocolRequestShouldNoTryToRefreshMataDataIfCanNotRecoverByRefreshMetadata( ErrorResponseCode code) { var routerProxy = new BrokerRouterProxy(_kernel); routerProxy._cacheExpiration = TimeSpan.FromMilliseconds(10); var router = routerProxy.Create(); ProtocolGateway protocolGateway = new ProtocolGateway(router); routerProxy.BrokerConn0.FetchResponseFunction = FailedInFirstMessageError(code, routerProxy._cacheExpiration); routerProxy.BrokerConn0.MetadataResponseFunction = BrokerRouterProxy.CreateMetadataResponseWithMultipleBrokers; await protocolGateway.SendProtocolRequest(new FetchRequest(), BrokerRouterProxy.TestTopic, _partitionId); }
private static Func<Task<FetchResponse>> FailedInFirstMessageError(ErrorResponseCode errorResponseCode, TimeSpan delay) { bool firstTime = true; Func<Task<FetchResponse>> result = async () => { if (firstTime) { await Task.Delay(delay); await Task.Delay(1); firstTime = false; return new FetchResponse() { Error = (short)errorResponseCode }; } return new FetchResponse() { Error = (short)ErrorResponseCode.NoError }; }; return result; }
public InvalidTopicMetadataException(ErrorResponseCode code, string message, params object[] args) : base(string.Format(message, args)) { ErrorResponseCode = code; }