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)); }