static CachedConfigurator GetOrAdd(HandlerRegistration registration)
{
return(Instance.GetOrAdd(registration.ImplementationType, _ =>
{
if (registration.ServiceType.Closes(typeof(ICommandHandler <>)))
{
return typeof(CachedCommandConfigurator <>).CloseAndBuildAs <CachedConfigurator>(registration.MessageType);
}
else if (registration.ServiceType.Closes(typeof(IDistributedEventListener <>)))
{
return typeof(CachedDistributedEventListenerConfigurator <,>).CloseAndBuildAs <CachedConfigurator>(registration.MessageType, registration.ImplementationType);
}
else if (registration.ServiceType.Closes(typeof(IEventListener <>)))
{
return typeof(CachedEventListenerConfigurator <,>).CloseAndBuildAs <CachedConfigurator>(registration.MessageType, registration.ImplementationType);
}
else if (registration.ServiceType.Closes(typeof(ICommandHandler <,>)))
{
return typeof(CachedCommandResponseConfigurator <,>).CloseAndBuildAs <CachedConfigurator>(registration.MessageType, registration.ResponseType);
}
else if (registration.ServiceType.Closes(typeof(IFaultHandler <>)))
{
return typeof(CachedFaultConfigurator <,>).CloseAndBuildAs <CachedConfigurator>(registration.MessageType, registration.ImplementationType);
}
throw new InvalidOperationException($"Unable to find Configurator for service type `{registration.ServiceType.Name}`");
}));
}
public async Task <IHandlerRegistration> RegisterAsync(IContextualProvider <IMessageHandler <TMessage> > handlerProvider)
{
var provider = new ContextualProvider <IMessageReplyer <TMessage> >(
serviceProvider => new MessageReplyer <TMessage>(_endPoint, handlerProvider.ProvideInstance(serviceProvider)));
return(await HandlerRegistration.CreateRegistrationAsync(_handler, provider));
}
private (bool processResult, bool stopExecution) CallHandler(
HandlerRegistration handlerRegistration,
MethodInfo handlerDelegateInvokeMethodInfo,
object handlerDelegate,
object message,
bool processResult
)
{
var stopExecution = false;
if (handlerRegistration.IsAsync)
{
ThreadPool.QueueUserWorkItem(_ =>
{
((Task <(bool success, bool @continue)>)handlerDelegateInvokeMethodInfo.Invoke(handlerDelegate, new[] { message })).ConfigureAwait(false).GetAwaiter().GetResult();
});
}
else
{
var handlerReturnTask = ((Task <(bool success, bool @continue)>)handlerDelegateInvokeMethodInfo.Invoke(handlerDelegate, new[] { message })).ConfigureAwait(false).GetAwaiter().GetResult();
// Test only previous processResult are valid
if (processResult)
{
processResult = handlerReturnTask.success;
}
stopExecution = !handlerReturnTask.@continue || !processResult && handlerRegistration.StopOnError;
}
return(processResult, stopExecution);
}
private void UpdateEntity(IHandlerRegistration entity)
{
using (var ctx = new HappyDogShowContext())
{
HandlerRegistration foundEntity = ctx.HandlerRegistrations.Where(d => d.ID == entity.Id).First();
if (foundEntity != null)
{
Sex entitySex = ctx.Sexes.Where(g => g.ID == entity.SexId).First();
foundEntity.Sex = entitySex;
foundEntity.DateOfBirth = entity.DateOfBirth;
foundEntity.Surname = entity.Surname;
foundEntity.Title = entity.Title;
foundEntity.FirstName = entity.FirstName;
foundEntity.Address = entity.Address;
foundEntity.PostalCode = entity.PostalCode;
foundEntity.Tel = entity.Tel;
foundEntity.Cell = entity.Cell;
foundEntity.Fax = entity.Fax;
foundEntity.Email = entity.Email;
ctx.SaveChanges();
}
}
}
private int CreateEntity(IHandlerRegistration entity)
{
int newid = -1;
using (var ctx = new HappyDogShowContext())
{
Sex entitySex = ctx.Sexes.Where(g => g.ID == entity.SexId).First();
HandlerRegistration newEntity = new HandlerRegistration()
{
Sex = entitySex,
DateOfBirth = entity.DateOfBirth,
Surname = entity.Surname,
Title = entity.Title,
FirstName = entity.FirstName,
Address = entity.Address,
PostalCode = entity.PostalCode,
Tel = entity.Tel,
Cell = entity.Cell,
Fax = entity.Fax,
Email = entity.Email
};
ctx.HandlerRegistrations.Add(newEntity);
ctx.SaveChanges();
newid = newEntity.ID;
}
return(newid);
}
private int CreateEntity(IHandlerEntryEntity entity)
{
int newid = -1;
using (var ctx = new HappyDogShowContext())
{
DogRegistration selectedDog = ctx.DogRegistrations.Where(i => i.ID == entity.Dog.Id).First();
DogShow selectedShow = ctx.DogShows.Where(i => i.ID == entity.DogShow.Id).First();
HandlerClass selectedClass = ctx.HandlerClasses.Where(i => i.ID == entity.Class.Id).First();
HandlerRegistration selectedHander = ctx.HandlerRegistrations.Where(i => i.ID == entity.Handler.Id).First();
HandlerEntry newEntity = new HandlerEntry()
{
Dog = selectedDog,
Show = selectedShow,
EnteredClass = selectedClass,
Handler = selectedHander
};
ctx.HandlerEntries.Add(newEntity);
ctx.SaveChanges();
newid = newEntity.ID;
}
return(newid);
}
public static IServiceCollection AddCommandHandlers(this IServiceCollection services)
{
services.AddSingleton <CommandBus>();
services.AddTransient <CommandHandlerAggregateArgument>();
var listHandlerTypes = typeof(CommandHandlerRegistration).Assembly.GetTypes()
.Where(x => !x.IsAbstract && x.Name.EndsWith("Handler", StringComparison.InvariantCulture) && x.GetInterfaces().Any(y => HandlerRegistration.IsHandlerInterface(y, typeof(ICommandHandler <>))))
.ToList();
listHandlerTypes.ForEach(x => HandlerRegistration.AddHandler(services, x, typeof(ICommandHandler <>)));
return(services);
}
public IHandlerRegistration RegisterHandler(Type handlerType)
{
var handlerDeclarations = handlerType.GetInterfaces().Where(isHandler).ToList();
handlerDeclarations.Each(x =>
{
var r = new HandlerRegistration(x, handlerType);
registeredHandlerTypes[r.MessageType] = r;
});
return(this);
}
private ValidationConfigurer OnValidationFailed <TMessage, TValidationFailedStrategy>()
where TValidationFailedStrategy : IValidationFailedStrategy
{
Type messageType = typeof(TMessage);
if (_registeredHandlerTypes.TryGetValue(messageType, out HandlerRegistration registeredHandlerType))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.ArgumentNullException_MessageTypeAlreadyConfigured, messageType.FullName, registeredHandlerType.StrategyType.FullName));
}
_registeredHandlerTypes[messageType] = new HandlerRegistration
{
MessageType = messageType,
StrategyType = typeof(TValidationFailedStrategy),
ImplementationFactory = ctx => ctx.Get <TValidationFailedStrategy>()
};
return(this);
}
public async Task <IHandlerRegistration> RegisterAsync <TEvent, TEntity>(IContextualProvider <IEventReplayer <TId, TEventBase, TEntityBase, TEvent, TEntity> > eventReplayerFactory)
where TEvent : TEventBase
where TEntity : TEntityBase
{
if (eventReplayerFactory == null)
{
throw new ArgumentNullException(nameof(eventReplayerFactory));
}
IAsyncSingleHandlerRegistry <IEventReplayer <TId, TEventBase, TEntityBase> > handlerRegistry;
ImmutableDictionary <Type, ImmutableDictionary <Type, IAsyncSingleHandlerRegistry <IEventReplayer <TId, TEventBase, TEntityBase> > > > current = _replayer,
start,
desired;
do
{
start = current;
if (start.TryGetValue(typeof(TEvent), out var perEventRegistry) &&
perEventRegistry.TryGetValue(typeof(TEntity), out handlerRegistry))
{
break;
}
desired = start.Remove(typeof(TEvent));
handlerRegistry = new AsyncSingleHandlerRegistry <IEventReplayer <TId, TEventBase, TEntityBase> >();
perEventRegistry = (perEventRegistry ?? ImmutableDictionary <Type, IAsyncSingleHandlerRegistry <IEventReplayer <TId, TEventBase, TEntityBase> > > .Empty)
.Add(typeof(TEntity), handlerRegistry);
desired = desired.Add(typeof(TEvent), perEventRegistry);
current = Interlocked.CompareExchange(ref _replayer, desired, start);
}while (current != start);
var untypedFactory = new EventReplayerFactory <TEvent, TEntity>(eventReplayerFactory);
return(await HandlerRegistration.CreateRegistrationAsync(handlerRegistry, untypedFactory));
}
public AndRetrievingRegistrationForSampleHandlerInput()
{
registeredHandler = register.GetHandlerRegistration <SampleHandlerInput>();
}
public async Task CanReceiveChannelPointCustomRewardRedemptionAddNotification()
{
const string twitchNotification = @"{""subscription"":{""id"":""f1c2a387-161a-49f9-a165-0f21d7a4e1c4"",""type"":""channel.channel_points_custom_reward_redemption.add"",""version"":""1"",""status"":""enabled"",""cost"":0,""condition"":{""broadcaster_user_id"":""1337""},""transport"":{""method"":""webhook"",""callback"":""https://example.com/webhooks/callback""},""created_at"":""2019-11-16T10:11:12.123Z""},""event"":{""id"":""1234"",""broadcaster_user_id"":""1337"",""broadcaster_user_login"":""cool_user"",""broadcaster_user_name"":""Cool_User"",""user_id"":""9001"",""user_login"":""cooler_user"",""user_name"":""Cooler_User"",""user_input"":""pogchamp"",""status"":""unfulfilled"",""reward"":{""id"":""9001"",""title"":""title"",""cost"":100,""prompt"":""reward prompt""},""redeemed_at"":""2020-07-15T17:16:03.17106713Z""}}";
using Stream requestBody = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(twitchNotification));
var headers = new Dictionary <string, StringValues>
{
{ TwitchConstants.EventSubHeaderNames.MessageId, new StringValues("e76c6bd4-55c9-4987-8304-da1588d8988b") },
{ TwitchConstants.EventSubHeaderNames.MessageRetry, new StringValues("0") },
{ TwitchConstants.EventSubHeaderNames.MessageSignature, new StringValues("sha256=4c87325fea62c0082668ce6258de7eaccc0ee56e0d42242d54b60ce2f3ecb6b3") },
{ TwitchConstants.EventSubHeaderNames.MessageTimeStamp, new StringValues("2019-11-16T10:11:12.123Z") },
{ TwitchConstants.EventSubHeaderNames.MessageType, new StringValues(TwitchConstants.EventSubMessageTypes.Notification) },
{ TwitchConstants.EventSubHeaderNames.SubscriptionType, new StringValues(TwitchConstants.EventSubTypes.ChannelCustomRewardRedemptionAdd) },
{ TwitchConstants.EventSubHeaderNames.SubscriptionVersion, new StringValues("1") },
};
Mock <HttpContext> httpContextMoq = new Mock <HttpContext>();
Mock <HttpResponse> httpResponse = new Mock <HttpResponse>();
httpContextMoq.Setup(c => c.Request.Headers)
.Returns(new HeaderDictionary(headers));
httpContextMoq.Setup(c => c.Request.Body)
.Returns(requestBody);
httpContextMoq.Setup(c => c.Request.BodyReader)
.Returns(PipeReader.Create(requestBody));
httpContextMoq.Setup(c => c.Response)
.Returns(httpResponse.Object);
bool receivedEvent = false;
Func <EventSubContext, TwitchEventSubChannelPointsCustomRewardRedemptionEvent, Task> assertingHandler = (context, twitchEvent) =>
{
Assert.NotNull(context);
Assert.NotNull(twitchEvent);
Assert.NotNull(context.Subscription);
Assert.Equal(Guid.Parse("f1c2a387-161a-49f9-a165-0f21d7a4e1c4"), context.Subscription.Id);
Assert.Equal(TwitchConstants.EventSubTypes.ChannelCustomRewardRedemptionAdd, context.Subscription.Type);
Assert.Equal("1234", twitchEvent.Id);
Assert.Equal("1337", twitchEvent.BroadcasterUserId);
Assert.Equal("cool_user", twitchEvent.BroadcasterUserLogin);
Assert.Equal("Cool_User", twitchEvent.BroadcasterUserName);
Assert.Equal("9001", twitchEvent.UserId);
Assert.Equal("cooler_user", twitchEvent.UserLogin);
Assert.Equal("Cooler_User", twitchEvent.UserName);
Assert.Equal("pogchamp", twitchEvent.UserInput);
Assert.Equal("unfulfilled", twitchEvent.Status);
Assert.Equal(DateTimeOffset.Parse("2020-07-15T17:16:03.17106713Z"), twitchEvent.RedeemedAt);
Assert.NotNull(twitchEvent.Reward);
Assert.Equal("9001", twitchEvent.Reward.Id);
Assert.Equal("title", twitchEvent.Reward.Title);
Assert.Equal("reward prompt", twitchEvent.Reward.Prompt);
Assert.Equal(100, twitchEvent.Reward.Cost);
receivedEvent = true;
return(Task.CompletedTask);
};
var eventSubOptions = new EventSubOptions
{
WebHookSecret = "secret",
};
var mockLogger = new Mock <ILogger <EventSubHandler> >();
var eventHandler = new HandlerRegistration <TwitchEventSubChannelPointsCustomRewardRedemptionEvent>(assertingHandler);
var eventSubHandler = new EventSubHandler(
new List <IHandlerRegistration> {
eventHandler
},
new OptionsWrapper <EventSubOptions>(eventSubOptions),
mockLogger.Object);
await eventSubHandler.HandleRequestAsync(httpContextMoq.Object);
Assert.True(receivedEvent);
}
public static void Cache(HandlerRegistration registration)
{
GetOrAdd(registration);
}
public static void Configure(HandlerRegistration registration, IReceiveEndpointConfigurator configurator, IServiceProvider container)
{
GetOrAdd(registration).Configure(configurator, container);
}
public async Task RejectsRequestsWithMissingHeaders()
{
const string twitchNotification = @"{""data"":[{""id"":""f1c2a387-161a-49f9-a165-0f21d7a4e1c4"",""status"":""webhook_callback_verification_pending"",""type"":""channel.follow"",""version"":""1"",""cost"":1,""condition"":{""broadcaster_user_id"":""12826""},""transport"":{""method"":""webhook"",""callback"":""https://example.com/webhooks/callback""},""created_at"":""2019-11-16T10:11:12.123Z""}],""total"":1,""total_cost"":1,""max_total_cost"":10000,""limit"":10000}";
using Stream requestBody = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(twitchNotification));
var missingSignature = new Dictionary <string, StringValues>
{
{ TwitchConstants.EventSubHeaderNames.MessageId, new StringValues("e76c6bd4-55c9-4987-8304-da1588d8988b") },
{ TwitchConstants.EventSubHeaderNames.MessageRetry, new StringValues("0") },
{ TwitchConstants.EventSubHeaderNames.MessageTimeStamp, new StringValues("2019-11-16T10:11:12.123Z") },
{ TwitchConstants.EventSubHeaderNames.MessageType, new StringValues("webhook_callback_verification") },
{ TwitchConstants.EventSubHeaderNames.SubscriptionType, new StringValues("channel.follow") },
{ TwitchConstants.EventSubHeaderNames.SubscriptionVersion, new StringValues("1") },
};
var missingMessageType = new Dictionary <string, StringValues>
{
{ TwitchConstants.EventSubHeaderNames.MessageId, new StringValues("e76c6bd4-55c9-4987-8304-da1588d8988b") },
{ TwitchConstants.EventSubHeaderNames.MessageRetry, new StringValues("0") },
{ TwitchConstants.EventSubHeaderNames.MessageSignature, new StringValues("sha256=f56bf6ce06a1adf46fa27831d7d15d") },
{ TwitchConstants.EventSubHeaderNames.MessageTimeStamp, new StringValues("2019-11-16T10:11:12.123Z") },
{ TwitchConstants.EventSubHeaderNames.SubscriptionType, new StringValues("channel.follow") },
{ TwitchConstants.EventSubHeaderNames.SubscriptionVersion, new StringValues("1") },
};
Mock <HttpResponse> httpResponse = new Mock <HttpResponse>();
httpResponse.SetupSet(r => r.StatusCode = 403);
Mock <HttpContext> httpContextMoqNoSignature = new Mock <HttpContext>();
httpContextMoqNoSignature.Setup(c => c.Request.Headers)
.Returns(new HeaderDictionary(missingSignature));
httpContextMoqNoSignature.Setup(c => c.Request.Body)
.Returns(requestBody);
httpContextMoqNoSignature.Setup(c => c.Response)
.Returns(httpResponse.Object);
Mock <HttpContext> httpContextMoqNoMessageType = new Mock <HttpContext>();
httpContextMoqNoMessageType.Setup(c => c.Request.Headers)
.Returns(new HeaderDictionary(missingMessageType));
httpContextMoqNoMessageType.Setup(c => c.Request.Body)
.Returns(requestBody);
httpContextMoqNoMessageType.Setup(c => c.Response)
.Returns(httpResponse.Object);
Func <EventSubContext, TwitchEventSubEvent, Task> assertingHandler = (context, twitchEvent) =>
{
throw new Exception("Should not reach the handler callback");
};
var eventSubOptions = new EventSubOptions
{
WebHookSecret = "secret",
};
var mockLogger = new Mock <ILogger <EventSubHandler> >();
var eventHandler = new HandlerRegistration <TwitchEventSubEvent>(assertingHandler);
var eventSubHandler = new EventSubHandler(
new List <IHandlerRegistration> {
eventHandler
},
new OptionsWrapper <EventSubOptions>(eventSubOptions),
mockLogger.Object);
await eventSubHandler.HandleRequestAsync(httpContextMoqNoSignature.Object);
await eventSubHandler.HandleRequestAsync(httpContextMoqNoMessageType.Object);
}
public async Task CanReceiveChannelUpdateNotification()
{
const string twitchNotification = @"{""subscription"":{""id"":""f1c2a387-161a-49f9-a165-0f21d7a4e1c4"",""type"":""channel.update"",""version"":""1"",""status"":""enabled"",""cost"":0,""condition"":{""broadcaster_user_id"":""1337""},""transport"":{""method"":""webhook"",""callback"":""https://example.com/webhooks/callback""},""created_at"":""2019-11-16T10:11:12.123Z""},""event"":{""broadcaster_user_id"":""1337"",""broadcaster_user_login"":""cool_user"",""broadcaster_user_name"":""Cool_User"",""title"":""Best Stream Ever"",""language"":""en"",""category_id"":""21779"",""category_name"":""Fortnite"",""is_mature"":false}}";
using Stream requestBody = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(twitchNotification));
var headers = new Dictionary <string, StringValues>
{
{ TwitchConstants.EventSubHeaderNames.MessageId, new StringValues("e76c6bd4-55c9-4987-8304-da1588d8988b") },
{ TwitchConstants.EventSubHeaderNames.MessageRetry, new StringValues("0") },
{ TwitchConstants.EventSubHeaderNames.MessageSignature, new StringValues("sha256=144c8a2a7c859a77bb464e676571f7ffb634f4e34ac64a8794114596ee3eaeea") },
{ TwitchConstants.EventSubHeaderNames.MessageTimeStamp, new StringValues("2019-11-16T10:11:12.123Z") },
{ TwitchConstants.EventSubHeaderNames.MessageType, new StringValues(TwitchConstants.EventSubMessageTypes.Notification) },
{ TwitchConstants.EventSubHeaderNames.SubscriptionType, new StringValues(TwitchConstants.EventSubTypes.ChannelUpdate) },
{ TwitchConstants.EventSubHeaderNames.SubscriptionVersion, new StringValues("1") },
};
Mock <HttpContext> httpContextMoq = new Mock <HttpContext>();
Mock <HttpResponse> httpResponse = new Mock <HttpResponse>();
httpContextMoq.Setup(c => c.Request.Headers)
.Returns(new HeaderDictionary(headers));
httpContextMoq.Setup(c => c.Request.Body)
.Returns(requestBody);
httpContextMoq.Setup(c => c.Request.BodyReader)
.Returns(PipeReader.Create(requestBody));
httpContextMoq.Setup(c => c.Response)
.Returns(httpResponse.Object);
bool receivedEvent = false;
Func <EventSubContext, TwitchEventSubChannelUpdateEvent, Task> assertingHandler = (context, twitchEvent) =>
{
Assert.NotNull(context);
Assert.NotNull(twitchEvent);
Assert.NotNull(context.Subscription);
Assert.Equal(Guid.Parse("f1c2a387-161a-49f9-a165-0f21d7a4e1c4"), context.Subscription.Id);
Assert.Equal(TwitchConstants.EventSubTypes.ChannelUpdate, context.Subscription.Type);
Assert.Equal("1337", context.Subscription.Condition.BroadcasterUserId);
Assert.Equal("1337", twitchEvent.BroadcasterUserId);
Assert.Equal("cool_user", twitchEvent.BroadcasterUserLogin);
Assert.Equal("Cool_User", twitchEvent.BroadcasterUserName);
Assert.Equal("Best Stream Ever", twitchEvent.Title);
Assert.Equal("en", twitchEvent.Language);
Assert.Equal("21779", twitchEvent.CategoryId);
Assert.Equal("Fortnite", twitchEvent.CategoryName);
Assert.False(twitchEvent.IsMature);
receivedEvent = true;
return(Task.CompletedTask);
};
var eventSubOptions = new EventSubOptions
{
WebHookSecret = "secret",
};
var mockLogger = new Mock <ILogger <EventSubHandler> >();
var eventHandler = new HandlerRegistration <TwitchEventSubChannelUpdateEvent>(assertingHandler);
var eventSubHandler = new EventSubHandler(
new List <IHandlerRegistration> {
eventHandler
},
new OptionsWrapper <EventSubOptions>(eventSubOptions),
mockLogger.Object);
await eventSubHandler.HandleRequestAsync(httpContextMoq.Object);
Assert.True(receivedEvent);
}
/*
* protected override IMessageHandlerBackgroundWorker CreateMessageHandlerWorker(AwsSqsHandlerConfiguration messageHandlerConfiguration,
* string queueName, Action<IMessageHandlerBackgroundWorker, Exception> errorHandler)
* {
* var messageHandler = messageHandlerConfiguration.MessageHandlerFactory.CreateMessageHandler();
* return new AwsSqsMessageHandlerWorker(this.SqsServer.SqsClient, this.SqsServer, this.SqsServer.QueueUrls, messageHandler, queueName, errorHandler);
* }
*
* protected override IList<IQueueHandlerBackgroundWorker> CreateQueueHandlerWorkers(IDictionary<string, Type> messageQueueNames, IDictionary<Type, AwsSqsHandlerConfiguration> messageHandlerConfigurations,
* Action<IQueueHandlerBackgroundWorker, Exception> errorHandler)
* {
* var queueHandlers = new List<IQueueHandlerBackgroundWorker>();
* foreach (var queue in messageQueueNames)
* {
* var messageConfiguration = messageHandlerConfigurations[queue.Value];
* var waitTimeInSeconds = messageConfiguration.WaitTimeInSeconds.HasValue ? Convert.ToInt32(messageConfiguration.WaitTimeInSeconds.Value) : Convert.ToInt32(this.SqsServer.RequestTimeOut.TotalSeconds);
* var maxNumberOfMessagesToReceivePerRequest = messageConfiguration.MaxNumberOfMessagesToReceivePerRequest.HasValue ? messageConfiguration.MaxNumberOfMessagesToReceivePerRequest.Value : this.SqsServer.MaxNumberOfMessagesToReceivePerRequest;
* var messageVisibilityTimeout = messageConfiguration.MessageVisibilityTimeout.HasValue ? messageConfiguration.MessageVisibilityTimeout.Value : this.SqsServer.MessageVisibilityTimeout;
* queueHandlers.Add(new AwsSqsQueueHandlerWorker(this.SqsServer.SqsClient, this.SqsServer, queue.Value, queue.Key, this.SqsServer.QueueUrls[queue.Key], errorHandler, waitTimeInSeconds, maxNumberOfMessagesToReceivePerRequest, messageVisibilityTimeout));
* }
*
* return queueHandlers;
* }
*/
// TODO:Add 'Retry Count' to default config parameters?
// TODO: Switch 'Task' approach with std ThreadPool, so it is 3.5 compatable? => Finish.
protected override IMessageHandlerBackgroundWorker CreateMessageHandlerWorker(HandlerRegistration <AwsSqsHandlerConfiguration> messageHandlerRegistration, string queueName, Action <IMessageHandlerBackgroundWorker, Exception> errorHandler)
{
var messageHandler = messageHandlerRegistration.MessageHandlerFactory.CreateMessageHandler();
return(new AwsSqsMessageHandlerWorker(this.SqsServer.SqsClient, this.SqsServer, this.SqsServer.QueueUrls, messageHandler, queueName, errorHandler));
}
private void HandleConnection(Socket remote)
{
try
{
if (localOnly && !((IPEndPoint)remote.RemoteEndPoint).Address.Equals(IPAddress.Loopback))
{
Trace.WriteLine("Rejecting non-loopback connection from remote host");
return;
}
else
{
SocketReader reader = new SocketReader(remote, 2048);
string val = reader.NextLine();
Match match = reqLine.Match(val);
if (!match.Success)
{
Trace.WriteLine("Rejecting malformed HTTP query: " + val);
return;
}
else
{
HttpHeaders headers = new HttpHeaders(reader);
string method = match.Groups[1].Value;
string uri = match.Groups[2].Value;
string version = match.Groups[3].Value;
if (headers.ContentLength >= 0)
{
reader.SetBytesRemaining(headers.ContentLength);
}
else if (string.Compare(method, "GET", true, CultureInfo.InvariantCulture) == 0)
{
reader.SetBytesRemaining(0);
}
// Console.WriteLine("URI: " + uri);
OnHandleConnectionBegin();
bool success = false;
for (int i = 0; i < handlers.Count; i++)
{
HandlerRegistration reg = (HandlerRegistration)handlers[i];
if (reg.Pattern.IsMatch(uri))
{
if (reg.Handler(method.ToUpper(CultureInfo.InvariantCulture), uri, headers, reader, remote))
{
success = true;
break;
}
}
}
if (!success)
{
HttpHelper.SendErrorCode(remote, 404, "Not found");
}
return;
}
}
}
finally
{
remote.Shutdown(SocketShutdown.Both);
remote.Close();
}
}
/*
* protected internal override IMessageHandlerBackgroundWorker CreateMessageHandlerWorker(DefaultHandlerConfiguration messageHandlerConfiguration,
* string queueName, Action<IMessageHandlerBackgroundWorker, Exception> errorHandler)
* {
* return new RedisMessageHandlerWorker(
* this.ClientsManager,
* messageHandlerConfiguration.MessageHandlerFactory.CreateMessageHandler(), // messageHandler,
* queueName,
* errorHandler);
* }
*
* protected internal override IList<IQueueHandlerBackgroundWorker> CreateQueueHandlerWorkers(IDictionary<string, Type> messageQueueNames, IDictionary<Type, DefaultHandlerConfiguration> messageHandlerConfigurations,
* Action<IQueueHandlerBackgroundWorker, Exception> errorHandler)
* {
* return new List<IQueueHandlerBackgroundWorker>
* {
* new RedisQueueHandlerWorker(this.ClientsManager, this.RedisMqServer, "RedisMq", errorHandler)
* };
* }
*/
protected override IMessageHandlerBackgroundWorker CreateMessageHandlerWorker(HandlerRegistration <DefaultHandlerConfiguration> messageHandlerRegistration, string queueName, Action <IMessageHandlerBackgroundWorker, Exception> errorHandler)
{
return(new RedisMessageHandlerWorker(
this.ClientsManager,
messageHandlerRegistration.MessageHandlerFactory.CreateMessageHandler(), // messageHandler,
queueName,
errorHandler));
}
