public async Task InvokeTest()
{
var descriptor = new ConsumerExecutorDescriptor()
{
Attribute = new CandidatesTopic("fake.output.withcancellation"),
ServiceTypeInfo = typeof(FakeSubscriberWithCancellation).GetTypeInfo(),
ImplTypeInfo = typeof(FakeSubscriberWithCancellation).GetTypeInfo(),
MethodInfo = typeof(FakeSubscriberWithCancellation)
.GetMethod(nameof(FakeSubscriberWithCancellation.CancellationTokenInjected)),
Parameters = new List <ParameterDescriptor>
{
new ParameterDescriptor {
ParameterType = typeof(CancellationToken),
IsFromCap = true,
Name = "cancellationToken"
}
}
};
var header = new Dictionary <string, string>();
var message = new Message(header, null);
var context = new ConsumerContext(descriptor, message);
var cancellationToken = new CancellationToken();
var ret = await SubscribeInvoker.InvokeAsync(context, cancellationToken);
Assert.Equal(cancellationToken, ret.Result);
}
public async Task Send(ConsumerContext <TKey, TValue> context, IPipe <ConsumerContext <TKey, TValue> > next)
{
var inputAddress = _context.InputAddress;
IKafkaMessageReceiver <TKey, TValue> receiver = new KafkaMessageReceiver <TKey, TValue>(_context, context);
await receiver.Ready.ConfigureAwait(false);
_context.AddConsumeAgent(receiver);
await _context.TransportObservers.Ready(new ReceiveTransportReadyEvent(inputAddress)).ConfigureAwait(false);
try
{
await receiver.Completed.ConfigureAwait(false);
}
finally
{
DeliveryMetrics metrics = receiver;
await _context.TransportObservers.Completed(new ReceiveTransportCompletedEvent(inputAddress, metrics));
LogContext.Debug?.Log("Consumer completed {InputAddress}: {DeliveryCount} received, {ConcurrentDeliveryCount} concurrent", inputAddress,
metrics.DeliveryCount, metrics.ConcurrentDeliveryCount);
}
await next.Send(context).ConfigureAwait(false);
}
public async Task ExecuteAsync()
{
var groupedCandidates = _selector.GetCandidatesMethodsOfGroupNameGrouped(_serviceProvider);
using (var scope = _serviceProvider.CreateScope())
{
var provider = scope.ServiceProvider;
var messageStore = provider.GetService <ICapMessageStore>();
var nextReceivedMessage = await messageStore.GetNextReceivedMessageToBeExcuted();
if (nextReceivedMessage != null && groupedCandidates.ContainsKey(nextReceivedMessage.Group))
{
try
{
await messageStore.ChangeReceivedMessageStateAsync(nextReceivedMessage, StatusName.Processing);
// If there are multiple consumers in the same group, we will take the first
var executeDescriptor = groupedCandidates[nextReceivedMessage.Group][0];
var consumerContext = new ConsumerContext(executeDescriptor, nextReceivedMessage.ToMessageContext());
var invoker = _consumerInvokerFactory.CreateInvoker(consumerContext);
await invoker.InvokeAsync();
await messageStore.ChangeReceivedMessageStateAsync(nextReceivedMessage, StatusName.Succeeded);
}
catch (Exception ex)
{
_logger.ReceivedMessageRetryExecutingFailed(nextReceivedMessage.KeyName, ex);
}
}
}
}
public ConsumersRepository(ConsumerContext context)
{
_context = context;
if (_context.Consumers.Count() == 0)
{
_context.Consumers.AddRange(
new Consumer
{
Name = "Opie",
Location = "Shih Tzu",
ConsumerType = ConsumerType.Agent
},
new Consumer
{
Name = "Reggie",
Location = "Beagle",
ConsumerType = ConsumerType.Agent
},
new Consumer
{
Name = "Diesel",
Location = "Bombay",
ConsumerType = ConsumerType.User
},
new Consumer
{
Name = "Lucy",
Location = "Maine Coon",
ConsumerType = ConsumerType.User
});
_context.SaveChanges();
}
}
/// <summary>
/// 获取实例
/// </summary>
/// <param name="provider">服务提供程序</param>
/// <param name="context">订阅上下文</param>
protected override object GetInstance(IServiceProvider provider, ConsumerContext context)
{
var capHeader = new CapHeader(context.DeliverMessage.Headers);
InitTraceIdContext(capHeader);
return(base.GetInstance(provider, context));
}
private void ProcessMessage(IServiceScope serviceScope, CapReceivedMessage receivedMessage)
{
var provider = serviceScope.ServiceProvider;
var messageStore = provider.GetRequiredService <ICapMessageStore>();
try
{
var executeDescriptorGroup = _selector.GetTopicExector(receivedMessage.KeyName);
if (executeDescriptorGroup.ContainsKey(receivedMessage.Group))
{
messageStore.ChangeReceivedMessageStateAsync(receivedMessage, StatusName.Processing).Wait();
// If there are multiple consumers in the same group, we will take the first
var executeDescriptor = executeDescriptorGroup[receivedMessage.Group][0];
var consumerContext = new ConsumerContext(executeDescriptor, receivedMessage.ToMessageContext());
_consumerInvokerFactory.CreateInvoker(consumerContext).InvokeAsync();
messageStore.ChangeReceivedMessageStateAsync(receivedMessage, StatusName.Succeeded).Wait();
}
}
catch (Exception ex)
{
_logger.ConsumerMethodExecutingFailed($"Group:{receivedMessage.Group}, Topic:{receivedMessage.KeyName}", ex);
}
}
protected override void DoEnd ()
{
base.DoEnd ();
context.Close();
context = null;
}
private async Task InvokeConsumerMethodAsync(CapReceivedMessage receivedMessage)
{
if (!_selector.TryGetTopicExector(receivedMessage.Name, receivedMessage.Group,
out var executor))
{
var error = $"message can not be found subscriber, Message:{receivedMessage},\r\n see: https://github.com/dotnetcore/CAP/issues/63";
throw new SubscriberNotFoundException(error);
}
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
var operationId = Guid.Empty;
var consumerContext = new ConsumerContext(executor, receivedMessage.ToMessageContext());
try
{
operationId = s_diagnosticListener.WriteSubscriberInvokeBefore(consumerContext);
var ret = await Invoker.InvokeAsync(consumerContext);
s_diagnosticListener.WriteSubscriberInvokeAfter(operationId, consumerContext, startTime, stopwatch.Elapsed);
if (!string.IsNullOrEmpty(ret.CallbackName))
{
await _callbackMessageSender.SendAsync(ret.MessageId, ret.CallbackName, ret.Result);
}
}
catch (Exception ex)
{
s_diagnosticListener.WriteSubscriberInvokeError(operationId, consumerContext, ex, startTime, stopwatch.Elapsed);
throw new SubscriberExecutionFailedException(ex.Message, ex);
}
}
protected virtual async Task <OperateResult> ExecuteSubscribeAsync(CapReceivedMessage receivedMessage)
{
try
{
var executeDescriptorGroup = _selector.GetTopicExector(receivedMessage.Name);
if (!executeDescriptorGroup.ContainsKey(receivedMessage.Group))
{
throw new SubscriberNotFoundException(receivedMessage.Name + " has not been found.");
}
// If there are multiple consumers in the same group, we will take the first
var executeDescriptor = executeDescriptorGroup[receivedMessage.Group][0];
var consumerContext = new ConsumerContext(executeDescriptor, receivedMessage.ToMessageContext());
await _consumerInvokerFactory.CreateInvoker(consumerContext).InvokeAsync();
return(OperateResult.Success);
}
catch (SubscriberNotFoundException ex)
{
_logger.LogError("Can not be found subscribe method of name: " + receivedMessage.Name);
return(OperateResult.Failed(ex));
}
catch (Exception ex)
{
_logger.ConsumerMethodExecutingFailed($"Group:{receivedMessage.Group}, Topic:{receivedMessage.Name}", ex);
return(OperateResult.Failed(ex));
}
}
public static void PartitionsRevoked(ILogger logger,
IReadOnlyList <TopicPartitionOffset> partitions,
IConsumerDispatcher consumerDispatcher,
Func <ConsumerContext, IEnumerable <TopicPartition>, Task> partitionsRevokedHandler,
ConsumerContext context)
{
if (!partitions.Any())
{
return;
}
AsyncHelpers.RunSync(async() =>
{
var partitionsByTopic = partitions
.GroupBy(p => p.Topic)
.Select(g => new { Topic = g.Key, Partitions = g.Select(p => p.Partition.Value) })
.ToList();
logger.Info("Revocation: {@partitions}", partitionsByTopic);
if (partitionsRevokedHandler != null)
{
await partitionsRevokedHandler(context, partitions.Select(p => p.TopicPartition));
}
foreach (var revocation in partitionsByTopic)
{
await consumerDispatcher.Revoke(revocation.Topic, revocation.Partitions);
}
});
}
public void MessageTimestamp_ConsumeResultHasMessageTimestamp_ReturnsMessageTimestampFromResult()
{
// Arrange
var expectedMessageTimestamp = new DateTime(
2020,
1,
1,
0,
0,
0);
var consumerResult = new ConsumeResult <byte[], byte[]>
{
Message = new Message <byte[], byte[]>
{
Timestamp = new Timestamp(expectedMessageTimestamp),
},
};
var target = new ConsumerContext(
null,
null,
consumerResult,
CancellationToken.None,
0);
// Act
var messageTimestamp = target.MessageTimestamp;
// Assert
messageTimestamp.Should().Be(expectedMessageTimestamp.ToUniversalTime());
}
public void CanRoundtripSomeStuff_String()
{
var context = new ConsumerContext();
context.SetItem("hej");
Assert.That(context.GetItem <string>(), Is.EqualTo("hej"));
}
public ActionResult DeleteConfirmed(int id)
{
ContentItemTool contentitemtool = ConsumerContext.ContentItemTools.Find(id);
ConsumerContext.ContentItemTools.Remove(contentitemtool);
ConsumerContext.SaveChanges();
return(RedirectToAction("Index"));
}
public static void SetTransportMessage(this ConsumerContext context, Message message)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
context.Properties[MessageKey] = message;
}
/// <summary>
/// 注册监听器
/// </summary>
/// <param name="action"></param>
/// <param name="maxReceiveMQThread"></param>
/// <param name="context"></param>
public virtual void Register(Action<MQMessage> action,ConsumerContext context)
{
DebugHelper.WriteLine(context.GetMQPathID(), context.GetMQPath(), "ReceiveMessageListener", "消费者开始监听器");
context.Listener = this; context.ActionInfo.InnerAction = action;
var quque = new ReceiveMessageQuque(context);//注册队列
heartbeat = new ConsumerHeartbeatProtect(context);//注册心跳
DebugHelper.WriteLine(context.GetMQPathID(), context.GetMQPath(), "ReceiveMessageListener", "消费者监听器注册成功");
LogHelper.WriteLine(context.GetMQPathID(), context.GetMQPath(), "ReceiveMessageListener", "消费者监听器注册成功");
}
public static Message GetTransportMessage(this ConsumerContext context)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
return(context.GetOrDefault <Message>(MessageKey, null));
}
public ActionResult Edit(Course course)
{
if (ModelState.IsValid)
{
ConsumerContext.Entry(course).State = EntityState.Modified;
ConsumerContext.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(course));
}
public InMemConsumerImplementation(InMemEventBroker eventBroker, ILoggerFactory loggerFactory, Topics topics,
IConsumerDispatcher consumerDispatcher, ConsumerContext consumerContext)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_eventBroker = eventBroker ?? throw new ArgumentNullException(nameof(eventBroker));
_logger = loggerFactory.GetLogger(typeof(InMemConsumerImplementation));
}
public ActionResult Edit([Bind(Include = "ContentItemToolId,ConsumerKey,ConsumerSecret,CustomParameters,Description,Name,Url")] ContentItemTool contentitemtool)
{
if (ModelState.IsValid)
{
ConsumerContext.Entry(contentitemtool).State = EntityState.Modified;
ConsumerContext.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(contentitemtool));
}
public ActionResult PlaceContentItem(LtiRequest model)
{
var ltiMessageType = model.LtiMessageType;
if (!string.IsNullOrEmpty(ltiMessageType) &&
!ltiMessageType.Equals(LtiConstants.ContentItemSelectionLtiMessageType))
{
return(RedirectToAction("BadRequest", "Error", new { error = "Unknown LTI message" }));
}
var ltiResponse = (IContentItemSelection)model;
var data = JsonConvert.DeserializeObject <ContentItemData>(ltiResponse.Data);
var contentItemTool = ConsumerContext.ContentItemTools.Find(data.ContentItemToolId);
if (contentItemTool == null)
{
return(RedirectToAction("BadRequest", "Error", new { error = "Invalid content item tool id" }));
}
var course = ConsumerContext.Courses.Find(data.CourseId);
if (course == null)
{
return(RedirectToAction("BadRequest", "Error", new { error = "Invalid course id" }));
}
var contentItems = JsonConvert.DeserializeObject <ContentItemSelectionGraph>(ltiResponse.ContentItems);
foreach (var contentItem in contentItems.Graph)
{
if (contentItem.Type == LtiConstants.LtiLinkType)
{
var custom = new StringBuilder();
foreach (var key in contentItem.Custom.Keys)
{
custom.AppendFormat("{0}={1}\n", key, contentItem.Custom[key]);
}
var assignment = new Assignment
{
ConsumerKey = contentItemTool.ConsumerKey,
Course = course,
ConsumerSecret = contentItemTool.ConsumerSecret,
CustomParameters = custom.ToString(),
Description = contentItem.Text,
Name = contentItem.Title,
Url = (contentItem.Id ?? new Uri(contentItemTool.Url)).AbsoluteUri
};
ConsumerContext.Assignments.Add(assignment);
}
}
ConsumerContext.SaveChanges();
return(RedirectToAction("Details", "Course", new { id = data.CourseId }));
}
public ActionResult Create(Course model)
{
if (ModelState.IsValid)
{
model.Instructor = UserManager.FindById(User.Identity.GetUserId());
ConsumerContext.Courses.Add(model);
ConsumerContext.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
private async static Task SaveTransformedConsumer(IEnumerable <ConsumerDTO> consumer)
{
using (var dbContext = new ConsumerContext())
{
// Creates the database if not exists
dbContext.Database.EnsureCreated();
var comsumers = consumer.Select(c => c.ToConsumerEntity()).ToList();
dbContext.Consumer.AddRange(comsumers);
await dbContext.SaveChangesAsync();
}
}
/// <summary>
/// 处理方法
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public ResponseResult Handler(ConsumerContext context)
{
var number = 0;
var number1 = 1 / number;
return(new ResponseResult()
{
Success = true,
Data = "测试访问成功的结果数据"
});
}
/// <summary>
/// 处理方法
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public ResponseResult Handler(ConsumerContext context)
{
var number = 0;
var number1 = 1 / number;
return(new ResponseResult()
{
Success = true,
Data = "Topic测试数据返回结果！！！"
});
}
/// <summary>
/// 处理方法
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public ResponseResult Handler(ConsumerContext context)
{
var number = 0;
var number1 = 1 / number;
return(new ResponseResult()
{
Success = true,
Data = $"路由Key:{context.RoutingKey}Fanout测试数据返回结果！！！"
});
}
public static IEnumerable <TopicPartitionOffset> PartitionsAssigned(
ILogger logger,
IReadOnlyList <TopicPartition> partitions,
IPositionManager positionManager,
Func <ConsumerContext, IEnumerable <TopicPartition>, Task> partitionsAssignedHandler,
ConsumerContext context
)
{
if (!partitions.Any())
{
return(Enumerable.Empty <TopicPartitionOffset>());
}
var partitionsByTopic = partitions
.GroupBy(p => p.Topic)
.Select(g => new { Topic = g.Key, Partitions = g.Select(p => p.Partition.Value) })
.ToList();
logger.Info("Assignment: {@partitions}", partitionsByTopic);
if (partitionsAssignedHandler != null)
{
AsyncHelpers.RunSync(() => partitionsAssignedHandler(context, partitions));
}
return(AsyncHelpers.GetAsync(async() =>
{
var results = await partitions
.Select(async tp => new
{
TopicPartition = tp,
Position = await positionManager.Get(tp.Topic, tp.Partition.Value)
})
.ToListAsync();
return results
.Select(a =>
{
if (a.Position.IsDefault)
{
return a.TopicPartition.WithOffset(Offset.Beginning);
}
if (a.Position.IsOnlyNew)
{
return a.TopicPartition.WithOffset(Offset.End);
}
return a.Position.Advance(1).ToTopicPartitionOffset();
})
.ToList();
}));
}
/// <summary>
/// Delete the Score that corresponds to the result.
/// </summary>
/// <param name="lisResultSourcedId">The sourcedId of the LisResult to delete.</param>
/// <returns>True if the Score was deleted.</returns>
protected override bool DeleteResult(string lisResultSourcedId)
{
var model = GetScore(lisResultSourcedId);
if (model.IsValid && model.Score != null)
{
ConsumerContext.Scores.Remove(model.Score);
ConsumerContext.SaveChanges();
return(true);
}
return(false);
}
public ActionResult Create([Bind(Include = "ContentItemToolId,ConsumerKey,ConsumerSecret,CustomParameters,Description,Name,Url")] ContentItemTool contentitemtool)
{
if (ModelState.IsValid)
{
contentitemtool.Owner = UserManager.FindById(User.Identity.GetUserId());
ConsumerContext.ContentItemTools.Add(contentitemtool);
ConsumerContext.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(contentitemtool));
}
public void CanRoundtripSomeStuff_StringAndHashSet()
{
var context = new ConsumerContext();
var now = DateTimeOffset.Now;
context.SetItem("hej");
context.SetItem(new HashSet <DateTimeOffset> {
now
});
Assert.That(context.GetItem <string>(), Is.EqualTo("hej"));
Assert.That(context.GetItem <HashSet <DateTimeOffset> >().ToArray(), Is.EqualTo(new[] { now }));
}
protected override ISubscribeHandle DoStart(ConsumerContext context)
{
CompositeSubscribeHandle handler = new CompositeSubscribeHandle();
List<Partition> partitions = MetaService.ListPartitionsByTopic(context.Topic.Name);
IConsumingStrategy consumingStrategy = ConsumingStrategyRegistry.FindStrategy(context.ConsumerType);
foreach (Partition partition in partitions)
{
handler.AddSubscribeHandle(consumingStrategy.Start(context, partition.ID));
}
return handler;
}
public static void ConsumerIsComing(Consumer consumer)
{
ConsumerContext consumerContext = new ConsumerContext {
ConsumerName = consumer.Name
};
consumer.Show(consumerContext);
for (int i = 0; i < 5; i++)
{
AbstractFood abstractFood = CreateFood(consumer);
consumerContext.AbstractFoodList.Add(abstractFood);
}
PrintResult(consumer);
}
public bool StartWork(System.Action<object> backgroundProc)
{
if (null == backgroundProc)
{
return false;
}
context = new ConsumerContext(backgroundProc);
if (!base.StartWork(BkgProc, context))
{
context = null;
return false;
}
return true;
}
/// <summary>
/// 启动服务
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task StartAsync(CancellationToken cancellationToken)
{
var config = RabbitmqContext.Config;
if (config == null)
{
throw new TypeInitializationException("RabbitmqConfig", null);
}
_channel.BasicQos(0, 1, false);
_channel.QueueDeclare(RabbitmqContext.AuditQueueName, true, false, false, null);//声明审计队列
foreach (RabbitmqServiceOptions service in config.Services)
{
if (!service.IsAudit)
{
continue;
}
var exchangeType = service.PatternType.GetExchangeType();
var exchangeName = service.PatternType.GetExchangeName(service.ExchangeName);
_channel.ExchangeDeclare(exchangeName, exchangeType); //申明交换机
_channel.QueueBind(RabbitmqContext.AuditQueueName, exchangeName, service.QueueName); //建立队列与交换机的绑定关系
}
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (sender, eventArgs) =>
{
var canAck = true;
try
{
IBasicProperties basicProperties = eventArgs.BasicProperties; //消息属性
IDictionary <string, object> headers = eventArgs.BasicProperties.Headers; //头部信息
if (!string.IsNullOrEmpty(eventArgs.Exchange) && (headers == null || !headers.ContainsKey(RabbitmqContext.RetryCountKeyName)))
{
ConsumerContext context = eventArgs.GetConsumerContext(); //获取消费者消息处理上下文
_mongoDbContext.Collection <ConsumerContext>().InsertOneAsync(context, cancellationToken: cancellationToken); //添加审计记录
}
}
catch (Exception ex)
{
canAck = false;
_log.Error($"【审计日志】事件参数：{JsonConvert.SerializeObject(eventArgs)}", ex);
}
//处理应答结果
AnswerHandler(canAck, eventArgs);
};
_channel.BasicConsume(RabbitmqContext.AuditQueueName, false, consumer);
return(Task.CompletedTask);
}
public KafkaMessageReceiver(ReceiveEndpointContext context, ConsumerContext <TKey, TValue> consumerContext)
{
_context = context;
_consumerContext = consumerContext;
_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(Stopping);
_consumerContext.ErrorHandler += HandleKafkaError;
_deliveryComplete = TaskUtil.GetTask <bool>();
_dispatcher = context.CreateReceivePipeDispatcher();
_dispatcher.ZeroActivity += HandleDeliveryComplete;
Task.Run(Consume);
}
public ISubscribeHandle Start(ConsumerContext context, int partitionId)
{
try
{
int localCacheSize = config.GetLocalCacheSize(context.Topic.Name);
IConsumerTask consumerTask = GetConsumerTask(context, partitionId, localCacheSize);
Thread pollingThread = new Thread(consumerTask.Start);
pollingThread.IsBackground = false;
pollingThread.Start();
return new BrokerLongPollingSubscribeHandler(consumerTask);
}
catch (Exception e)
{
throw new Exception(string.Format("Start Consumer failed(topic={0}, partition={1}, groupId={2})", context
.Topic.Name, partitionId, context.GroupId), e);
}
}
public void Notify(List<IConsumerMessage> msgs, ConsumerContext context, ProducerConsumer<Action> executorService, IPipeline<object> pipeline)
{
foreach (IConsumerMessage msg in msgs)
{
NackDelayedBrokerConsumerMessage nackDelayedMsg = new NackDelayedBrokerConsumerMessage((BrokerConsumerMessage)msg);
List<IConsumerMessage> singleMsg = new List<IConsumerMessage>();
singleMsg.Add(nackDelayedMsg);
int retries = 0;
while (true)
{
pipeline.Put(new Pair<ConsumerContext, List<IConsumerMessage>>(context, singleMsg));
if (nackDelayedMsg.BaseConsumerMessage.Status == MessageStatus.FAIL)
{
// reset status to enable reconsume or nack
nackDelayedMsg.BaseConsumerMessage.ResetStatus();
if (retries < m_retryPolicy.GetRetryTimes())
{
Sleep(m_retryPolicy.NextScheduleTimeMillis(retries, 0));
retries++;
}
else
{
msg.Nack();
break;
}
}
else
{
msg.Ack();
break;
}
}
}
}
public void Notify(List<IConsumerMessage> msgs, ConsumerContext context, ProducerConsumer<Action> executorService, IPipeline<object> pipeline)
{
pipeline.Put(new Pair<ConsumerContext, List<IConsumerMessage>>(context, msgs));
}
public CourseController(ApplicationUserManager userManager, ConsumerContext consumerContext)
{
UserManager = userManager;
ConsumerContext = consumerContext;
}
public DefaultConsumingStrategyConsumerTask(ConsumerContext context, int partitionId, int cacheSize)
: base(context, partitionId, cacheSize)
{
}
public void Stop(ConsumerContext context)
{
DoStop(context);
}
protected abstract ISubscribeHandle DoStart(ConsumerContext context);
public HomeController(ConsumerContext consumerContext)
{
ConsumerContext = consumerContext;
}
protected abstract IConsumerTask GetConsumerTask(ConsumerContext context, int partitionId, int localCacheSize);
public StrictlyOrderedConsumingStrategyConsumerTask(ConsumerContext context, int partitionId, int cacheSize)
: base(context, partitionId, cacheSize)
{
queryOffsetResultMonitor = ComponentLocator.Lookup<IQueryOffsetResultMonitor>();
}
protected void DoStop(ConsumerContext context)
{
}
public ContentItemToolController(ApplicationUserManager userManager, ConsumerContext consumerContext)
{
UserManager = userManager;
ConsumerContext = consumerContext;
}
public ReceiveMessageQuque(ConsumerContext context)
{
Context = context; Context.Quque = this;
Create();
}
protected override IConsumerTask GetConsumerTask(ConsumerContext context, int partitionId, int localCacheSize)
{
return new StrictlyOrderedConsumingStrategyConsumerTask(context, partitionId, localCacheSize);
}
public ISubscribeHandle Start(ConsumerContext context)
{
return DoStart(context);
}
public AssignmentController(ApplicationUserManager userManager, ConsumerContext consumerContext)
{
UserManager = userManager;
ConsumerContext = consumerContext;
}
