コード例 #1
0
        /// <summary>
        /// Replaces custom codes in msg.
        /// </summary>
        /// <param name="conn"></param>
        /// <param name="msg"></param>
        private void HandleCustomCode(ChannelConnection conn, ref string msg)
        {
            // Wrap localization key
            if (this.IsLocalizationKey(msg))
            {
                msg = this.WrapLocalizationKey(msg);

                // Return, as there won't be any custom code.
                return;
            }

            // {pcname} Character name
            if (msg.IndexOf("{pcname}") != -1)
            {
                msg = msg.Replace("{pcname}", conn.SelectedCharacter.Name);
            }

            // {teamname} Character team name
            if (msg.IndexOf("{teamname}") != -1)
            {
                msg = msg.Replace("{teamname}", conn.SelectedCharacter.TeamName);
            }

            // {fullname} Character name + team name
            if (msg.IndexOf("{fullname}") != -1)
            {
                msg = msg.Replace("{fullname}", conn.SelectedCharacter.Name + " " + conn.SelectedCharacter.TeamName);
            }
        }
コード例 #2
0
        public async Task WebSocketsTransportStopsWhenConnectionClosedByTheServer(TransferMode transferMode)
        {
            using (StartLog(out var loggerFactory))
            {
                var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
                var transportToConnection = Channel.CreateUnbounded <byte[]>();
                var channelConnection     = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);

                var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
                await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), channelConnection, transferMode, connectionId : string.Empty, connection : Mock.Of <IConnection>());

                var sendTcs = new TaskCompletionSource <object>();
                connectionToTransport.Writer.TryWrite(new SendMessage(new byte[] { 0x42 }, sendTcs));
                try
                {
                    await sendTcs.Task;
                }
                catch (OperationCanceledException)
                {
                    // Because the server and client are run in the same process there is a race where websocket.SendAsync
                    // can send a message but before returning be suspended allowing the server to run the EchoEndpoint and
                    // send a close frame which triggers a cancellation token on the client and cancels the websocket.SendAsync.
                    // Our solution to this is to just catch OperationCanceledException from the sent message if the race happens
                    // because we know the send went through, and its safe to check the response.
                }

                // The echo endpoint closes the connection immediately after sending response which should stop the transport
                await webSocketsTransport.Running.OrTimeout();

                Assert.True(transportToConnection.Reader.TryRead(out var buffer));
                Assert.Equal(new byte[] { 0x42 }, buffer);
            }
        }
コード例 #3
0
        public async Task SSETransportStopsIfTheServerClosesTheStream()
        {
            var mockHttpHandler = new Mock <HttpMessageHandler>();

            mockHttpHandler.Protected()
            .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
            .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
            {
                await Task.Yield();
                return(new HttpResponseMessage {
                    Content = new StringContent("data: 3:abc\r\n\r\n")
                });
            });

            using (var httpClient = new HttpClient(mockHttpHandler.Object))
            {
                var sseTransport = new ServerSentEventsTransport(httpClient);

                var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
                var transportToConnection = Channel.CreateUnbounded <byte[]>();
                var channelConnection     = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
                await sseTransport.StartAsync(
                    new Uri("http://fakeuri.org"), channelConnection, TransferMode.Text, connectionId : string.Empty).OrTimeout();

                var message = await transportToConnection.Reader.ReadAsync().AsTask().OrTimeout();

                Assert.Equal("3:abc", Encoding.ASCII.GetString(message));

                await sseTransport.Running.OrTimeout();
            }
        }
コード例 #4
0
        public void EstablishContext()
        {
            using (var startEvent = new ManualResetEvent(false))
            {
                _srv = new TestService();

                _channelAdaptor = new ChannelAdapter();
                _hostChannel = WellknownAddresses.GetHostHost(_channelAdaptor);

                _connection = _channelAdaptor.Connect(config => config.AddConsumerOf<ServiceStarted>().UsingConsumer(msg => startEvent.Set()));

                ServiceConfigurator<TestService> c = new ServiceConfigurator<TestService>();
                c.WhenStarted(s => s.Start());
                c.WhenStopped(s => s.Stop());
                c.WhenPaused(s => { _wasPaused = true; });
                c.WhenContinued(s => { _wasContinued = true; });
                c.HowToBuildService(name => _srv);

                _serviceController = c.Create();
                _serviceController.Start();

                startEvent.WaitOne(5.Seconds());

                _serviceController.State.ShouldEqual(ServiceState.Started);
            }
        }
コード例 #5
0
        void CreateCoordinatorChannel()
        {
            if (_channel != null)
            {
                return;
            }

            _channel           = new ChannelAdapter();
            _channelConnection = _channel.Connect(x =>
            {
                x.AddConsumerOf <ServiceEvent>()
                .UsingConsumer(OnServiceEvent)
                .HandleOnFiber(_fiber);

                x.AddConsumerOf <ServiceFault>()
                .UsingConsumer(OnServiceFault)
                .HandleOnFiber(_fiber);

                x.AddConsumerOf <ServiceStopped>()
                .UsingConsumer(OnServiceStopped)
                .HandleOnFiber(_fiber);

                x.AddConsumerOf <CreateShelfService>()
                .UsingConsumer(OnCreateShelfService)
                .HandleOnFiber(_fiber);

                x.AddConsumerOf <ServiceFolderChanged>()
                .UsingConsumer(OnServiceFolderChanged)
                .HandleOnFiber(_fiber);

                x.AddConsumerOf <Request <ServiceStatus> >()
                .UsingConsumer(Status)
                .HandleOnFiber(_fiber);
            });
        }
コード例 #6
0
ファイル: RequestWcf_Specs.cs プロジェクト: rickj33/Stact
        public void A_request_is_sent_via_wcf()
        {
            _pipeUri = new Uri("net.pipe://localhost/pipe");

            _response = new Future<Response<TestMessage>>();

            _client = new ChannelAdapter();
            _clientConnection = _client.Connect(x =>
                {
                    x.SendToWcfChannel(_pipeUri, _pipeName)
                        .HandleOnCallingThread();

                    x.AddConsumerOf<Response<TestMessage>>()
                        .UsingConsumer(_response.Complete);
                });

            _server = new ChannelAdapter();
            _serverConnection = _server.Connect(x =>
                {
                    x.ReceiveFromWcfChannel(_pipeUri, _pipeName);

                    x.AddConsumerOf<Request<TestMessage>>()
                        .UsingConsumer(request => request.Respond(request.Body));
                });
        }
コード例 #7
0
        private CommandResult HandleSkillPoints(ChannelConnection conn, Character sender, Character target, string command, string[] args)
        {
            if (args.Length < 3)
            {
                return(CommandResult.InvalidArgument);
            }

            if (!int.TryParse(args[1], out var iJobId))
            {
                return(CommandResult.InvalidArgument);
            }

            if (!int.TryParse(args[2], out var modifier))
            {
                return(CommandResult.InvalidArgument);
            }

            var jobId = (JobId)iJobId;

            if (!target.Jobs.ModifySkillPoints(jobId, modifier))
            {
                sender.ServerMessage("The job doesn't exist.");
                return(CommandResult.Okay);
            }

            sender.ServerMessage("Modified {0}'s skill points by {1:+0;-0;0}.", jobId, modifier);

            return(CommandResult.Okay);
        }
コード例 #8
0
        /// <summary>
        /// Creates a PollingFileSystemEventProducer
        /// </summary>		
        /// <param name="directory">The directory to watch</param>
        /// <param name="channel">The channel where events should be sent</param>
        /// <param name="scheduler">Event scheduler</param>
        /// <param name="fiber">Fiber to schedule on</param>
        /// <param name="checkInterval">The maximal time between events or polls on a given file</param>
        /// <param name="checkSubDirectory">Indicates if subdirectorys will be checked or ignored</param>
        public PollingFileSystemEventProducer(string directory, UntypedChannel channel, [NotNull] Scheduler scheduler, Fiber fiber, TimeSpan checkInterval, bool checkSubDirectory)
        {
            if (scheduler == null)
                throw new ArgumentNullException("scheduler");

            _directory = directory;
            _channel = channel;
            _fiber = fiber;
            _hashes = new Dictionary<string, Guid>();
            _scheduler = scheduler;
            _checkInterval = checkInterval;

            _scheduledAction = scheduler.Schedule(3.Seconds(), _fiber, HashFileSystem);

            var myChannel = new ChannelAdapter();

            _connection = myChannel.Connect(connectionConfigurator =>
            {
                connectionConfigurator.AddConsumerOf<FileSystemChanged>().UsingConsumer(HandleFileSystemChangedAndCreated);
                connectionConfigurator.AddConsumerOf<FileSystemCreated>().UsingConsumer(HandleFileSystemChangedAndCreated);
                connectionConfigurator.AddConsumerOf<FileSystemRenamed>().UsingConsumer(HandleFileSystemRenamed);
                connectionConfigurator.AddConsumerOf<FileSystemDeleted>().UsingConsumer(HandleFileSystemDeleted);
            });

            _fileSystemEventProducer = new FileSystemEventProducer(directory, myChannel, checkSubDirectory);
        }
コード例 #9
0
        void Dispose(bool disposing)
        {
            if (_disposed)
            {
                return;
            }
            if (disposing)
            {
                if (_channelConnection != null)
                {
                    _log.DebugFormat("[Topshelf] Closing coordinator channel");
                    _channelConnection.Dispose();
                    _channelConnection = null;
                }

                if (_updated != null && _updated.Implements <IDisposable>())
                {
                    var disp = (IDisposable)_updated;
                    disp.Dispose();
                }

                _channel = null;
            }

            _disposed = true;
        }
コード例 #10
0
        public void Starting_a_socket_server()
        {
            TraceLogger.Configure(LogLevel.Debug);

            _startingEventReceived = new Future <ServerStarting>();
            _runningEventReceived  = new Future <ServerRunning>();

            _input      = new ChannelAdapter();
            _connection = _input.Connect(x =>
            {
                x.AddConsumerOf <ServerStarting>()
                .UsingConsumer(_startingEventReceived.Complete)
                .HandleOnCallingThread();

                x.AddConsumerOf <ServerRunning>()
                .UsingConsumer(_runningEventReceived.Complete)
                .HandleOnCallingThread();
            });

            ServerUri = new Uri("http://localhost:8008/Topshelf");
            _server   = new HttpServer(ServerUri, new ThreadPoolFiber(), _input, new[]
            {
                new VersionConnectionHandler(),
            });
            _server.Start();
        }
コード例 #11
0
ファイル: GmCommands.cs プロジェクト: b1glord/melia
        private CommandResult HandleSpawn(ChannelConnection conn, Character character, Character target, string command, string[] args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.InvalidArgument);
            }

            int id;

            if (!int.TryParse(args[1], out id))
            {
                return(CommandResult.InvalidArgument);
            }

            var monsterData = ChannelServer.Instance.Data.MonsterDb.Find(id);

            if (monsterData == null)
            {
                this.SystemMessage(character, "Monster not found.");
                return(CommandResult.Okay);
            }

            var monster = new Monster(id, NpcType.Monster);

            monster.Position  = target.Position;
            monster.Direction = target.Direction;

            target.Map.AddMonster(monster);

            return(CommandResult.Okay);
        }
コード例 #12
0
        void OnServiceFolderRemoved(ServiceFolderRemoved message)
        {
            _log.InfoFormat("[Topshelf] Folder Removed: {0}", message.ServiceName);

            if (_actorCache.Has(message.ServiceName))
            {
                var actor = _actorCache[message.ServiceName];

                _actorCache.Remove(message.ServiceName);
                _serviceCache.Remove(message.ServiceName);

                ChannelConnection connection = null;
                connection = _channel.Connect(x =>
                {
                    x.AddConsumerOf <ServiceStopped>()
                    .Where(m => m.ServiceName == message.ServiceName)
                    .UsingConsumer(_ =>
                    {
                        actor.Send(new UnloadService(message.ServiceName));
                    });

                    x.AddConsumerOf <ServiceUnloaded>()
                    .Where(m => m.ServiceName == message.ServiceName)
                    .UsingConsumer(_ =>
                    {
                        // actor.Exit(); why timeout?
                        connection.Dispose();
                    });
                });

                actor.Send(new StopService(message.ServiceName));
            }
        }
コード例 #13
0
        public async Task SSETransportThrowsForInvalidTransferMode()
        {
            var mockHttpHandler = new Mock <HttpMessageHandler>();

            mockHttpHandler.Protected()
            .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
            .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
            {
                await Task.Yield();
                return(new HttpResponseMessage {
                    Content = new StringContent(string.Empty)
                });
            });

            using (var httpClient = new HttpClient(mockHttpHandler.Object))
            {
                var sseTransport          = new ServerSentEventsTransport(httpClient);
                var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
                var transportToConnection = Channel.CreateUnbounded <byte[]>();
                var channelConnection     = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
                var exception             = await Assert.ThrowsAsync <ArgumentException>(() =>
                                                                                         sseTransport.StartAsync(new Uri("http://fakeuri.org"), null, TransferMode.Text | TransferMode.Binary, connectionId: string.Empty));

                Assert.Contains("Invalid transfer mode.", exception.Message);
                Assert.Equal("requestedTransferMode", exception.ParamName);
            }
        }
コード例 #14
0
        public async Task SSETransportStopsSendAndReceiveLoopsWhenTransportStopped()
        {
            var eventStreamCts  = new CancellationTokenSource();
            var mockHttpHandler = new Mock <HttpMessageHandler>();

            mockHttpHandler.Protected()
            .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
            .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
            {
                await Task.Yield();

                var mockStream = new Mock <Stream>();
                mockStream
                .Setup(s => s.CopyToAsync(It.IsAny <Stream>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
                .Returns <Stream, int, CancellationToken>(async(stream, bufferSize, t) =>
                {
                    await Task.Yield();
                    var buffer = Encoding.ASCII.GetBytes("data: 3:abc\r\n\r\n");
                    while (!eventStreamCts.IsCancellationRequested)
                    {
                        await stream.WriteAsync(buffer, 0, buffer.Length);
                    }
                });
                mockStream.Setup(s => s.CanRead).Returns(true);

                return(new HttpResponseMessage {
                    Content = new StreamContent(mockStream.Object)
                });
            });

            Task transportActiveTask;

            using (var httpClient = new HttpClient(mockHttpHandler.Object))
            {
                var sseTransport = new ServerSentEventsTransport(httpClient);

                try
                {
                    var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
                    var transportToConnection = Channel.CreateUnbounded <byte[]>();
                    var channelConnection     = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
                    await sseTransport.StartAsync(
                        new Uri("http://fakeuri.org"), channelConnection, TransferMode.Text, connectionId : string.Empty).OrTimeout();

                    transportActiveTask = sseTransport.Running;
                    Assert.False(transportActiveTask.IsCompleted);
                    var message = await transportToConnection.Reader.ReadAsync().AsTask().OrTimeout();

                    Assert.Equal("3:abc", Encoding.ASCII.GetString(message));
                }
                finally
                {
                    await sseTransport.StopAsync().OrTimeout();
                }

                await transportActiveTask.OrTimeout();

                eventStreamCts.Cancel();
            }
        }
コード例 #15
0
ファイル: HttpConnection.cs プロジェクト: irongoose/SignalR
        private async Task StartTransport(Uri connectUrl)
        {
            var applicationToTransport = Channel.CreateUnbounded<SendMessage>();
            var transportToApplication = Channel.CreateUnbounded<byte[]>();
            var applicationSide = ChannelConnection.Create(applicationToTransport, transportToApplication);
            _transportChannel = ChannelConnection.Create(transportToApplication, applicationToTransport);

            // Start the transport, giving it one end of the pipeline
            try
            {
                await _transport.StartAsync(connectUrl, applicationSide, GetTransferMode(), this);

                // actual transfer mode can differ from the one that was requested so set it on the feature
                if (!_transport.Mode.HasValue)
                {
                    // This can happen with custom transports so it should be an exception, not an assert.
                    throw new InvalidOperationException("Transport was expected to set the Mode property after StartAsync, but it has not been set.");
                }
                SetTransferMode(_transport.Mode.Value);
            }
            catch (Exception ex)
            {
                _logger.ErrorStartingTransport(_transport, ex);
                throw;
            }
        }
コード例 #16
0
        public async Task LongPollingTransportSetsTransferMode(TransferMode transferMode)
        {
            var mockHttpHandler = new Mock <HttpMessageHandler>();

            mockHttpHandler.Protected()
            .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
            .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
            {
                await Task.Yield();
                return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
            });

            using (var httpClient = new HttpClient(mockHttpHandler.Object))
            {
                var longPollingTransport = new LongPollingTransport(httpClient);

                try
                {
                    var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
                    var transportToConnection = Channel.CreateUnbounded <byte[]>();
                    var channelConnection     = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);

                    Assert.Null(longPollingTransport.Mode);
                    await longPollingTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, transferMode, connectionId : string.Empty, connection : new TestConnection());

                    Assert.Equal(transferMode, longPollingTransport.Mode);
                }
                finally
                {
                    await longPollingTransport.StopAsync();
                }
            }
        }
コード例 #17
0
        public async Task TransportClosesOnCloseTimeoutIfClientDoesNotSendCloseFrame()
        {
            var transportToApplication = Channel.CreateUnbounded <byte[]>();
            var applicationToTransport = Channel.CreateUnbounded <byte[]>();

            using (var transportSide = ChannelConnection.Create <byte[]>(applicationToTransport, transportToApplication))
                using (var applicationSide = ChannelConnection.Create <byte[]>(transportToApplication, applicationToTransport))
                    using (var feature = new TestWebSocketConnectionFeature())
                    {
                        var options = new WebSocketOptions()
                        {
                            CloseTimeout = TimeSpan.FromSeconds(1)
                        };

                        var connectionContext = new DefaultConnectionContext(string.Empty, null, null);
                        var ws = new WebSocketsTransport(options, transportSide, connectionContext, loggerFactory: new LoggerFactory());

                        var serverSocket = await feature.AcceptAsync();

                        // Give the server socket to the transport and run it
                        var transport = ws.ProcessSocketAsync(serverSocket);

                        // End the app
                        applicationSide.Dispose();

                        await transport.OrTimeout(TimeSpan.FromSeconds(10));

                        // Now we're closed
                        Assert.Equal(WebSocketState.Aborted, serverSocket.State);

                        serverSocket.Dispose();
                    }
        }
コード例 #18
0
        private CommandResult HandleRecallAll(ChannelConnection conn, Character sender, Character target, string command, string[] args)
        {
            if (args.Length > 1)
            {
                return(CommandResult.InvalidArgument);
            }

            // TODO: Once we have support for channels and map servers,
            //   add warp from other servers and restrict recall to
            //   channel's max player count.

            // Check characters
            var characters = ChannelServer.Instance.World.GetCharacters(a => a != target);

            if (!characters.Any())
            {
                sender.ServerMessage("No players found.");
                return(CommandResult.Okay);
            }

            // Recall each player to current location.
            foreach (var character in characters)
            {
                var location = target.GetLocation();
                character.Warp(location);

                character.ServerMessage("You've been warped to {0}.", location);
            }

            sender.ServerMessage("You have called {0} characters to target location.", characters.Length);

            return(CommandResult.Okay);
        }
コード例 #19
0
        public async Task TransportFailsOnTimeoutWithErrorWhenApplicationFailsAndClientDoesNotSendCloseFrame()
        {
            var transportToApplication = Channel.CreateUnbounded <byte[]>();
            var applicationToTransport = Channel.CreateUnbounded <byte[]>();

            using (var transportSide = ChannelConnection.Create <byte[]>(applicationToTransport, transportToApplication))
                using (var applicationSide = ChannelConnection.Create <byte[]>(transportToApplication, applicationToTransport))
                    using (var feature = new TestWebSocketConnectionFeature())
                    {
                        var options = new WebSocketOptions
                        {
                            CloseTimeout = TimeSpan.FromSeconds(1)
                        };

                        var connectionContext = new DefaultConnectionContext(string.Empty, null, null);
                        var ws = new WebSocketsTransport(options, transportSide, connectionContext, loggerFactory: new LoggerFactory());

                        var serverSocket = await feature.AcceptAsync();

                        // Give the server socket to the transport and run it
                        var transport = ws.ProcessSocketAsync(serverSocket);

                        // Run the client socket
                        var client = feature.Client.ExecuteAndCaptureFramesAsync();

                        // fail the client to server channel
                        applicationToTransport.Out.TryComplete(new Exception());

                        await Assert.ThrowsAsync <Exception>(() => transport).OrTimeout();

                        Assert.Equal(WebSocketState.Aborted, serverSocket.State);
                    }
        }
コード例 #20
0
        private CommandResult HandleBuyAbilPoint(ChannelConnection conn, Character sender, Character target, string command, string[] args)
        {
            // Since this command is sent via UI interactions, we'll not
            // use any automated command result messages, but we'll leave
            // debug messages for now, in case of unexpected values.

            if (args.Length < 0)
            {
                Log.Debug("HandleBuyAbilPoint: No amount given by user '{0}'.", conn.Account.Name);
                return(CommandResult.Okay);
            }

            if (!int.TryParse(args[1], out var amount))
            {
                Log.Debug("HandleBuyAbilPoint: Invalid amount '{0}' by user '{1}'.", amount, conn.Account.Name);
                return(CommandResult.Okay);
            }

            var cost   = (amount * 1000);
            var silver = sender.Inventory.CountItem(ItemId.Silver);

            if (silver < cost)
            {
                Log.Debug("HandleBuyAbilPoint: User '{0}' didn't have enough money.", conn.Account.Name);
                return(CommandResult.Okay);
            }

            sender.Inventory.Remove(ItemId.Silver, cost, InventoryItemRemoveMsg.Given);
            sender.ModifyAbilityPoints(amount);
            Send.ZC_ADDON_MSG(sender, "SUCCESS_BUY_ABILITY_POINTBLANK");

            return(CommandResult.Okay);
        }
コード例 #21
0
ファイル: WebSocketsTests.cs プロジェクト: tommyja/SignalR
        public async Task ClientReceivesInternalServerErrorWhenTheApplicationFails()
        {
            using (StartLog(out var loggerFactory))
            {
                var transportToApplication = Channel.CreateUnbounded <byte[]>();
                var applicationToTransport = Channel.CreateUnbounded <byte[]>();

                using (var transportSide = ChannelConnection.Create <byte[]>(applicationToTransport, transportToApplication))
                    using (var applicationSide = ChannelConnection.Create <byte[]>(transportToApplication, applicationToTransport))
                        using (var feature = new TestWebSocketConnectionFeature())
                        {
                            var connectionContext = new DefaultConnectionContext(string.Empty, null, null);
                            var ws = new WebSocketsTransport(new WebSocketOptions(), transportSide, connectionContext, loggerFactory);

                            // Give the server socket to the transport and run it
                            var transport = ws.ProcessSocketAsync(await feature.AcceptAsync());

                            // Run the client socket
                            var client = feature.Client.ExecuteAndCaptureFramesAsync();

                            // Fail in the app
                            Assert.True(applicationSide.Writer.TryComplete(new InvalidOperationException("Catastrophic failure.")));
                            var clientSummary = await client.OrTimeout();

                            Assert.Equal(WebSocketCloseStatus.InternalServerError, clientSummary.CloseResult.CloseStatus);

                            // Close from the client
                            await feature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);

                            var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => transport.OrTimeout());

                            Assert.Equal("Catastrophic failure.", ex.Message);
                        }
            }
        }
コード例 #22
0
        private CommandResult HandleStatPoints(ChannelConnection conn, Character sender, Character target, string command, string[] args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.InvalidArgument);
            }

            if (!int.TryParse(args[1], out var amount) || amount < 1)
            {
                return(CommandResult.InvalidArgument);
            }

            // Modification for stat points is a little tricky, because ToS
            // has 3 stat points properties:
            // - Stat points gained by leveling
            // - Stat points gained in another way
            // - Used stat points
            // When increasing stats, "Used" is increased and the others are
            // left alone. I'll make this adding-only for now, until I feel
            // like untangling modifying them.

            target.AddStatPoints(amount);

            sender.ServerMessage("Added {0} stat points.", amount);

            return(CommandResult.Okay);
        }
コード例 #23
0
ファイル: GmCommands.cs プロジェクト: rincew1nd/melia
        private CommandResult HandleJob(ChannelConnection conn, Character character, Character target, string command, string[] args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.InvalidArgument);
            }

            short jobId;

            if (!short.TryParse(args[1], out jobId))
            {
                return(CommandResult.InvalidArgument);
            }

            if (!Enum.IsDefined(typeof(Job), jobId))
            {
                this.SystemMessage(character, "Unknown job.");
                return(CommandResult.Okay);
            }

            target.Job = (Job)jobId;
            Send.ZC_PC(target, PcUpdateType.Job, (short)jobId);
            Send.ZC_UPDATED_PCAPPEARANCE(target);

            return(CommandResult.Okay);
        }
コード例 #24
0
        public TestClient(bool synchronousCallbacks = false)
        {
            var options = new ChannelOptimizations {
                AllowSynchronousContinuations = synchronousCallbacks
            };
            var transportToApplication = Channel.CreateUnbounded <byte[]>(options);
            var applicationToTransport = Channel.CreateUnbounded <byte[]>(options);

            Application = ChannelConnection.Create <byte[]>(input: applicationToTransport, output: transportToApplication);
            _transport  = ChannelConnection.Create <byte[]>(input: transportToApplication, output: applicationToTransport);

            Connection      = new DefaultConnectionContext(Guid.NewGuid().ToString(), _transport, Application);
            Connection.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, Interlocked.Increment(ref _id).ToString()) }));
            Connection.Metadata["ConnectedTask"] = new TaskCompletionSource <bool>();

            var protocol = new JsonHubProtocol(new JsonSerializer());

            _protocolReaderWriter = new HubProtocolReaderWriter(protocol, new PassThroughEncoder());

            _cts = new CancellationTokenSource();

            using (var memoryStream = new MemoryStream())
            {
                NegotiationProtocol.WriteMessage(new NegotiationMessage(protocol.Name), memoryStream);
                Application.Out.TryWrite(memoryStream.ToArray());
            }
        }
コード例 #25
0
ファイル: GmCommands.cs プロジェクト: rincew1nd/melia
        private CommandResult HandleItemInfo(ChannelConnection conn, Character sender, Character target, string command, string[] args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.InvalidArgument);
            }

            var search = command.Substring(command.IndexOf(" ")).Trim();
            var items  = ChannelServer.Instance.Data.ItemDb.FindAll(search);

            if (items.Count == 0)
            {
                this.SystemMessage(sender, "No items found for '{0}'.", search);
                return(CommandResult.Okay);
            }

            var eItems = items.OrderBy(a => a.Name.LevenshteinDistance(search)).ThenBy(a => a.Id).GetEnumerator();
            var max    = 20;

            for (int i = 0; eItems.MoveNext() && i < max; ++i)
            {
                var item = eItems.Current;
                this.SystemMessage(sender, "{0}: {1}, Category: {2}", item.Id, item.Name, item.Category);
            }

            this.SystemMessage(sender, "Results: {0} (Max. {1} shown)", items.Count, max);

            return(CommandResult.Okay);
        }
コード例 #26
0
        public async Task SSETransportSetsTransferMode(TransferMode transferMode)
        {
            var mockHttpHandler = new Mock <HttpMessageHandler>();

            mockHttpHandler.Protected()
            .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
            .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
            {
                await Task.Yield();
                return(new HttpResponseMessage {
                    Content = new StringContent(string.Empty)
                });
            });

            using (var httpClient = new HttpClient(mockHttpHandler.Object))
            {
                var sseTransport          = new ServerSentEventsTransport(httpClient);
                var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
                var transportToConnection = Channel.CreateUnbounded <byte[]>();
                var channelConnection     = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
                Assert.Null(sseTransport.Mode);
                await sseTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, transferMode, connectionId : string.Empty).OrTimeout();

                Assert.Equal(TransferMode.Text, sseTransport.Mode);
                await sseTransport.StopAsync().OrTimeout();
            }
        }
コード例 #27
0
        private CommandResult HandleName(ChannelConnection conn, Character character, Character target, string command, string[] args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.InvalidArgument);
            }

            var newName = args[1];

            if (newName == character.Name)
            {
                return(CommandResult.Okay);
            }

            // TODO: Can you rename any time, without cooldown?

            // TODO: Keep a list of all account characters after all?
            if (ChannelServer.Instance.Database.CharacterExists(conn.Account.Id, newName))
            {
                character.ServerMessage("Name already exists.");
                return(CommandResult.Okay);
            }

            target.Name = newName;
            Send.ZC_PC(target, PcUpdateType.Name, newName);

            return(CommandResult.Okay);
        }
コード例 #28
0
ファイル: RequestWcf_Specs.cs プロジェクト: yonglehou/Stact
        public void A_request_is_sent_via_wcf()
        {
            _pipeUri = new Uri("net.pipe://localhost/pipe");

            _response = new Future <Response <TestMessage> >();

            _client           = new ChannelAdapter();
            _clientConnection = _client.Connect(x =>
            {
                x.SendToWcfChannel(_pipeUri, _pipeName)
                .HandleOnCallingThread();

                x.AddConsumerOf <Response <TestMessage> >()
                .UsingConsumer(_response.Complete);
            });

            _server           = new ChannelAdapter();
            _serverConnection = _server.Connect(x =>
            {
                x.AddConsumerOf <Request <TestMessage> >()
                .UsingConsumer(request => request.Respond(request.Body));
            });

            _host = new WcfChannelHost(new PoolFiber(), _server, _pipeUri, _pipeName);
        }
コード例 #29
0
        private CommandResult HandleMonsterInfo(ChannelConnection conn, Character sender, Character target, string command, string[] args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.InvalidArgument);
            }

            var search   = command.Substring(command.IndexOf(" ")).Trim();
            var monsters = ChannelServer.Instance.Data.MonsterDb.FindAll(search);

            if (monsters.Count == 0)
            {
                sender.ServerMessage("No monsters found for '{0}'.", search);
                return(CommandResult.Okay);
            }

            var entries = monsters.OrderBy(a => a.Name.LevenshteinDistance(search)).ThenBy(a => a.Id).GetEnumerator();
            var max     = 20;

            for (var i = 0; entries.MoveNext() && i < max; ++i)
            {
                var current = entries.Current;
                sender.ServerMessage("{0}: {1}", current.Id, current.Name);
            }

            sender.ServerMessage("Results: {0} (Max. {1} shown)", monsters.Count, max);

            return(CommandResult.Okay);
        }
コード例 #30
0
        public async Task LongPollingTransportStopsWhenPollReceives204()
        {
            var mockHttpHandler = new Mock <HttpMessageHandler>();

            mockHttpHandler.Protected()
            .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
            .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
            {
                await Task.Yield();
                return(ResponseUtils.CreateResponse(HttpStatusCode.NoContent));
            });

            using (var httpClient = new HttpClient(mockHttpHandler.Object))
            {
                var longPollingTransport = new LongPollingTransport(httpClient);
                try
                {
                    var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
                    var transportToConnection = Channel.CreateUnbounded <byte[]>();
                    var channelConnection     = ChannelConnection.Create(connectionToTransport, transportToConnection);
                    await longPollingTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, TransferMode.Binary, connectionId : string.Empty, connection : new TestConnection());

                    await longPollingTransport.Running.OrTimeout();

                    Assert.True(transportToConnection.Reader.Completion.IsCompleted);
                }
                finally
                {
                    await longPollingTransport.StopAsync();
                }
            }
        }
コード例 #31
0
        private CommandResult HandleRecall(ChannelConnection conn, Character sender, Character target, string command, string[] args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.InvalidArgument);
            }

            // TODO: Once we have support for more than one map server,
            //   we have to search for characters across all of them.

            var teamName  = args[1];
            var character = ChannelServer.Instance.World.GetCharacterByTeamName(teamName);

            if (character == null)
            {
                sender.ServerMessage("Character not found.");
                return(CommandResult.Okay);
            }

            var location = target.GetLocation();

            character.Warp(location);

            character.ServerMessage("You've been warped to {0}.", location);

            return(CommandResult.Okay);
        }
コード例 #32
0
        public async Task LongPollingTransportStopsWhenPollRequestFails()
        {
            var mockHttpHandler = new Mock <HttpMessageHandler>();

            mockHttpHandler.Protected()
            .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
            .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
            {
                await Task.Yield();
                return(ResponseUtils.CreateResponse(HttpStatusCode.InternalServerError));
            });

            using (var httpClient = new HttpClient(mockHttpHandler.Object))
            {
                var longPollingTransport = new LongPollingTransport(httpClient);
                try
                {
                    var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
                    var transportToConnection = Channel.CreateUnbounded <byte[]>();
                    var channelConnection     = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
                    await longPollingTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, TransferMode.Binary, connectionId : string.Empty);

                    var exception =
                        await Assert.ThrowsAsync <HttpRequestException>(async() => await transportToConnection.Reader.Completion.OrTimeout());

                    Assert.Contains(" 500 ", exception.Message);
                }
                finally
                {
                    await longPollingTransport.StopAsync();
                }
            }
        }
コード例 #33
0
        private CommandResult HandleReqUpdateEquip(ChannelConnection conn, Character sender, Character target, string command, string[] args)
        {
            // Command is sent when the inventory is opened, purpose unknown,
            // officials don't seem to send anything back.

            return(CommandResult.Okay);
        }
コード例 #34
0
		public void Run()
		{
			Stopwatch timer = Stopwatch.StartNew();

			const int channelCount = 10000;
			const int seedCount = 500;

			var channels = new UntypedChannel[channelCount];
			var connections = new ChannelConnection[channelCount];

			var complete = new Future<int>();

			var latch = new CountdownLatch(channelCount*seedCount, complete.Complete);

			for (int i = 0; i < channelCount; i++)
			{
				int channelNumber = i;
				channels[i] = new ChannelAdapter();
				connections[i] = channels[i].Connect(x =>
					{
						x.AddConsumerOf<AMessage>()
							.UsingConsumer(message =>
								{
									if (channelNumber < channels.Length - 1)
										channels[channelNumber + 1].Send(message);

									latch.CountDown();
								});
					});
			}

			var body = new AMessage();

			for (int i = 0; i < seedCount; i++)
			{
				channels[i].Send(body);

				for (int j = 0; j < i; j++)
					latch.CountDown();
			}

			bool completed = complete.WaitUntilCompleted(2.Minutes());

			timer.Stop();

			connections.Each(x => x.Dispose());
			

			if (!completed)
			{
				Console.WriteLine("Process did not complete");
				return;
			}

			Console.WriteLine("Processed {0} messages in with {1} channels in {2}ms", seedCount, channelCount,
			                  timer.ElapsedMilliseconds);

			Console.WriteLine("That's {0} messages per second!", ((long)seedCount*channelCount*1000)/timer.ElapsedMilliseconds);
		}
コード例 #35
0
ファイル: Audit_Specs.cs プロジェクト: Nangal/Stact
		public void Close_connection()
		{
			if (_connection != null)
			{
				_connection.Dispose();
				_connection = null;
			}
		}
コード例 #36
0
ファイル: HostHost.cs プロジェクト: ramonsmits/Topshelf
 public HostHost(UntypedChannel inputChannel, Uri address, string endpoint)
 {
     _input = inputChannel;
     _inputConnection = _input.Connect(x =>
         {
             x.ReceiveFromWcfChannel(address, endpoint)
                 .HandleOnCallingThread();
         });
 }
コード例 #37
0
        public void After()
        {
            _inputConnection.Dispose();
            _inputConnection = null;
            _input = null;

            _outputConnection.Dispose();
            _outputConnection = null;
            _output = null;
        }
コード例 #38
0
ファイル: RequestWcf_Specs.cs プロジェクト: rickj33/Stact
        public void After()
        {
            _clientConnection.Dispose();
            _clientConnection = null;
            _client = null;

            _serverConnection.Dispose();
            _serverConnection = null;
            _server = null;
        }
コード例 #39
0
ファイル: Auction_Specs.cs プロジェクト: Nangal/Stact
		public void A_message_is_sent_to_an_instance()
		{
			_auctionId = CombGuid.Generate();

			_input = new ChannelAdapter();
			_connection = _input.Connect(x =>
			{
				x.AddConsumerOf<Bid>()
					.UsingInstance().Of<Auction>()
					.ObtainedBy(m => new Auction(m.AuctionId))
					.OnChannel(auction => auction.BidChannel);
			});
		}
コード例 #40
0
ファイル: DirectoryMonitor.cs プロジェクト: raelyard/Topshelf
        public void Start()
        {
            // file system watcher will fail if directory isn't there, ensure it is
            if (!Directory.Exists(_baseDirectory))
                Directory.CreateDirectory(_baseDirectory);

            _scheduler = new TimerScheduler(new PoolFiber());
            _channel = new ChannelAdapter();

            _producer = new PollingFileSystemEventProducer(_baseDirectory, _channel, _scheduler, new PoolFiber(),
                                                           10.Minutes());

            _connection = _channel.Connect(x =>
                {
                    x.AddConsumerOf<FileSystemEvent>()
                        .UsingConsumer(msg => ScheduleFolderChangeNotification(GetChangedDirectory(msg.Path)))
                        .HandleOnFiber(_fiber);
                });
        }
コード例 #41
0
		public void Start()
		{
			_eventConnection = _eventChannel.Connect(x =>
				{
					x.AddConsumerOf<ReceiveCompleted>()
						.UsingConsumer(Handle)
						.HandleOnCallingThread();

					x.AddConsumerOf<ConsumeCompleted>()
						.UsingConsumer(Handle)
						.HandleOnCallingThread();
				});

			_enabled = true;

			if (_log.IsDebugEnabled)
				_log.DebugFormat("Starting Consumer Pool for {0}", _bus.Endpoint.Address.Uri);

			QueueReceiver();
		}
コード例 #42
0
ファイル: Audit_Specs.cs プロジェクト: Nangal/Stact
		public void Configuring_event_listeners_for_nhibernate()
		{
			using (ISession session = SessionFactory.OpenSession())
			using (ITransaction transaction = session.BeginTransaction())
			{
				session.CreateQuery("Delete TestInstance").ExecuteUpdate();
				session.CreateQuery("Delete TestInstanceAudit").ExecuteUpdate();

				transaction.Commit();
			}

			_channel = new ChannelAdapter();
			_connection = _channel.Connect(x =>
				{
					x.AddConsumersFor<TestInstanceAudit>()
						.BindUsing<TestInstanceAuditBinding, AuditKey>()
						.HandleOnCallingThread()
						.CreateNewInstanceBy(id => new TestInstanceAudit(id))
						.PersistUsingNHibernate()
						.UseSessionProvider(() => SessionFactory.OpenSession());
				});

			ResetSessionFactory();
			ExtraConfiguration = cfg => { cfg.AddAuditEventListeners(_channel); };

			using (ISession session = SessionFactory.OpenSession())
			using (ITransaction transaction = session.BeginTransaction())
			{
				session.CreateQuery("Delete TestInstance").ExecuteUpdate();

				var instance = new TestInstance(27, 123.45m);
				session.Save(instance);
				instance = new TestInstance(37, 123.45m);
				session.Save(instance);
				instance = new TestInstance(47, 123.45m);
				session.Save(instance);

				transaction.Commit();
			}
		}
コード例 #43
0
ファイル: SocketServer_Specs.cs プロジェクト: Nangal/Stact
		public void Starting_a_socket_server()
		{
			_startingEventReceived = new Future<ServerStarting>();
			_runningEventReceived = new Future<ServerRunning>();

			_input = new ChannelAdapter();
			_connection = _input.Connect(x =>
			{
				x.AddConsumerOf<ServerStarting>()
					.UsingConsumer(_startingEventReceived.Complete)
					.HandleOnCallingThread();

				x.AddConsumerOf<ServerRunning>()
					.UsingConsumer(_runningEventReceived.Complete)
					.HandleOnCallingThread();
			});

			_uri = new Uri("tcp://0.0.0.0:8008");

			_server = new SocketServer(_uri, _input);
			_server.Start();
		}
コード例 #44
0
        public void Connecting_two_services_through_a_wcf_proxy_and_host()
        {
            _pipeUri = new Uri("net.pipe://localhost/pipe");

            _consumer = new Future<TestMessage>();

            _input = new ChannelAdapter();
            _inputConnection = _input.Connect(x =>
                {
                    x.ReceiveFromWcfChannel(_pipeUri, _pipeName);

                    x.AddConsumerOf<TestMessage>()
                        .UsingConsumer(_consumer.Complete);
                });

            _output = new ChannelAdapter();
            _outputConnection = _output.Connect(x =>
                {
                    x.SendToWcfChannel(_pipeUri, _pipeName)
                        .HandleOnCallingThread();
                });
        }
コード例 #45
0
ファイル: HttpServer_Specs.cs プロジェクト: Nangal/Stact
		public void Starting_a_socket_server()
		{
			_startingEventReceived = new Future<ServerStarting>();
			_runningEventReceived = new Future<ServerRunning>();

			_input = new ChannelAdapter();
			_connection = _input.Connect(x =>
				{
					x.AddConsumerOf<ServerStarting>()
						.UsingConsumer(_startingEventReceived.Complete)
						.HandleOnCallingThread();

					x.AddConsumerOf<ServerRunning>()
						.UsingConsumer(_runningEventReceived.Complete)
						.HandleOnCallingThread();
				});

			ServerUri = new Uri("http://localhost:8008/Topshelf");
			_server = new HttpServer(ServerUri, _input, new[]
				{
					new VersionConnectionHandler(),
				});
			_server.Start();
		}
コード例 #46
0
ファイル: HttpServer.cs プロジェクト: Nangal/Stact
		void CreateChannelNetwork()
		{
			_connectionChannel = new ChannelAdapter<ConnectionContext>();
			_connectionChannelConnection = _connectionChannel.Connect(x =>
				{
					var channelProvider = new HttpConnectionChannelProvider(_connectionHandlers);
					var threadPoolChannel = new ThreadPoolChannel<ConnectionContext>(channelProvider, _concurrentConnectionLimit);

					x.AddChannel(threadPoolChannel);
				});
		}
コード例 #47
0
		void Dispose(bool disposing)
		{
			if (_disposed) return;
			if (disposing)
			{
				if (_eventConnection != null)
				{
					_eventConnection.Dispose();
					_eventConnection = null;
				}
			}

			_disposed = true;
		}
コード例 #48
0
ファイル: DirectoryMonitor.cs プロジェクト: raelyard/Topshelf
        public void Stop()
        {
            if (_producer != null)
            {
                _producer.Dispose();
                _producer = null;
            }

            _pendingNotifications.Each(x => x.Value.Cancel());

            if (_scheduler != null)
            {
                _scheduler.Stop(30.Seconds());
                _scheduler = null;
            }

            if (_connection != null)
            {
                _connection.Dispose();
                _connection = null;
            }

            _channel = null;
        }
コード例 #49
0
ファイル: DirectoryMonitor.cs プロジェクト: haf/Topshelf
        public void Start()
        {
            // file system watcher will fail if directory isn't there, ensure it is
            if (!Directory.Exists(_baseDirectory))
                Directory.CreateDirectory(_baseDirectory);

            _scheduler = new TimerScheduler(new PoolFiber());
            _channel = new ChannelAdapter();

            _producer = new PollingFileSystemEventProducer(_baseDirectory, _channel, _scheduler, new PoolFiber(),
                                                           2.Minutes());

            _connection = _channel.Connect(config =>
                {
                    config
                        .AddConsumerOf<FileSystemEvent>()
                        .BufferFor(3.Seconds())
                        .UseScheduler(_scheduler)
                        .Distinct(fsEvent => GetChangedDirectory(fsEvent.Path))
                        .UsingConsumer(fsEvents =>
                            {
                                fsEvents.Keys.Distinct().Each(key =>
                                    {
                                        if (key == _baseDirectory)
                                            return;

                                        _serviceChannel.Send(new ServiceFolderChanged(key));
                                    });
                            })
                        .HandleOnFiber(_fiber);
                });
        }
コード例 #50
0
ファイル: DirectoryMonitor.cs プロジェクト: haf/Topshelf
        public void Stop()
        {
            if (_producer != null)
            {
                _producer.Dispose();
                _producer = null;
            }

            if (_scheduler != null)
            {
                _scheduler.Stop(30.Seconds());
                _scheduler = null;
            }

            if (_connection != null)
            {
                _connection.Dispose();
                _connection = null;
            }

            _channel = null;
        }
コード例 #51
0
ファイル: Auction_Specs.cs プロジェクト: Nangal/Stact
		public void After()
		{
			_connection.Dispose();
			_connection = null;
			_input = null;
		}
コード例 #52
0
ファイル: GraphChannel_Specs.cs プロジェクト: wbinford/Magnum
        public void Setup()
        {
            _channel = new ChannelAdapter();
            _channelConnection = _channel.Connect(x =>
                {
                    x.AddConsumerOf<SomeEvent>()
                        .UsingConsumer(m => { })
                        .HandleOnCallingThread();

                    x.AddConsumerOf<AnyEvent>()
                        .UsingConsumer(m => { });

                    x.AddConsumerOf<AnyEvent>()
                        .UsingConsumer(m => { });

                    x.AddConsumerOf<SomeEvent>()
                        .UsingInstance()
                        .Of<MyConsumer>()
                        .ObtainedBy(m => new MyConsumer())
                        .OnChannel(c => c.Input);

                    x.AddConsumerOf<AnyEvent>()
                        .BufferFor(5.Minutes())
                        .Distinct(m => m.Key)
                        .UsingConsumer(ms => { })
                        .HandleOnFiber();

                    x.AddConsumerOf<AnyEvent>()
                        .Where(m => m.Key > 100)
                        .UsingConsumer(m => { })
                        .HandleOnThread();

                    x.AddConsumerOf<SomeEvent>()
                        .BufferFor(5.Minutes())
                        .Last()
                        .UsingConsumer(m => { })
                        .HandleOnFiber();
                });
        }