/// <summary>
/// Initializes a new instance of the <see cref="LegacyStreamingConnection"/> class that uses web sockets.
/// </summary>
/// <param name="socket">The <see cref="WebSocket"/> instance to use for legacy streaming connection.</param>
/// <param name="logger">Logger implementation for tracing and debugging information.</param>
/// <param name="onServerDisconnect">Additional handling code to be run when the transport server is disconnected.</param>
public LegacyStreamingConnection(WebSocket socket, ILogger logger, DisconnectedEventHandler onServerDisconnect = null)
: base(logger)
{
_socket = socket ?? throw new ArgumentNullException(nameof(socket));
_logger = logger ?? NullLogger.Instance;
_onServerDisconnect = onServerDisconnect;
}
public void Start()
{
playerdeathhandler = new PlayerDeathEventHandler(EventSink_PlayerDeath);
disconnectedhandler = new DisconnectedEventHandler(EventSink_PlayerDisc);
EventSink.PlayerDeath += playerdeathhandler;
EventSink.Disconnected += disconnectedhandler;
int cpt = 0;
foreach (PVPTeam team in m_pvpevent.teams)
{
cpt += team.Count;
}
if (cpt > 1)
{
m_timeoutTimer.Start();
OnStart();
}
else
{
Stop();
}
}
public async Task SendRequestAsync_WaitsTillAllDataSent()
{
var payLoadSender = new PayloadSender();
var tcs = new TaskCompletionSource <bool>();
DisconnectedEventHandler eventHandler = (sender, args) =>
{
tcs.TrySetException(new Exception(args.Reason));
};
payLoadSender.Disconnected += eventHandler;
payLoadSender.Connect(GetMockedTransportSender(tcs, TransportConstants.MaxPayloadLength * 4));
var sendOperations = new SendOperations(payLoadSender);
try
{
using (var stream = GetMockedStream(TransportConstants.MaxPayloadLength * 4))
{
var request = new StreamingRequest();
request.AddStream(new StreamContent(stream));
await sendOperations.SendRequestAsync(Guid.NewGuid(), request);
}
await tcs.Task;
}
finally
{
payLoadSender.Disconnected -= eventHandler;
}
}
public async Task Should_send_disconnect_messages_to_participants_and_service_bus_on_participant_disconnect()
{
_eventHandler = new DisconnectedEventHandler(EventHubContextMock.Object, ConferenceCache, LoggerMock.Object,
VideoApiClientMock.Object);
var conference = TestConference;
var participantCount = conference.Participants.Count + 1; // plus one for admin
var participantForEvent = conference.Participants.First(x => x.Role == Role.Individual);
var callbackEvent = new CallbackEvent
{
EventType = EventType.Disconnected,
EventId = Guid.NewGuid().ToString(),
ParticipantId = participantForEvent.Id,
ConferenceId = conference.Id,
Reason = "Unexpected drop",
TimeStampUtc = DateTime.UtcNow
};
await _eventHandler.HandleAsync(callbackEvent);
// Verify messages sent to event hub clients
EventHubClientMock.Verify(
x => x.ParticipantStatusMessage(participantForEvent.Id, participantForEvent.Username, conference.Id, ParticipantState.Disconnected),
Times.Exactly(participantCount));
}
public bool ReceiveMessage(ref Message m)
{
if (m.Msg == WM_USER_SIMCONNECT && simconnect != null)
{
try
{
simconnect.ReceiveMessage();
return(true);
}
catch (System.AccessViolationException ex)
//catch (Exception ex)
{
// на всякий случай создаем копию события т.к. возможна ситуация, что подписчик отпишется от события в момент проверки ниже
DisconnectedEventHandler disconnectedHandler = DisconnectedEvent;
// далее проверяем, что есть ли какой-то подписчик на событие ConnectedToEndPointEvent (эта переменная не равна нулю) и генерируем тогда такое событие
if (disconnectedHandler != null)
{
disconnectedHandler(this, new EventArgs());
}
return(false);
}
}
else
{
return(false);
}
}
protected void OnDisconnected()
{
DisconnectedEventHandler handler = Disconnected;
if (handler != null)
{
handler(this);
}
}
protected void OnDisconnected(EventArgs e)
{
DisconnectedEventHandler disHandler = Disconnected;
if (disHandler != null)
{
disHandler(this, e);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LegacyStreamingConnection"/> class that uses named pipes.
/// </summary>
/// <param name="pipeName">The name of the named pipe.</param>
/// <param name="logger">Logger implementation for tracing and debugging information.</param>
/// <param name="onServerDisconnect">Additional handling code to be run when the transport server is disconnected.</param>
public LegacyStreamingConnection(string pipeName, ILogger logger, DisconnectedEventHandler onServerDisconnect = null)
{
if (string.IsNullOrWhiteSpace(pipeName))
{
throw new ArgumentNullException(nameof(pipeName));
}
_pipeName = pipeName;
_logger = logger ?? NullLogger.Instance;
_onServerDisconnect = onServerDisconnect;
}
public void DisconnectedEventHandlerCanBeRemoved()
{
var stream = MockRepository.GenerateStub <Stream>();
var channelStream = new ChannelStream(stream);
bool called = false;
var eventHandler = new DisconnectedEventHandler(() => called = true);
channelStream.Disconnected += eventHandler;
channelStream.Disconnected -= eventHandler;
channelStream.Dispose();
Assert.False(called, "Event handler should not have been called.");
}
public void DisconnectedEventFiresAfterDispose()
{
var stream = MockRepository.GenerateStub <Stream>();
var channelStream = new ChannelStream(stream);
bool called = false;
var eventHandler = new DisconnectedEventHandler(() => called = true);
channelStream.Disconnected += eventHandler;
Assert.False(called, "Disconnected should not have fired before Dispose() was called.");
channelStream.Dispose();
Assert.True(called, "Expected event to have been fired");
}
public void DisconnectedEventFiresImmediatelyIfDisposed()
{
var stream = MockRepository.GenerateStub <Stream>();
var channelStream = new ChannelStream(stream);
channelStream.Dispose();
bool called = false;
var eventHandler = new DisconnectedEventHandler(() => called = true);
channelStream.Disconnected += eventHandler;
Assert.True(called, "Expected event to have been fired");
}
public SlotManager(string userName, int port, List <ServerMetadata> servers)
{
_calendar = new Dictionary <int, CalendarSlot>();
_activeReservations = new Dictionary <int, Reservation>();
_committedReservations = new Dictionary <int, Reservation>();
_userName = userName;
_port = port;
_servers = servers;
_msgDispatcher = new MessageDispatcher(_userName);
_clientMonitor = new ClientMonitor(_msgDispatcher, _userName, _servers);
_disconnectInterested = new DisconnectedEventHandler(_msgDispatcher.ClientDisconnected) + new DisconnectedEventHandler(_clientMonitor.Disconnected);
_monitorThread = null;
}
/// <summary>
/// The case where the user closes Prepar3D
/// </summary>
/// <param name="sender"></param>
/// <param name="data"></param>
void simconnect_OnRecvQuit(SimConnect sender, SIMCONNECT_RECV data)
{
CloseConnection();
// на всякий случай создаем копию события т.к. возможна ситуация, что подписчик отпишется от события в момент проверки ниже
DisconnectedEventHandler disconnectedHandler = DisconnectedEvent;
// далее проверяем, что есть ли какой-то подписчик на событие ConnectedToEndPointEvent (эта переменная не равна нулю) и генерируем тогда такое событие
if (disconnectedHandler != null)
{
disconnectedHandler(this, new EventArgs());
}
}
public void Connect()
{
CommandSent += new CommandSentEventHandler(client_CommandSent);
CommandSendingFailed += new CommandSendingFailedEventHandler(client_CommandSendingFailed);
CommandReceivingFailed += new CommandReceivingFailedEventHandler(client_CommandReceivingFailed);
ServerDisconnected += new ServerDisconnectedEventHandler(client_ServerDisconnected);
DisconnectedFromServer += new DisconnectedEventHandler(client_DisconnectedFromServer);
ConnectingSuccessed += new ConnectingSuccessedEventHandler(client_ConnectingSuccessed);
ConnectingFailed += new ConnectingFailedEventHandler(client_ConnectingFailed);
NetworkDead += new NetworkDeadEventHandler(client_NetworkDead);
NetworkAlived += new NetworkAlivedEventHandler(client_NetworkAlived);
ConnectToServer();
}
public SlotManager(string userName, int port, List<ServerMetadata> servers)
{
_calendar = new Dictionary<int, CalendarSlot>();
_activeReservations = new Dictionary<int, Reservation>();
_committedReservations = new Dictionary<int, Reservation>();
_userName = userName;
_port = port;
_servers = servers;
_msgDispatcher = new MessageDispatcher(_userName);
_clientMonitor = new ClientMonitor(_msgDispatcher, _userName, _servers);
_disconnectInterested = new DisconnectedEventHandler(_msgDispatcher.ClientDisconnected) + new DisconnectedEventHandler(_clientMonitor.Disconnected);
_monitorThread = null;
}
public void Connect()
{
CommandSent += new CommandSentEventHandler(client_CommandSent);
CommandSendingFailed += new CommandSendingFailedEventHandler(client_CommandSendingFailed);
CommandReceivingFailed += new CommandReceivingFailedEventHandler(client_CommandReceivingFailed);
ServerDisconnected += new ServerDisconnectedEventHandler(client_ServerDisconnected);
DisconnectedFromServer += new DisconnectedEventHandler(client_DisconnectedFromServer);
ConnectingSuccessed += new ConnectingSuccessedEventHandler(client_ConnectingSuccessed);
ConnectingFailed += new ConnectingFailedEventHandler(client_ConnectingFailed);
NetworkDead += new NetworkDeadEventHandler(client_NetworkDead);
NetworkAlived += new NetworkAlivedEventHandler(client_NetworkAlived);
ConnectToServer();
}
public Client(Socket sock, DisconnectedEventHandler callback)
{
_sock = sock;
_ip = _sock.RemoteEndPoint.ToString().Split(':')[0];
Disconnected += callback;
Utils.MyConsole.WriteLine
(
_ip, ConsoleType.Connect, ConsoleWriter.Game
);
BeginReceive();
_parser = new Parser(this);
}
public void initialize()
{
ConnectedEventHandler ConnectedDelegate = new ConnectedEventHandler(HandleConnectedEvent);
DisconnectedEventHandler DisconnectedDelegate = new DisconnectedEventHandler(HandleDisconnectedEvent);
EscrowEventHandler EscrowedDelegate = new EscrowEventHandler(HandleEscrowedEvent);
RejectedEventHandler RejectedDelegate = new RejectedEventHandler(HandleRejectedEvent);
ReturnedEventHandler ReturnedDelegate = new ReturnedEventHandler(HandleReturnedEvent);
StackedEventHandler StackedDelegate = new StackedEventHandler(HandleStackedEvent);
billacceptor.OnConnected += ConnectedDelegate;
billacceptor.OnDisconnected += DisconnectedDelegate;
billacceptor.OnEscrow += EscrowedDelegate;
billacceptor.OnRejected += RejectedDelegate;
billacceptor.OnReturned += ReturnedDelegate;
billacceptor.OnStacked += StackedDelegate;
}
public void Read(IAsyncResult ar)
{
if (this.client.GetStream().DataAvailable & this.client.GetStream().CanRead)
{
try
{
Thread.Sleep(15);
byte[] info = (byte[])this.bf.Deserialize(this.client.GetStream());
GotInfoEventHandler gotInfoEvent = this.GotInfoEvent;
if (gotInfoEvent != null)
{
gotInfoEvent(this, info);
}
}
catch (Exception exception1)
{
ProjectData.SetProjectError(exception1);
ProjectData.ClearProjectError();
}
}
try
{
this.client.GetStream().Flush();
this.client.GetStream().BeginRead(new byte[] { 0 }, 0, 0, new AsyncCallback(this.Read), null);
}
catch (Exception exception2)
{
ProjectData.SetProjectError(exception2);
DisconnectedEventHandler disconnectedEvent = this.DisconnectedEvent;
if (disconnectedEvent != null)
{
disconnectedEvent(this);
}
ProjectData.ClearProjectError();
}
}
public TestLegacyStreamingConnection(WebSocket socket, ILogger logger, DisconnectedEventHandler onServerDisconnect = null)
: base(socket, logger, onServerDisconnect)
{
}
public TestLegacyStreamingConnection(string pipeName, ILogger logger, DisconnectedEventHandler onServerDisconnect = null)
: base(pipeName, logger, onServerDisconnect)
{
}
public OnDisconnectedHostedService(DiscordSocketClient discordSocketClient, DisconnectedEventHandler disconnectedEventHandler)
{
_discordSocketClient = discordSocketClient;
_disconnectedEventHandler = disconnectedEventHandler;
}
public void ExecuteDisconnectedHandler(IPAddress ip)
{
DisconnectedEventHandler?.Invoke(ip);
}
/// <summary>
/// Registers the given function to be run when the bot gets disconnected from the server.
/// </summary>
/// <param name = "handler">
/// The function to register.
/// </param>
public void RegisterOnDisconnectedHook(DisconnectedEventHandler handler)
{
AlarisBase.Instance.Connection.Listener.OnDisconnected += handler;
}
public override void OnDisconnect()
{
DisconnectedEventHandler?.Invoke(this, EventArgs.Empty);
base.OnDisconnect();
}
