/// <summary>
/// Receives inbound message while the message receiver is running.
/// </summary>
private void Receive()
{
var endPoint = new IPEndPoint(IPAddress.Any, Port);
while (IsRunning)
{
try
{
var received = _client.Receive(ref endPoint);
var ip = endPoint.Address;
if (!IsBlacklisted(ip))
{
try
{
var message = _messageParser.Parse(received);
OnMessageReceived(new MessageReceivedEventArgs(message));
}
catch (MessageException)
{
// Failed to parse message.
}
}
}
catch
{
Stop();
throw;
}
}
}
public void StartListener(IMessageStorage storage, IMessageParser parser)
{
bool done = false;
UdpClient listener = new UdpClient(_port);
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, _port);
try
{
while (!done)
{
byte[] bytes = listener.Receive(ref endPoint);
if (bytes.Length > MaxMessageLength)
{
continue;
}
var rawmessage = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
storage.Add(parser.Parse(rawmessage, endPoint.Address));
}
}
catch (Exception ex)
{
}
finally
{
listener.Close();
}
}
public void StartListener(IMessageStorage storage, IMessageParser parser)
{
bool done = false;
UdpClient listener = new UdpClient(_port);
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, _port);
try
{
while (!done)
{
byte[] bytes = listener.Receive(ref endPoint);
if (bytes.Length > MaxMessageLength)
continue;
var rawmessage = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
storage.Add(parser.Parse(rawmessage, endPoint.Address));
}
}
catch (Exception ex)
{
}
finally
{
listener.Close();
}
}
public void OnNext(string value)
{
if (!string.IsNullOrEmpty(value))
{
_parser.Parse(value);
}
}
private string ParseString(string message)
{
message = message.WithoutStxEtxEnvelope().Trim();
IMessageParser parser = _parserFactory.GetParser(message);
BaseParseResult result = parser.Parse(message);
// todo: evaluate
// It's not possible to determine if hex is a request or response value, check is now based on ErrorParseResult
if (result is ErrorParseResult)
{
parser = _parserFactory.GetParser(typeof(MiniResponse));
result = parser.Parse(message);
}
return(JsonConvert.SerializeObject(result, Formatting.Indented, new Newtonsoft.Json.Converters.StringEnumConverter()));
}
private static void Process(byte[] buffer)
{
var messages = _messageParser.Parse(buffer);
foreach (var message in messages)
{
if (message != null)
{
Console.WriteLine($"{DateTime.Now.ToLongTimeString()} RoomId: {message.RoomId}, ClientId: {message.ClientId}, Text = {message.Text}");
}
}
}
private IMessage Parse(ConsumeResult <Guid, byte[]> result)
{
try
{
return(_messageParser.Parse(result));
}
catch (Exception ex)
{
_logger.LogError(ex, "an exception has occurred while consuming a message: {Exception}", ex.Message);
return(null);
}
}
static void Main(string[] args)
{
_parser = new FileContentParser();
var files = new DirectoryInfo(@"c:\temp").GetFiles();
foreach (var file in files)
{
string content = CleanUpContent(File.ReadAllText(file.FullName));
var message = _parser.Parse(content);
WriteMesaageFile(message, content);
}
}
public ADSBMessageBase BuildMessage(string sentence)
{
string message = parser.Parse(sentence);
string payload = parser.ParsePayload(message).ToBin();
ADSBMessagetype type = parser.ParseMessagetype(payload);
if (type == ADSBMessagetype.undefined)
{
return(null);
}
return(builderMethods[type].Invoke(message));
}
private void Wc_Received(object sender, string e)
{
//{"type":"watch","body":{"command":"statistics","params":["10","0","0","0"]}}
//{"type":"watch","body":{"command":"servertime","params":["1559238662759"]}}
//{"type":"watch","body":{"command":"permit","params":["11638528803398"]}}
//{"type":"watch","body":{"currentStream":{"uri":"https://pa03503c0e0.dmc.nico/hlslive/ht2_nicolive/nicolive-production-pg11638528803398_f8b21634cfbd88ba8cb0d160255872f680386cb5cb850fabca8b791423079e13/master.m3u8?ht2_nicolive=2297426.sh06gy_psbw92_do4o0yyhuyix","name":null,"quality":"abr","qualityTypes":["abr","high","normal","low","super_low"],"mediaServerType":"dmc","mediaServerAuth":null,"streamingProtocol":"hls"},"command":"currentstream"}}
//{"type":"watch","body":{"room":{"messageServerUri":"wss://msg.live2.nicovideo.jp/u10199/websocket","messageServerType":"niwavided","roomName":"co3860652","threadId":"1651504725","forks":[0],"importedForks":[]},"command":"currentroom"}}
//{"type":"watch","body":{"command":"statistics","params":["10","0","0","0"]}}
//{"type":"watch","body":{"command":"watchinginterval","params":["30"]}}
//{"type":"watch","body":{"update":{"begintime":1559237439000,"endtime":1559248239000},"command":"schedule"}}
//{"type":"ping","body":{}}
//{"type":"watch","body":{"command":"statistics","params":["10","0","0","0"]}}
//{"type":"ping","body":{}}
var raw = e;
IInternalMessage internalMessage;
try
{
internalMessage = _messageParser.Parse(raw);
}
catch (ParseException ex)
{
//_logger.
return;
}
catch (Exception ex)
{
//_logger.
return;
}
switch (internalMessage)
{
case IPing _:
{
SendPong();
}
break;
default:
MessageReceived?.Invoke(this, internalMessage);
break;
}
}
public string ParseMessage(string subj, string sender, IMessageParser parser)
{
SearchCondition condition = new SearchCondition();
if (this.m_host == "gmail.com")
{
DateTime messageTime = new DateTime(2000, 9, 28);
condition.Value = string.Format(@"X-GM-RAW ""AFTER:{0:yyyy-MM-dd}""", messageTime);
}
else
{
condition = SearchCondition.Undeleted();
}
var msgs = m_client.SearchMessages(condition);
List <Lazy <MailMessage> > resultMessages = new List <Lazy <MailMessage> >();
foreach (var msg in msgs)
{
if (msg.Value.Subject == subj && msg.Value.From.Address == sender)
{
resultMessages.Add(msg);
}
}
resultMessages.Sort((x, y) =>
x.Value.Date.CompareTo(y.Value.Date)
);
if (resultMessages.Count == 0)
{
ExceptionUtils.SetState(Error.E_DATA_NOT_FOUND);
return("");
}
return(parser.Parse(resultMessages[resultMessages.Count].Value.Body));
}
public async Task ProcessFileAsync(string filePath)
{
var messageLines = _reader.ReadMessagesAsync(filePath).GetAsyncEnumerator();
var tasks = new List <Task <NiceMessage> >();
var stopWatch = new Stopwatch();
stopWatch.Start();
while (await messageLines.MoveNextAsync())
{
tasks.Add(Task.Run(() => _parser.Parse(messageLines.Current)));
}
await Task.WhenAll(tasks.ToArray());
stopWatch.Stop();
Console.WriteLine($"Elapsed Time {stopWatch.ElapsedMilliseconds}ms");
//await Task.Delay(15000);
//foreach (var task in tasks)
//{
// _writer.Write(task.Result);
//}
}
public ICommand ProcessMessage(Update update)
{
long userId = -1;
switch (update.Type)
{
case UpdateType.CallbackQuery:
userId = update.CallbackQuery.Message.Chat.Id;
break;
case UpdateType.Message:
userId = update.Message.Chat.Id;
break;
}
var userEntity = userRepository.FindByTelegramId(userId) ??
userRepository.Insert(new UserEntity(new UnknownUserState(), userId, Guid.NewGuid(), 0));
var state = userEntity.CurrentState;
var transition = parser.Parse(state, update, quizService, logger);
logger.LogInformation($"Parsed transition {transition}");
logger.LogInformation($"Parsed state {state}");
if (transition is CorrectTransition correct)
{
logger.LogInformation($"State content: {correct.Content}");
}
var(currentState, currentCommand) = stateMachine.GetNextState(state, transition);
logger.LogInformation($"New state {currentState}");
userRepository.Update(new UserEntity(currentState, userId, userEntity.Id, userEntity.MessageId, userEntity.CurrentTask));
return(currentCommand);
}
public void Parse() => _parser.Parse(_message);
public void ParseStruct() => _parser.Parse(_message);
public void Parse_DataLengthLessThan6_ShouldThrowMessageException()
{
Parser.Parse(Enumerable.Repeat((byte)0, 5).ToArray());
}
public void ParseString() => _parser.Parse(Message.Value);
private void DataReceived(IAsyncResult ar)
{
var connection = (SocketConnectionInfo)ar.AsyncState;
var socket = ((SocketConnectionInfo)ar.AsyncState).Socket;
try
{
var bytesRead = connection.Socket.EndReceive(ar);
connection.BytesRead += bytesRead;
if (!IsSocketConnected(connection.Socket))
{
// client disconnected but we have some data in buffer to read
if (connection.BytesRead <= 0)
{
return;
}
// there is a chance that we have more than one packet in buffer
var messages = _messageParser.Parse(connection.Buffer);
foreach (var message in messages)
{
ProcessMessage(message, socket);
}
return;
}
if (bytesRead == 0 || (bytesRead > 0 && bytesRead < SocketConnectionInfo.BufferSize))
{
var buffer = new byte[connection.Buffer.Length];
connection.Buffer.CopyTo(buffer, 0);
// there is a chance that we have more than one packet in buffer
var messages = _messageParser.Parse(buffer).ToList();
foreach (var message in messages)
{
ProcessMessage(message, socket);
}
if (connection.ClientId == null)
{
// associate connection to client id
var msg = messages.FirstOrDefault(m => m != null);
if (msg != null)
{
connection.ClientId = msg.ClientId;
}
}
// clear buffer for next packet
Array.Clear(connection.Buffer, 0, connection.Buffer.Length);
connection.BytesRead = 0;
connection.Socket.BeginReceive(connection.Buffer, 0, connection.Buffer.Length, SocketFlags.None, DataReceived,
connection);
}
else
{
// resize array if we have a large amount of data to receive
Array.Resize(ref connection.Buffer, connection.Buffer.Length + SocketConnectionInfo.BufferSize);
connection.Socket.BeginReceive(connection.Buffer, 0, connection.Buffer.Length, SocketFlags.None, DataReceived,
connection);
}
}
catch (SocketException)
{
// client disconnected
if (connection.ClientId != null)
{
_rooms.Remove(connection.ClientId);
}
// client disconnected but we might have some data in buffer to read
if (connection.BytesRead > 0)
{
var messages = _messageParser.Parse(connection.Buffer);
foreach (var message in messages)
{
ProcessMessage(message, socket);
}
}
}
catch (ObjectDisposedException)
{
// ignore the situation when socket was disposed while trying to read from it
}
catch (Exception ex)
{
FireOnError(ex);
}
finally
{
if (IsSocketConnected(socket))
{
socket.BeginReceive(connection.Buffer, 0, connection.Buffer.Length, SocketFlags.None, DataReceived, connection);
}
}
}
