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