public override void OnReceive(ReadOnlySpan <byte> data)
{
base.OnReceive(data);
Span <byte> headerSpan = headerPayload;
while (RecvBuffer.Peek(headerSpan) == 4)
{
if (BitConverter.IsLittleEndian)
{
headerSpan.Reverse();
}
var payloadLength = BitConverter.ToInt32(headerSpan);
if (payloadLength > payload.Length)
{
throw new IndexOutOfRangeException("not enough buffer for message");
}
if (payloadLength + 4 <= RecvBuffer.Length)
{
RecvBuffer.Skip(4);
Span <byte> messageSpan = payload;
messageSpan = messageSpan.Slice(0, payloadLength);
var count = RecvBuffer.Take(messageSpan);
OnNewMessage?.Invoke(messageSpan, count);
}
else
{
break;
}
}
}
private void LongPollEventLoop()
{
//Запускаем бесконечный цикл опроса
try
{
while (true)
{
var longPollHistoryResponse = _api.Groups.GetBotsLongPollHistory(new BotsLongPollHistoryParams
{
Ts = ts.ToString(),
Key = key,
Server = server,
Wait = 10
});
ts = longPollHistoryResponse.Ts;
foreach (var update in longPollHistoryResponse.Updates)
{
if (update.Type.ToString() == "message_new")
{
OnNewMessage.Invoke(
update.MessageNew.Message
);
}
}
}
}
catch (Exception)
{
StartMessageHandling();
return;
}
}
private void Process()
{
while (IsActive)
{
try
{
ItemMessage message;
if (_messages.TryDequeue(out message))
{
var isNew = FileMode.Append;
if (GetPathToTextLog())
{
isNew = FileMode.Create;
}
OnNewMessage?.Invoke(message);
Debug.WriteLine(message.ToString());
using (var writer = new StreamWriter(new FileStream(_fi.FullName, isNew)))
{
writer.WriteLine(message.ToString());
}
continue;
}
Thread.Sleep(500);
}
catch (Exception)
{
}
}
}
public async Task GetStreamTweets(string tag)
{
await
(from strm in _twitterCtx.Streaming
where strm.Type == StreamingType.Filter &&
strm.Track == tag
select strm)
.StartAsync(strm =>
{
if (strm.EntityType == StreamEntityType.Status)
{
var status = strm.Entity as Status;
if (status.Entities != null)
{
if (status.Entities.MediaEntities != null && status.Entities.MediaEntities.Count > 0 && status.RetweetedStatus.CreatedAt == DateTime.MinValue)
{
OnNewMessage?.Invoke(this, new GenericEventArgs <Status> {
Data = status
});
}
}
}
return(Task.FromResult(0));
});
}
private void HandleOnChanged(object sender, RecordChangedEventArgs <Message> e)
{
if (e.ChangeType == TableDependency.SqlClient.Base.Enums.ChangeType.Insert)
{
OnNewMessage?.Invoke(e.Entity);
}
}
public static void Message(MessageStatus status, string message, bool sendtoserver = false)
{
if (sendtoserver)
{
ConnectionToServer.SendMessageToServer(status, message);
}
OnNewMessage?.Invoke(status, message);
}
public ChatBL()
{
server = ServerBL.Instance;
server.chatHubProxy.On("newMessage",
(string room, string msg) => OnNewMessage?.Invoke(room, msg));
server.chatHubProxy.On("ChatClosed",
(string room, string sender) => OnChatClosed?.Invoke(room, sender));
}
public void Set(RequestMessage message)
{
if (_isReleased)
{
return;
}
Task.Run(() => OnNewMessage?.Invoke(this, message));
}
public void Warn(string message, [CallerMemberName] string callerMemberName = "")
{
OnNewMessage?.Invoke(this, new LogMessage
{
Level = "WARN",
Message = message,
CallingMemberName = callerMemberName
});
}
public void Error(string message, [CallerMemberName] string callerMemberName = "")
{
OnNewMessage?.Invoke(this, new LogMessage
{
Level = "ERROR",
Message = message,
CallingMemberName = callerMemberName
});
}
} // ServerThread()
private void EventThread(object command)
{
var commandString = command as string;
if (!string.IsNullOrEmpty(commandString))
{
OnNewMessage?.Invoke(this, new MessageEventArgs(commandString));
}
} // EventThread()
public void Debug(string message, [CallerMemberName] string callerMemberName = "")
{
OnNewMessage?.Invoke(this, new LogMessage
{
Level = "DEBUG",
Message = message,
CallingMemberName = callerMemberName
});
}
private void StartTcpReceivingThread()
{
OnNewMessage += _messageManager.HandleMessage;
StringBuilder stringBuilder = new StringBuilder();
var receivingThread = new Thread(() =>
{
string oneResponse;
while (true)
{
if (_socket != null && _socket.Connected)
{
try
{
//
//StringBuilder stringBuilder = new StringBuilder();
// var bytes = new byte[250];
// var numBytesReadFromStream = _socket.Receive(bytes);
// if (numBytesReadFromStream > 0)
{
using (NetworkStream ns = new NetworkStream(_socket))
using (StreamReader sr = new StreamReader(ns))
OnNewMessage?.Invoke(this, sr.ReadLine());
//stringBuilder.Append(sr.ReadLine());
//Debug.WriteLine(sr.ReadToEnd());
//; //oneResponse = _tcpReceiver.Receive(_socket, stringBuilder);
//if (!string.IsNullOrEmpty(oneResponse))
// {
//stringBuilder.Append(Encoding.ASCII.GetString(bytes));
//OnNewMessage?.Invoke(this, Encoding.ASCII.GetString(bytes));
//}
// stringBuilder.Append(Encoding.ASCII.GetString(bytes));
}
//if (numBytesReadFromStream == 0)
//{
//string s = stringBuilder.ToString();
//Debug.WriteLine(s);
//}
/*if (!string.IsNullOrEmpty(oneResponse))
* {
* OnNewMessage?.Invoke(this, oneResponse);
* } */
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
});
receivingThread.Start();
}
public override void OnReceive(ReadOnlySpan <byte> data)
{
base.OnReceive(data);
Span <byte> header = headerPayload;
while (streamReadBytesLeft == 0 && RecvBuffer.Peek(header) == 12)
{
// use network endian
var messageType = BinaryPrimitives.ReadInt32BigEndian(header);
var payloadLength = BinaryPrimitives.ReadInt64BigEndian(header.Slice(4));
if (messageType == MessageType.Message)
{
if (payloadLength > payloadBuffer.Length)
{
throw new IndexOutOfRangeException(
$"Message({payloadLength}) is too big to fit into the buffer({payloadBuffer.Length})");
}
if (payloadLength + 12 <= RecvBuffer.Length)
{
RecvBuffer.Skip(12);
Span <byte> messageSpan = payloadBuffer;
messageSpan = messageSpan.Slice(0, (int)payloadLength);
var count = RecvBuffer.Take(messageSpan);
OnNewMessage?.Invoke(messageSpan, count);
}
else
{
break;
}
}
else if (messageType == MessageType.ByteStream)
{
if (memoryStream == null)
{
memoryStream = new MemoryStream(1024 * 1024 * 4);
}
memoryStream.SetLength(0);
memoryStream.Seek(0, SeekOrigin.Begin);
streamReadBytesLeft = payloadLength;
RecvBuffer.Skip(12);
DrainStreamPayload();
}
}
while (streamReadBytesLeft > 0)
{
if (DrainStreamPayload() == 0)
{
break;
}
}
}
private void InvokeNewMessageHandler(BroadcastedMessage message)
{
try
{
OnNewMessage?.Invoke(this, message);
}
catch (Exception e)
{
throw new Exception($"Error thrown by OnNewMessage handler! Error: {e.Message} \n {e.InnerException?.Message}");
}
}
public override void OnMessage(string message)
{
string key = GetClientKey(this);
Type objType = GeneXus.Metadata.ClassLoader.FindType("GeneXus", GX_NOTIFICATIONINFO_NAME, null);
GxUserType nInfo = (GxUserType)Activator.CreateInstance(objType);
JObject jObj = new JObject();
jObj.Put("Message", message);
nInfo.FromJSONObject(jObj);
ExecuteHandler(HandlerType.ReceivedMessage, new Object[] { key, nInfo });
OnNewMessage?.Invoke(key, message);
}
private void _server_DataReceived(object sender, Message e)
{
Console.WriteLine("Packet Weight : " + e.Data.Count() + " bytes");
Thread thread = new Thread(delegate()
{
var tmp = SimpleTcpAdapter.Convert(e.TcpClient);
var packet = new BasicPacket();
if (!packet.Parse(e.Data))
{
var packets = SplitPacket(e.Data);
foreach (var pk in packets)
{
Thread.Sleep(500);
Thread t = new Thread(delegate()
{
var pack = new BasicPacket();
if (!pack.Parse(pk))
{
return;
}
var ptc = ProtocolFactory.CreateProtocol(pack.Opcode);
if (!ptc.Parse(Encoding.Unicode.GetString(pack.Data)))
{
return;
}
var handling = HandleFactory.CreateHandle(pack.Opcode);
string toview = handling.Handling(ptc, tmp);
if (OnNewMessage != null)
{
OnNewMessage.Invoke(tmp, toview);
}
});
t.Start();
}
return;
}
var protocol = ProtocolFactory.CreateProtocol(packet.Opcode);
if (!protocol.Parse(Encoding.Unicode.GetString(packet.Data)))
{
return;
}
var handle = HandleFactory.CreateHandle(packet.Opcode);
string toView = handle.Handling(protocol, tmp);
if (OnNewMessage != null)
{
OnNewMessage.Invoke(tmp, toView);
}
});
thread.Priority = ThreadPriority.Highest;
thread.Start();
}
internal void WriteMessage(Entry entry)
{
if (entry == null)
{
throw new ArgumentNullException(nameof(entry));
}
Messages.Add(entry);
if (OnNewMessage != null)
{
OnNewMessage.Invoke(this, entry);
}
}
public override Task OnMessage(string connectionGUID, System.Net.WebSockets.WebSocket socket, WebSocketReceiveResult result, byte[] buffer)
{
string key = connectionGUID;
string message = Encoding.UTF8.GetString(buffer);
Type objType = GeneXus.Metadata.ClassLoader.FindType("GeneXus", GX_NOTIFICATIONINFO_NAME, null);
GxUserType nInfo = (GxUserType)Activator.CreateInstance(objType);
JObject jObj = new JObject();
jObj.Put("Message", message);
nInfo.FromJSONObject(jObj);
ExecuteHandler(HandlerType.ReceivedMessage, new Object[] { key, nInfo });
OnNewMessage?.Invoke(key, message);
return(Task.CompletedTask);
}
private void ProcessData(byte[] bytes, int count)
{
for (int i = 0; i < count; i++)
{
byte b = bytes[i];
if (b == _delimByte)
{
// Message done!
byte[] message = _currentMessage.ToArray();
_currentMessage.Clear();
_escaped = false;
OnNewMessage?.Invoke(message);
}
else if (b == _escapeByte)
{
_escaped = true;
}
else if (_escaped)
{
_escaped = false;
switch (b)
{
case _escapeEscapeByte:
_currentMessage.Add(_escapeByte);
break;
case _escapeDelimByte:
_currentMessage.Add(_delimByte);
break;
case _closeConnection:
OnCloseConnection?.Invoke();
SocketClose();
return;
default:
// Unrecognized escape sequence!
break;
}
}
else
{
_currentMessage.Add(b);
}
}
}
/// <summary>
/// Event handler to get new message from socket
/// </summary>
private void Socket_OnMessage(object sender, MessageEventArgs e)
{
try
{
OnNewMessage?.Invoke(e.Data);
// unzip data
//if (e.IsBinary)
// OnNewMessage?.Invoke(unzip(e.RawData));
}
catch (Exception ex)
{
logger.Fatal(ex, "Websocket OnMessage Exception");
}
}
private void WriteMessage(MessageEventArgs <TSub> msgArgs)
{
// Если отправитель это текущий подписчик, то выводится - кому было направлено -> "To {messageEventArgs.To}"
if (msgArgs.From.Equals(Subscriber))
{
msgArgs.Message = $"{FormatDate(msgArgs.DateCreated)} " +
$"To {msgArgs.To}: {msgArgs.Text}{Environment.NewLine}";
}
else // Если же сообщение пришло от другого контроллера, то:
{
msgArgs.Message = $"{FormatDate(msgArgs.DateCreated)} " +
$"{msgArgs.From}: {msgArgs.Text}{Environment.NewLine}";
}
OnNewMessage.Invoke(this, msgArgs);
}
private void _webSocket_OnMessage(string message)
{
try
{
if (Debug)
{
WriteLine($"New Message, Message: {message}");
}
_lastMessageTime = DateTime.Now;
// check if this is a keep alive
if (message == "{{}}")
{
return;
}
if (message.Trim() == "")
{
return;
}
var msg = JsonConvert.DeserializeObject <WsResponse>(message);
if (msg.S != null && msg.S == 1)
{
// this is an init message lets confirm
SignalR.Start(_httpHost, _connectionToken, _hubs);
return;
}
// record the related info
_lastMessageId = msg.C;
if (!string.IsNullOrEmpty(msg.G))
{
_groupsToken = msg.G;
}
// invoke the event
if (msg.M != null && msg.M.Any() || msg.R != null || !string.IsNullOrEmpty(msg.I) ||
!string.IsNullOrEmpty(msg.C))
{
Task.Run(() => { OnNewMessage?.Invoke(msg); });
}
}
catch (Exception e)
{
Console.WriteLine($"SignalR Message Error: {e.Message}");
}
}
internal override bool DoWork()
{
try
{
if (!_connection.TryReceiveMessage(out var serializedMessage))
{
return(false);
}
OnNewMessage?.Invoke(serializedMessage);
}
catch (Exception e)
{
throw new ConnectionException("Cannot receive a message", e);
}
return(true);
}
void ConveyorProcedure()
{
while (!_exitToken)
{
while (true)
{
RequestMessage message;
_queue.TryDequeue(out message);
if (message == null)
{
break;
}
OnNewMessage?.Invoke(this, message);
}
_onNewMessage.WaitOne(4000);
}
}
/// <summary>
/// 处理接受的数据
/// </summary>
/// <param name="socket"></param>
private void Recieve(IAsyncResult socket)
{
Socket SockeClient = (Socket)socket.AsyncState;
string IP = SockeClient.RemoteEndPoint.ToString();
if (SockeClient == null || !SessionPool.ContainsKey(IP))
{
return;
}
var client = SessionPool[IP];
string clientMsg = string.Empty;
try
{
int length = SockeClient.EndReceive(socket);
if (length == 0)
{
Disconnect(client, IP);
return;
}
byte[] buffer = SessionPool[IP].buffer;
SockeClient.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(Recieve), SockeClient);
try
{
clientMsg = AnalyzeClientData(buffer, length);
}
catch (Exception ex)
{
MessageBox.Show($"处理客户端数据时发生异常:{ex.Message}");
}
}
catch (Exception ex)
{
MessageBox.Show("接收客户端数据时发生异常:" + ex.Message);
try
{
SockeClient.Disconnect(true);
}
catch { }
Disconnect(client, IP);
}
OnNewMessage?.Invoke(this, new ClientNewMessageEventArgs(client, clientMsg));
}
internal override bool DoWork()
{
if (!_messageQueue.TryDequeue(out var serializedMessage))
{
return(false);
}
try
{
var message = _dataContractOperations.Deserialize(serializedMessage);
OnNewMessage?.Invoke(message);
}
catch (Exception e)
{
throw new SerializationException("Cannot deserialize the emessage.", e);
}
return(true);
}
private async Task GetMessages()
{
_cts = new CancellationTokenSource();
try
{
while (await _stream.ResponseStream.MoveNext(_cts.Token))
{
var m = _stream.ResponseStream.Current;
var token = _cts.Token;
Interfaces.AnalogyLogMessage msg = new Interfaces.AnalogyLogMessage()
{
Category = m.Category,
Level = (AnalogyLogLevel)m.Level,
Class = (AnalogyLogClass)m.Class,
Date = m.Date.ToDateTime().ToLocalTime(),
FileName = m.FileName,
LineNumber = m.LineNumber,
MachineName = m.MachineName,
MethodName = m.MethodName,
Module = m.Module,
ProcessId = m.ProcessId,
Source = m.Source,
Text = m.Text,
ThreadId = m.ThreadId,
User = m.User
};
msg.Id = string.IsNullOrEmpty(m.Id)
? Guid.NewGuid()
: Guid.TryParse(m.Id, out Guid id) ? id : Guid.NewGuid();
OnNewMessage?.Invoke(this, msg);
if (token.IsCancellationRequested)
{
break;
}
}
}
catch (Exception e)
{
OnError?.Invoke(this, e.Message);
}
}
internal override bool DoWork()
{
if (!_messageQueue.TryDequeue(out var message))
{
return(false);
}
try
{
_dataContractOperations
.CallRoute(message)
.ToList()
.ForEach(x => OnNewMessage?.Invoke(x));
}
catch (Exception e)
{
throw new SubscriberException("The subscriber code throws an exception.", e);
}
return(true);
}
private void ConnectSocketClient()
{
if (_socketClient != null)
{
return;
}
_socketClient = CreateClient(_token);
if (_socketClient == null)
{
return;
}
_socketClient.OnMessageReceived += msg =>
{
var channelMsg = msg.ToChannelMessage();
_newMessages.Add(channelMsg);
OnNewMessage?.Invoke(channelMsg);
};
}
