protected virtual void OnIncomingMessage(MessageEventArgs e)
{
if (IncomingMessage != null)
{
IncomingMessage?.Invoke(this, e);
}
}
private void EventService_MessangerIncomingText(object sender, MessangerIncomingTextEventArgs e)
{
if (e.MessangerType != MessangerType)
{
return;
}
switch (e.EventCode)
{
case MessangerEventType.Connected: //Connected
Connected?.Invoke(this, new EventArgs());
break;
case MessangerEventType.Disconnected: //Disconnected
Disconnected?.Invoke(this, new EventArgs());
break;
case MessangerEventType.Message: //Incoming Message
IncomingMessage?.Invoke(this, e as MessangerTextEventArgs);
break;
case MessangerEventType.Error: //Error
Error?.Invoke(this, e as MessangerErrorEventArgs);
break;
}
}
private void ThreadProc()
{
while (!exit)
{
try
{
var args = new IncommingMessageEventArgs <E>
{
Message = reader.Read(),
Sender = reader.Sender
};
IncomingMessage?.Invoke(this, args);
}
catch (System.Net.Sockets.SocketException e)
{
}
catch (Exception e)
{
string message = e.Message;
string caption = "Error Detected in Input";
MessageBoxButtons buttons = MessageBoxButtons.OK;
var result = MessageBox.Show(message, caption, buttons);
}
}
}
protected void OnIncomingMessage(IncomingMessageEventArgs e)
{
new Thread(() =>
{
IncomingMessage?.Invoke(this, e);
}
).Start();
}
private void OnIncomingMessage(object sender, string rawMessage)
{
if (isInfrastructureMessage(rawMessage))
{
// Prevents Infrastructure messages from propagating downwards
return;
}
IncomingMessage?.Invoke(sender, rawMessage);
}
private void InvokeIncomingMessageEvent(User sender, string message)
{
var eventArgs = new IncomingMessageEventArgs
{
Sender = sender,
Message = message
};
IncomingMessage?.Invoke(this, eventArgs);
}
private void Run()
{
while (_keepGoing)
{
IPEndPoint senderEndPoint;
var message = GetMessage(out senderEndPoint);
if (message == null)
{
continue;
}
IncomingMessage?.Invoke(message, senderEndPoint);
}
}
internal virtual void OnIncomingMessage(INetworkNode From, byte[] NewMessage)
{
if ((IncomingMessage == null) || (From == null) || (NewMessage == null) || (NewMessage.Length == 0))
{
return;
}
IncomingMessage?.Invoke(this, new InternetCommunicationEventArgs
{
Remote = From,
Local = this,
Direction = CommunicationDirection.Inbound,
Message = NewMessage
});
}
private void OnMessage(object sender, MessageEventArgs e)
{
if (e.Opcode == OpcodeEnum.Close)
{
// send close command to the socket
try
{
if (_streamSocket.TrySendFrame(Identity, Identity.Length, true))
{
_streamSocket.TrySendFrame("");
}
}
catch (NetMQException)
{
}
State = WebSocketClientState.Closed;
}
else if (e.Opcode == OpcodeEnum.Binary)
{
if (_outgoingMessage == null)
{
_outgoingMessage = new NetMQMessage();
}
_outgoingMessage.Append(e.Payload);
if (!e.More)
{
IncomingMessage?.Invoke(this, new NetMqMessageEventArgs(Identity, _outgoingMessage));
_outgoingMessage = null;
}
}
else if (e.Opcode == OpcodeEnum.Ping)
{
byte[] pong = new byte[2 + e.Payload.Length];
pong[0] = 0x8A; // Pong and Final
pong[1] = (byte)(e.Payload.Length & 127);
Buffer.BlockCopy(e.Payload, 0, pong, 2, e.Payload.Length);
if (_streamSocket.TrySendFrame(Identity, Identity.Length, true))
{
_streamSocket.TrySendFrame(pong);
}
}
}
void PipeClient_ServerMessage(NamedPipeConnection <Message, Message> connection, Message message)
{
Debug.WriteLine("Incoming message <- " + message.GetType().Name, NAME);
if (message is ConfigMessage)
{
HandleMessage((ConfigMessage)message);
}
else if (message is TerminateMessage)
{
HandleMessage((TerminateMessage)message);
}
else
{
IncomingMessage?.Invoke(this, new MessageEvent {
Message = message
});
}
}
private async Task AnyMessageReceived(
TwitchLibMessage twitchLibMessage,
string messageText,
MessageSource source)
{
string?colorHex = twitchLibMessage.ColorHex;
User user = await _userRepo.RecordUser(new UserInfo(
id : twitchLibMessage.UserId,
twitchDisplayName : twitchLibMessage.DisplayName,
simpleName : twitchLibMessage.Username,
color : string.IsNullOrEmpty(colorHex) ? null : colorHex.TrimStart('#'),
fromMessage : true,
updatedAt : _clock.GetCurrentInstant()
));
var message = new Message(user, messageText, source);
IncomingMessage?.Invoke(this, new MessageEventArgs(message));
}
private void Run()
{
Log.Debug("Communicator Started");
while (_keepGoing)
{
IPEndPoint senderEndPoint;
var message = GetMessage(out senderEndPoint);
if (message == null)
{
continue;
}
Log.Debug($"Got a {message} from {senderEndPoint}");
Console.WriteLine(message);
//Send("Race,Test Race,25000", senderEndPoint);
//Send("Athlete, 1881, Abe, Test, M, 25", senderEndPoint);
IncomingMessage?.Invoke(message, senderEndPoint);
manager.ReceiveMessage(message, senderEndPoint);
}
Log.Debug("Communicator Stopped");
}
private void ThreadProc()
{
while (!exit)
{
try
{
var args = new IncommingMessageEventArgs <E>
{
Message = reader.Receive(),
Sender = reader.RemoteEndPoint
};
IncomingMessage?.Invoke(this, args);
}
catch (Exception e)
{
string message = e.Message;
string caption = "Error Detected in Input";
Console.WriteLine(caption + " : " + e.Message);
}
}
}
internal void RaiseIncomingMessage(JsonResponse message)
{
IncomingMessage?.Invoke(this, message);
}
private void OnIncomingMessage(MessageEventArgs e)
{
IncomingMessage?.Invoke(this, e);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
public async Task OnMessage(string message)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
IncomingMessage?.Invoke(this, message);
}
protected virtual void OnIncomingMessage(MessageReceivedEventArgs e)
{
IncomingMessage?.Invoke(this, e);
}
protected virtual async Task OnIncomingMessageAsync(object sender, BasicDeliverEventArgs ea)
{
await Task.Delay(0, LocalCancellationToken);
var ackMode = ((ConsumerParameters)ChannelParameters).AutoAckMode;
var isRpc = false;
var requiresAck = false;
VerboseLoggingHandler.Log($"Event OnIncomingMessageAsync triggered For tag='{ea.DeliveryTag}', exchange='{ea.Exchange}', routingKeyOrTopicName='{ea.RoutingKey}', consumerTag='{ea.ConsumerTag}', deliveryTag='{ea.DeliveryTag}', redelivered='{ea.Redelivered}'");
var messageType = ea.BasicProperties.Type;
if (!ea.BasicProperties.IsCorrelationIdPresent())
{
var e = new InvalidOperationException($"Missing correlationId in message from exchange={ea.Exchange} deliveryTag=${ea.DeliveryTag}");
VerboseLoggingHandler.Log(e);
throw e;
}
VerboseLoggingHandler.Log($"MessageType='{messageType}'");
if (messageType.Contains(MessageTypeFragmentsRequestAmqAck))
{
if (ackMode == ConsumerParameters.AutoAckModeEnum.OnReceipt)
{
Channel.BasicAck(ea.DeliveryTag, false);
}
if (ackMode == ConsumerParameters.AutoAckModeEnum.Manual)
{
requiresAck = true;
}
}
if ((messageType.Contains(MessageTypeFragmentsRequestAck) || messageType.Contains(MessageTypeFragmentsRequestReply) && ea.BasicProperties.IsReplyToPresent()))
{
isRpc = true;
EndpointType = EndpointTypeEnum.RpcConsumer;
ReplyToQueueName = ea.BasicProperties.ReplyTo;
VerboseLoggingHandler.Log($"Reply requested to '{ReplyToQueueName}'");
if (ea.BasicProperties.IsHeadersPresent())
{
VerboseLoggingHandler.Log($"Headers found");
var headers = ea.BasicProperties.Headers;
if (headers.ContainsKey(DictionaryKey_PassedQueueTtl))
{
var ttl = Convert.ToInt32(headers[DictionaryKey_PassedQueueTtl]);
VerboseLoggingHandler.Log($"ttl='{ttl}'");
if (QueueTtlValues.ContainsKey(ReplyToQueueName))
{
QueueTtlValues[ReplyToQueueName] = ttl;
}
else
{
QueueTtlValues.Add(ReplyToQueueName, ttl);
}
ea.BasicProperties.Headers.Remove(DictionaryKey_PassedQueueTtl);
}
}
// Handle basic message acknowledgement here.
if (messageType.Contains(MessageTypeFragmentsRequestAck) && ConvertMessageToString(ea.Body) == MessageContent_Ping)
{
VerboseLoggingHandler.Log($"Ack'ing the Ping");
await ReplyAsync(MessageContent_PingResponse, null);
}
}
VerboseLoggingHandler.Log($"Delegate check - does messageType have '{MessageTypeFragmentsRequestReply}'?");
if (messageType.Contains(MessageTypeFragmentsRequestReply))
{
VerboseLoggingHandler.Log($"Confirmed. Fire delegate");
var args = new IncomingRabbitMqMessageEventArgs(isRpc, requiresAck, ea);
await Task.Run(() => IncomingMessage?.Invoke(this, args), LocalCancellationToken);
}
}
/// <summary>
/// Event fired when one or more new messages are ready for use.
/// </summary>
/// <param name="sender">Originator of call for this event.</param>
/// <param name="e">Event args for the message.</param>
protected virtual void OnIncomingMessage(object sender, IncomingMessageEventArgs <TSession, TConfig> e)
{
IncomingMessage?.Invoke(sender, e);
}
/// <summary>
/// Event method invoker
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The event object containing the mailbox to retrieve the message from.</param>
private void OnIncomingMessage(object sender, IncomingMessageEventArgs <TSession, TConfig> e)
{
IncomingMessage?.Invoke(sender, e);
}