public static void Initialize() { try { ConcursosManager.seavItemsObject(); //Cargar los items que caen en salas TrampasManager.saveTrampasSala(); //Cargar las trampas de todas las salas LoginHandler.Start(); FlowerHandler.Start(); PocionesHandler.Start(); CasasHandler.Start(); NavigatorHandler.Start(); NoticiasHandler.Start(); BPadHandler.Start(); CatalogoHandler.Start(); ConcursosHandler.Start(); PathfindingHandler.Start(); IntercambiosHandler.Start(); InterfazHandler.Start(); IslasHandler.Start(); MiniGamesHandler.Start(); PingHandler.Start(); npcHandler.Start(); codigos_promocionales.Iniciar(); Output.WriteLine("Se han registrado " + Handlers.Count + " handlers."); listas.automatic_lists_row(); UserManager.obtenerUsuariosRegistrados(); } catch (Exception e) { Program.EditorialResponse(e); } }
public ConsoleApplication( ILogger <ConsoleApplication> logger, IOptions <AppSettings> config, IrcClient client, IrcMessageParser ircParser, TwitchCommandParser commandParser, PingHandler pingHandler, CatfactsCommand catfactCommand, IssLocationCommand iisLocationCommand, ExchangeRateCommand exchangeRateCommand, UrbanDictionaryCommand urbanDictionaryCommand, BrbCommand brbCommand, HiMarkCommand hiMarkCommand, SoundsCommand SoundsCommand, RollCommand RollCommand, TestCommand testCommand) { _logger = logger; _config = config; _client = client; _ircParser = ircParser; _commandParser = commandParser; _pingHandler = pingHandler; commandObservers.Add(testCommand); commandObservers.Add(iisLocationCommand); commandObservers.Add(exchangeRateCommand); commandObservers.Add(catfactCommand); commandObservers.Add(brbCommand); commandObservers.Add(urbanDictionaryCommand); commandObservers.Add(hiMarkCommand); commandObservers.Add(SoundsCommand); commandObservers.Add(RollCommand); }
public void AfterSixPingsItShouldUseFirstIpAddressTwiceAndTheRestOnlyOnce() { //Arrange _pingMock.Setup(pingWrapper => pingWrapper.SendPing("139.130.4.5")).Returns(CreatePingReply("139.130.4.5")); _pingMock.Setup(pingWrapper => pingWrapper.SendPing("204.15.21.255")).Returns(CreatePingReply("204.15.21.255")); _pingMock.Setup(pingWrapper => pingWrapper.SendPing("212.77.101.5")).Returns(CreatePingReply("212.77.101.5")); _pingMock.Setup(pingWrapper => pingWrapper.SendPing("178.33.51.179")).Returns(CreatePingReply("178.33.51.179")); _pingMock.Setup(pingWrapper => pingWrapper.SendPing("8.8.8.8")).Returns(CreatePingReply("8.8.8.8")); PingHandler pingHandler = new PingHandler(_loggerMock.Object, _pingMock.Object, _dateTime); //Act for (int i = 0; i < 6; i++) { pingHandler.Ping(); } //Assert Assert.Multiple(() => { _loggerMock.Verify(logger => logger.Log("25.12.2020 00:00:11: Ping to: 139.130.4.5 Status: Success"), Times.Exactly(2)); _loggerMock.Verify(logger => logger.Log("25.12.2020 00:00:11: Ping to: 204.15.21.255 Status: Success"), Times.Exactly(1)); _loggerMock.Verify(logger => logger.Log("25.12.2020 00:00:11: Ping to: 212.77.101.5 Status: Success"), Times.Exactly(1)); _loggerMock.Verify(logger => logger.Log("25.12.2020 00:00:11: Ping to: 178.33.51.179 Status: Success"), Times.Exactly(1)); _loggerMock.Verify(logger => logger.Log("25.12.2020 00:00:11: Ping to: 8.8.8.8 Status: Success"), Times.Exactly(1)); }); }
public void TestSetup() { this.ircConfig = TestHelpers.GetTestIrcConfig(); ircConnection = new MockIrcConnection(this.ircConfig); responseReceived = null; this.uut = new PingHandler(); }
public void DoesntPingWhenThereIsActivity() { var selfData = new SelfBotData { Id = "BOTID" }; var mockState = new Mock<IBotState>(); mockState.Setup(m => m.Connected).Returns(true).Verifiable(); var mockService = new Mock<IBotServices>(); mockService.Setup(m => m.SendRawMessage(It.Is<OutputMessage>(om => om.Type == "ping"))) .Verifiable(); var handler = new PingHandler { BotState = mockState.Object, BotServices = mockService.Object, PingFrequencyMs = 200 }; var message = new PlainMessage { Type = EventType.Message, Subtype = MessageSubType.PlainMessage, Text = "<@BOTID>: pingdom" }; Thread.Sleep(250); foreach (var loop in Enumerable.Range(1, 6)) { handler.CanHandle(message); Thread.Sleep(100); } mockService.Verify(m => m.SendRawMessage(It.Is<OutputMessage>(om => om.Type == "ping")), Times.Exactly(1)); }
public void TestSetup() { this.ircConfig = TestHelpers.GetTestIrcConfig(); this.ircWriter = new Mock <IIrcWriter>(MockBehavior.Strict); this.uut = new PingHandler(); }
public void SendsPingAfterGivenTime() { var selfData = new SelfBotData { Id = "BOTID" }; var mockState = new Mock <IBotState>(); mockState.Setup(m => m.Connected).Returns(true).Verifiable(); var mockService = new Mock <IBotServices>(); mockService.Setup(m => m.SendRawMessage(It.Is <OutputMessage>(om => om.Type == "ping"))) .Verifiable(); var handler = new PingHandler { BotState = mockState.Object, BotServices = mockService.Object, PingFrequencyMs = 200 }; Thread.Sleep(500); mockService.Verify(m => m.SendRawMessage(It.Is <OutputMessage>(om => om.Type == "ping")), Times.Exactly(2)); }
public void TestPong() { var pingHandler = new PingHandler(); pingHandler.Msg(Talker, Caller, new MsgEventArgs { Command = "PING", Data = new[] { "someserver.com" } }); TalkMock.Verify(mock => mock.Post("p", "PONG :someserver.com")); }
public async Task ShouldPass() { var handler = new PingHandler(); var request = new PingRequest { Message = "Hello World" }; var response = await handler.Handle(request, CancellationToken.None); response.Message.Should().Be("Hello World"); }
public void OnClientDisconnect(IClient client) { PingHandler.Disconnect(client); RegistryEditorHandler.Disconnect(client); FileExplorerHandler.Disconnect(client); TaskManagerHandler.Disconnect(client); ConsoleHandler.Disconnect(client); ClipboardHandler.Disconnect(client); StartupManagerhandler.Disconnect(client); ConnectionsHandler.Disconnect(client); }
public async Task Should_call_abstract_handler() { IRequestHandler <Ping, Pong> handler = new PingHandler(); var response = await handler.Handle(new Ping() { Message = "Ping" }, default); response.Message.ShouldBe("Ping Pong"); }
public void LoggerShouldBeCalledOnceWithCorrectMessageWhenSendPingThrowsException() { //Arrange _pingMock.Setup(pingWrapper => pingWrapper.SendPing("139.130.4.5")).Throws(new Exception("Exception")); PingHandler pingHandler = new PingHandler(_loggerMock.Object, _pingMock.Object, _dateTime); //Act pingHandler.Ping(); //Assert _loggerMock.Verify(logger => logger.Log("25.12.2020 00:00:11: Ping to: 139.130.4.5 Unexpected exception: Exception"), Times.Once()); }
public void LoggerShouldBeCalledOnceWithCorrectMessageWhenSendPingIsCalledSuccessfully() { //Arrange _pingMock.Setup(pingWrapper => pingWrapper.SendPing("139.130.4.5")).Returns(CreatePingReply("139.130.4.5")); PingHandler pingHandler = new PingHandler(_loggerMock.Object, _pingMock.Object, _dateTime); //Act pingHandler.Ping(); //Assert _loggerMock.Verify(logger => logger.Log("25.12.2020 00:00:11: Ping to: 139.130.4.5 Status: Success"), Times.Once()); }
public void A_consumer_object_should_receive_the_message() { FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>(); PingHandler handler = new PingHandler(fm); LocalBus.Subscribe(handler); int old = PingHandler.Pinged; RemoteBus.Publish(new PingMessage()); fm.IsAvailable(1.Seconds()); Assert.That(PingHandler.Pinged, Is.GreaterThan(old)); }
public void CanHandlePongMessages() { var selfData = new SelfBotData { Id = "BOTID" }; var message = new Pong { Type = EventType.Pong }; var handler = new PingHandler(); var result = handler.CanHandle(message); Assert.True(result); }
public async Task Should_Call_Abstract_Handler() { // Arrange IRequestHandler <Ping, Pong> requestHandler = new PingHandler(); var expected = "Ping Pong"; // Act var response = await requestHandler.Handle(new Ping() { Message = "Ping" }, default(CancellationToken)); // Assert Assert.AreEqual(expected, response.Message); }
public async Task Should_call_abstract_unit_handler() { var builder = new StringBuilder(); var writer = new StringWriter(builder); IRequestHandler <Ping, Unit> handler = new PingHandler(writer); await handler.Handle(new Ping() { Message = "Ping" }, default); var result = builder.ToString(); result.ShouldContain("Ping Pong"); }
public void A_consumer_type_should_be_created_to_receive_the_message() { FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>(); PingHandler ph = new PingHandler(fm); ObjectBuilder.Stub(x => x.GetInstance <PingHandler>()).Return(ph); ObjectBuilder.Stub(x => x.GetInstance <PingHandler>(new Hashtable())).IgnoreArguments().Return(ph); LocalBus.Subscribe <PingHandler>(); int old = PingHandler.Pinged; RemoteBus.Publish(new PingMessage()); fm.IsAvailable(1.Seconds()); Assert.That(PingHandler.Pinged, Is.GreaterThan(old)); }
public void CanNotHandleInvalidPingMessages() { var selfData = new SelfBotData { Id = "BOTID" }; var message = new PlainMessage { Type = EventType.Message, Subtype = MessageSubType.PlainMessage, Text = "<@BOTID>: pingdom" }; var handler = new PingHandler(); var result = handler.CanHandle(message); Assert.False(result); }
public void OnDataRetrieved(IClient client, object[] data) { NetworkCommand command = (NetworkCommand)data[0]; MUIHost.Log(string.Format("Network Command: {0}", data[0]), System.Drawing.Color.Blue); if (data.Length > 1) { MUIHost.Log(string.Format("SubCommand Command: {0}", data[1]), System.Drawing.Color.Blue); } if (command == NetworkCommand.Pong) { PingHandler.EndPing(client); } if (command == NetworkCommand.RegistryEdit) { RegistryEditorHandler.Handle(client, data); } if (command == NetworkCommand.FileManager) { FileExplorerHandler.Handle(client, data); } if (command == NetworkCommand.TaskManager) { TaskManagerHandler.Handle(client, data); } if (command == NetworkCommand.Console) { ConsoleHandler.Handle(client, data); } if (command == NetworkCommand.Clipboard) { ClipboardHandler.Handle(client, data); } if (command == NetworkCommand.StartupManager) { StartupManagerhandler.Handle(client, data); } if (command == NetworkCommand.Connections) { ConnectionsHandler.Handle(client, data); } }
public void DoesntPingWhenThereIsActivity() { var selfData = new SelfBotData { Id = "BOTID" }; var mockState = new Mock <IBotState>(); mockState.Setup(m => m.Connected).Returns(true).Verifiable(); var mockService = new Mock <IBotServices>(); mockService.Setup(m => m.SendRawMessage(It.Is <OutputMessage>(om => om.Type == "ping"))) .Verifiable(); var handler = new PingHandler { BotState = mockState.Object, BotServices = mockService.Object, PingFrequencyMs = 200 }; var message = new PlainMessage { Type = EventType.Message, Subtype = MessageSubType.PlainMessage, Text = "<@BOTID>: pingdom" }; Thread.Sleep(250); foreach (var loop in Enumerable.Range(1, 6)) { handler.CanHandle(message); Thread.Sleep(100); } mockService.Verify(m => m.SendRawMessage(It.Is <OutputMessage>(om => om.Type == "ping")), Times.Exactly(1)); }
static void Main(string[] args) { //Debugger.Launch(); if (args.Length == 0) { ExitWithError("Must specify container-id as the first argument.", -1); } containerId = args[0]; hostJobObject = new JobObject(null); hostProcess = ProcessHelper.WrapProcess(Process.GetCurrentProcess()); var input = Console.In; var output = Console.Out; using (var transport = MessageTransport.Create(input, output)) { processTracker = new ProcessTracker(transport, hostJobObject, hostProcess, new ProcessHelper()); var createProcessHandler = new CreateProcessHandler(new ProcessRunner(), processTracker); var pingHandler = new PingHandler(); var findProcessByIdHandler = new FindProcessByIdHandler(processTracker); var stopProcessHandler = new StopProcessHandler(processTracker); var stopAllProcessesHandler = new StopAllProcessesHandler(processTracker); var waitForProcessExitHandler = new WaitForProcessExitHandler(processTracker); var dispatcher = new MessageDispatcher(); dispatcher.RegisterMethod <CreateProcessRequest>( CreateProcessRequest.MethodName, async(request) => { var result = await createProcessHandler.ExecuteAsync(request.@params); return(new CreateProcessResponse(request.id, result)); }); dispatcher.RegisterMethod <PingRequest>( PingRequest.MethodName, async(request) => { await pingHandler.ExecuteAsync(); return(new PingResponse(request.id)); }); dispatcher.RegisterMethod <FindProcessByIdRequest>( FindProcessByIdRequest.MethodName, async(request) => { var result = await findProcessByIdHandler.ExecuteAsync(request.@params); return(new FindProcessByIdResponse(request.id, result)); }); dispatcher.RegisterMethod <StopProcessRequest>( StopProcessRequest.MethodName, async(request) => { await stopProcessHandler.ExecuteAsync(request.@params); return(new StopProcessResponse(request.id)); }); dispatcher.RegisterMethod <StopAllProcessesRequest>( StopAllProcessesRequest.MethodName, async(request) => { await stopAllProcessesHandler.ExecuteAsync(request.@params); return(new StopAllProcessesResponse(request.id)); }); dispatcher.RegisterMethod <WaitForProcessExitRequest>( WaitForProcessExitRequest.MethodName, async(request) => { var result = await waitForProcessExitHandler.ExecuteAsync(request.@params); return(new WaitForProcessExitResponse(request.id, result)); }); transport.SubscribeRequest( async(request) => { var response = await dispatcher.DispatchAsync(request); await transport.PublishResponseAsync(response); }); transport.Start(); ReportOk(); exitEvent.WaitOne(); } }
public static int Main(string[] args) { RegisterBlipTypes(); var serviceProvider = new ServiceCollection() .AddSingleton <IStringService, StringService>() .AddSingleton <IBlipClientFactory, BlipClientFactory>() .AddSingleton <NLPCompareHandler>() .AddSingleton <CopyHandler>() .AddSingleton <ExportHandler>() .BuildServiceProvider(); return(CLI.HandleErrors(() => { var app = CLI.Parser(); app.ExecutableName(typeof(Program).GetTypeInfo().Assembly.GetName().Name); app.FromAssembly(typeof(Program).GetTypeInfo().Assembly); app.HelpText("BLiP Command Line Interface"); _verbose = app.Switch("v").Alias("verbose").HelpText("Enable verbose output."); _force = app.Switch("force").HelpText("Enable force operation."); var pingHandler = new PingHandler(); var pingCommand = app.Command("ping"); pingHandler.Node = pingCommand.Parameter <string>("n").Alias("node").HelpText("Node to ping"); pingCommand.HelpText("Ping a specific bot (node)"); pingCommand.Handler(pingHandler.Run); var nlpImportHandler = new NLPImportHandler(); var nlpImportCommand = app.Command("nlp-import"); nlpImportHandler.Node = nlpImportCommand.Parameter <string>("n").Alias("node").HelpText("Node to receive the data"); nlpImportHandler.Authorization = nlpImportCommand.Parameter <string>("a").Alias("authorization").HelpText("Node Authorization to receive the data"); nlpImportHandler.EntitiesFilePath = nlpImportCommand.Parameter <string>("ep").Alias("entities").HelpText("Path to entities file in CSV format"); nlpImportHandler.IntentsFilePath = nlpImportCommand.Parameter <string>("ip").Alias("intents").HelpText("Path to intents file in CSV format"); nlpImportHandler.AnswersFilePath = nlpImportCommand.Parameter <string>("ap").Alias("answers").HelpText("Path to answers file in CSV format"); nlpImportCommand.HelpText("Import intents and entities to a specific bot (node)"); nlpImportCommand.Handler(nlpImportHandler.Run); var copyHandler = serviceProvider.GetService <CopyHandler>(); var copyCommand = app.Command("copy"); copyHandler.From = copyCommand.Parameter <string>("f").Alias("from").HelpText("Node (bot) source."); copyHandler.To = copyCommand.Parameter <string>("t").Alias("to").HelpText("Node (bot) target"); copyHandler.FromAuthorization = copyCommand.Parameter <string>("fa").Alias("fromAuthorization").HelpText("Authorization key of source bot"); copyHandler.ToAuthorization = copyCommand.Parameter <string>("ta").Alias("toAuthorization").HelpText("Authorization key of target bot"); copyHandler.Contents = copyCommand.Parameter <List <BucketNamespace> >("c").Alias("contents").HelpText("Define which contents will be copied").ParseUsing(copyHandler.CustomNamespaceParser); copyHandler.Verbose = _verbose; copyHandler.Force = _force; copyCommand.HelpText("Copy data from source bot (node) to target bot (node)"); copyCommand.Handler(copyHandler.Run); var saveNodeHandler = new SaveNodeHandler(); var saveNodeCommand = app.Command("saveNode"); saveNodeHandler.Node = saveNodeCommand.Parameter <string>("n").Alias("node").HelpText("Node (bot) to be saved"); saveNodeHandler.AccessKey = saveNodeCommand.Parameter <string>("k").Alias("accessKey").HelpText("Node accessKey"); saveNodeHandler.Authorization = saveNodeCommand.Parameter <string>("a").Alias("authorization").HelpText("Node authoriaztion header"); saveNodeCommand.HelpText("Save a node (bot) to be used next"); saveNodeCommand.Handler(saveNodeHandler.Run); var formatKeyHandler = new FormatKeyHandler(); var formatKeyCommand = app.Command("formatKey").Alias("fk"); formatKeyHandler.Identifier = formatKeyCommand.Parameter <string>("i").Alias("identifier").HelpText("Bot identifier").Required(); formatKeyHandler.AccessKey = formatKeyCommand.Parameter <string>("k").Alias("accessKey").HelpText("Bot accessKey"); formatKeyHandler.Authorization = formatKeyCommand.Parameter <string>("a").Alias("authorization").HelpText("Bot authoriaztion header"); formatKeyCommand.HelpText("Show all valid keys for a bot"); formatKeyCommand.Handler(formatKeyHandler.Run); var nlpAnalyseHandler = new NLPAnalyseHandler(); var nlpAnalyseCommand = app.Command("nlp-analyse").Alias("analyse"); nlpAnalyseHandler.Text = nlpAnalyseCommand.Parameter <string>("t").Alias("text").HelpText("Text to be analysed"); nlpAnalyseHandler.Node = nlpAnalyseCommand.Parameter <string>("n").Alias("node").Alias("identifier").HelpText("Bot identifier"); nlpAnalyseHandler.Node = nlpAnalyseCommand.Parameter <string>("a").Alias("accessKey").HelpText("Bot access key"); nlpAnalyseCommand.HelpText("Analyse some text using a bot IA model"); nlpAnalyseCommand.Handler(nlpAnalyseHandler.Run); var exportHandler = serviceProvider.GetService <ExportHandler>(); var exportCommand = app.Command("export").Alias("get"); exportHandler.Node = exportCommand.Parameter <string>("n").Alias("node").HelpText("Node (bot) source"); exportHandler.Authorization = exportCommand.Parameter <string>("a").Alias("authorization").HelpText("Authorization key of source bot"); exportHandler.OutputFilePath = exportCommand.Parameter <string>("o").Alias("output").Alias("path").HelpText("Output file path. Please use a full path."); exportHandler.Model = exportCommand.Parameter <ExportModel>("m").Alias("model").HelpText($"Model to be exported. Examples: \'{exportHandler.GetTypesListAsString()}\'").ParseUsing(exportHandler.CustomParser); exportHandler.Verbose = _verbose; exportCommand.HelpText("Export some BLiP model"); exportCommand.Handler(exportHandler.Run); var compareHandler = serviceProvider.GetService <NLPCompareHandler>(); var compareCommand = app.Command("comp").Alias("compare"); compareHandler.Authorization1 = compareCommand.Parameter <string>("a1").Alias("authorization1").Alias("first").HelpText("Authorization key of first bot"); compareHandler.Bot1Path = compareCommand.Parameter <string>("p1").Alias("path1").Alias("firstpath").HelpText("Path of first bot containing exported model"); compareHandler.Authorization2 = compareCommand.Parameter <string>("a2").Alias("authorization2").Alias("second").HelpText("Authorization key of second bot"); compareHandler.Bot2Path = compareCommand.Parameter <string>("p2").Alias("path2").Alias("secondpath").HelpText("Path of second bot containing exported model"); compareHandler.OutputFilePath = compareCommand.Parameter <string>("o").Alias("output").Alias("path").HelpText("Output file path"); compareHandler.Method = compareCommand.Parameter <ComparisonMethod>("m").Alias("method").HelpText("Comparison method (exact, levenshtein)").ParseUsing(compareHandler.CustomMethodParser); compareHandler.Verbose = _verbose; compareCommand.HelpText("Compare two knowledgebases"); compareCommand.Handler(compareHandler.Run); app.HelpCommand(); return app.Parse(args).Run(); })); }
public void SendsPingAfterGivenTime() { var selfData = new SelfBotData { Id = "BOTID" }; var mockState = new Mock<IBotState>(); mockState.Setup(m => m.Connected).Returns(true).Verifiable(); var mockService = new Mock<IBotServices>(); mockService.Setup(m => m.SendRawMessage(It.Is<OutputMessage>(om => om.Type == "ping"))) .Verifiable(); var handler = new PingHandler { BotState = mockState.Object, BotServices = mockService.Object, PingFrequencyMs = 200 }; Thread.Sleep(500); mockService.Verify(m => m.SendRawMessage(It.Is<OutputMessage>(om => om.Type == "ping")), Times.Exactly(2)); }
public void TestPongOnlyOnPing() { var pingHandler = new PingHandler(); Assert.AreEqual("PING", pingHandler.ForCommand()); }
public WebSocketConnectionRfc6455([NotNull] NetworkConnection networkConnection, bool maskData, [NotNull] WebSocketListenerOptions options) { if (networkConnection == null) { throw new ArgumentNullException(nameof(networkConnection)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } const int HEADER_SEGMENT_SIZE = 16; const int PONG_SEGMENT_SIZE = 128; const int PING_HEADER_SEGMENT_SIZE = 16; const int PING_SEGMENT_SIZE = 128; const int SEND_HEADER_SEGMENT_SIZE = 16; const int CLOSE_SEGMENT_SIZE = 2; this.log = options.Logger; this.writeSemaphore = new SemaphoreSlim(1); this.options = options; this.networkConnection = networkConnection; this.maskData = maskData; var bufferSize = HEADER_SEGMENT_SIZE + PING_HEADER_SEGMENT_SIZE + PONG_SEGMENT_SIZE + PING_HEADER_SEGMENT_SIZE + PING_SEGMENT_SIZE + PING_HEADER_SEGMENT_SIZE + PONG_SEGMENT_SIZE + PING_HEADER_SEGMENT_SIZE + PING_SEGMENT_SIZE + CLOSE_SEGMENT_SIZE; var smallBuffer = this.options.BufferManager.TakeBuffer(bufferSize); this.headerBuffer = new ArraySegment <byte>(smallBuffer, 0, HEADER_SEGMENT_SIZE); this.outPongBuffer = this.headerBuffer.NextSegment(PING_HEADER_SEGMENT_SIZE).NextSegment(PONG_SEGMENT_SIZE); this.outPingBuffer = this.outPongBuffer.NextSegment(PING_HEADER_SEGMENT_SIZE).NextSegment(PING_SEGMENT_SIZE); this.inPongBuffer = this.outPingBuffer.NextSegment(PING_HEADER_SEGMENT_SIZE).NextSegment(PONG_SEGMENT_SIZE); this.inPingBuffer = this.inPongBuffer.NextSegment(PING_HEADER_SEGMENT_SIZE).NextSegment(PING_SEGMENT_SIZE); this.closeBuffer = this.inPingBuffer.NextSegment(CLOSE_SEGMENT_SIZE); var sendBuffer = this.options.BufferManager.TakeBuffer(this.options.SendBufferSize); this.SendBuffer = new ArraySegment <byte>(sendBuffer, SEND_HEADER_SEGMENT_SIZE, sendBuffer.Length - SEND_HEADER_SEGMENT_SIZE); switch (options.PingMode) { case PingMode.BandwidthSaving: this.pingHandler = new BandwidthSavingPing(this); break; case PingMode.LatencyControl: this.pingHandler = new LatencyControlPing(this); break; case PingMode.Manual: this.pingHandler = new ManualPing(this); break; default: throw new InvalidOperationException($"Unknown value '{options.PingMode}' for '{nameof(PingMode)}' enumeration."); } }
public void OnClientConnect(IClient client) { PingHandler.StartPing(client); }