public RobotConnectionService(IStreamResource streamResource)
{
_streamResource = streamResource;
_watchdog = new Watchdog(1100); //this should be minimum 2x keepAlive sending period
_watchdog.TimeoutOccured += (sender, args) => TimeoutOccured?.Invoke(sender, args);
//TODO unifiy the error event args, so we can use one common event handler
var messageExtractor = new MessageExtractor();
messageExtractor.KeepAliveReceived += (sender, args) => _watchdog.ResetWatchdog();
messageExtractor.MessageLostOccured +=
(sender, args) => Logger.Fatal($"Lost message, total count: {args.TotalLostCount}");
messageExtractor.SpeedCurrentFeedbackReceived += (sender, args) => SpeedCurrentFeedbackReceived?.Invoke(sender, args);
messageExtractor.VoltageTemperatureFeedbackReceived += (sender, args) => VoltageTemperatureFeedbackReceived?.Invoke(sender, args);
messageExtractor.ParametersReceived += (sender, args) => ParametersReceived?.Invoke(sender, args);
_receiverTask = new ReceiverTask(_streamResource);
_receiverTask.ErrorOccurred += (sender, args) => Logger.Error($"Receiver task error: {args.GetException().Message}");
_receiverTask.DataReceived += (sender, args) => messageExtractor.TryGetMessage(args.Data);
_receiverTask.Start();
_senderQueue = new SendQueueWrapper();
_senderTask = new SenderTask(_streamResource, _senderQueue);
_senderTask.ErrorOccurred += (sender, args) => Logger.Error($"Sender task error: {args.GetException().Message}");
_senderTask.Start();
_watchdog.Start();
}
private void InitializeTcpClient()
{
var callback = new ChatCallback
{
OnConnected = () =>
Dispatcher.Invoke(() => PrintMessage("Pomyślnie połączono z " + IpAddress + ":" + Port)),
OnMessageReceived = message => Dispatcher.Invoke(() =>
{
var format = MessageExtractor.Extract(message);
if (format == string.Empty)
{
return;
}
var msg = InformationConverter.Deserialize(format);
if (mutedUsers.Contains(msg.Nick))
{
return;
}
switch (msg.Type)
{
case InformationType.Message:
PrintUserLine(msg.Nick, msg.Message);
break;
case InformationType.Voice:
{
if (!UsersSpeakingTextBlock.Text.Contains(msg.Nick))
{
UsersSpeakingTextBlock.Text += "\uD83D\uDD0A" + msg.Nick + Environment.NewLine;
}
var byteMessage = Convert.FromBase64String(msg.Message);
_audioManager.Play(byteMessage);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}),
OnDisconnected = () => Dispatcher.Invoke(() =>
{
_client.Disconnect();
Environment.Exit(0);
}),
OnCannotConnect = () => Dispatcher.Invoke(() =>
{
var formattedMessage = new ColoredMessageBuilder()
.With("Nie można połączyć się z serwerem. Sprawdź dane połączenia.")
.Build();
ChatBlock.Document.Blocks.Add(formattedMessage);
ShowConnectionDialog();
ConnectToServer();
})
};
_client = new TCPClient(callback);
ConnectToServer();
}
private static ChatCallback CreateChatCallback()
{
return(new ChatCallback
{
OnConnected = () =>
{
_isConnected = true;
Console.WriteLine("Zostałeś połączony z serwerem. Możesz zacząć pisać!");
},
OnMessageReceived = message =>
{
var formattedMessage = MessageExtractor.Extract(message);
var information = InformationConverter.Deserialize(formattedMessage);
if (information.Type == Message)
{
Console.WriteLine($"{information.Nick} : {information.Message}");
}
},
OnCannotConnect = () =>
{
_isConnected = false;
Console.WriteLine("Brak połączenia z serwerem. Sprawdź dane połączenia oraz spróbuj ponownie.");
}
});
}
public void Decode(string file)
{
var message = MessageExtractor.ExtractMessage(file);
var messageBeforeRLE = ApplyReverseRLETransformation(message);
var decodedMessage = BuildReverseBWTable(messageBeforeRLE);
MessageFileWriter.WriteEncodedMessageToFile("output.txt", decodedMessage);
}
public void ShouldReturnEmptyStringIfNoClosingBracketAvailable()
{
var message = "aaa{aaa{aaa{aa{a{{a{";
var convertedMessage = MessageExtractor.Extract(message);
convertedMessage.Should().BeEquivalentTo(string.Empty);
}
public void AggregateCommandIdentityExtractor_InValidObject_ThrowsArgumentException()
{
var message = string.Empty;
var shardResolver = new MessageExtractor <TestAggregate, TestAggregateId>(10);
this.Invoking(test => shardResolver.EntityId(message))
.Should().Throw <ArgumentException>()
.WithMessage(nameof(message));
}
public void AggregateSagaIdentityExtractor_InValidObject_ThrowsArgumentNullException()
{
DomainEvent <TestAggregate, TestAggregateId, TestSentEvent> message = null;
var shardResolver = new MessageExtractor <TestSagaManager, TestSaga, TestSagaId, TestSagaLocator>(10);
// ReSharper disable once ExpressionIsAlwaysNull
this.Invoking(test => shardResolver.EntityId(message))
.Should().Throw <ArgumentNullException>();
}
public void AggregateCommandIdentityExtractor_InValidObject_ThrowsArgumentNullException()
{
CreateTestCommand message = null;
var shardResolver = new MessageExtractor <TestAggregate, TestAggregateId>(10);
// ReSharper disable once ExpressionIsAlwaysNull
this.Invoking(test => shardResolver.EntityId(message))
.Should().Throw <ArgumentNullException>();
}
public ActionResult POST([FromBody] MessageDto message, [FromServices] MessageExtractor extractor)
{
message.operation = extractor.GetServiceIdentifier(message);
message.request.formatted_data = extractor.AddHeadersToDictionary(extractor.ElementStructure(message?.request?.raw_data), message.request.headers);
extractor.AppendQueryParams(message.request.formatted_data, message.service);
message.response.formatted_data = extractor.AddHeadersToDictionary(extractor.ElementStructure(message?.response?.raw_data), message.response.headers);
return(Ok(message));
}
public static SiweMessage ParseUsingAbnf(string siweMessage)
{
var siweMessageRule =
Parser.Parse(
"sign-in-with-ethereum",
siweMessage);
var visitor = new MessageExtractor();
siweMessageRule.Accept(visitor);
return(visitor.SiweMessage);
}
public void AggregateCommandIdentityExtractor_ValidMessage_ExtractsShardValue(int shardSize)
{
var aggregateId = TestAggregateId.New;
var commandId = CommandId.New;
var message = new CreateTestCommand(aggregateId, commandId);
var shardResolver = new MessageExtractor <TestAggregate, TestAggregateId>(shardSize);
var extractedShard = shardResolver.ShardId(message);
var extractedShardValue = int.Parse(extractedShard);
extractedShardValue.Should().BeInRange(0, shardSize);
}
private bool ExtractMessage(byte[] buffer, int bytesRead)
{
if (buffer != null)
{
_readBuffer.Append(Encoding.ASCII.GetChars(buffer, 0, bytesRead));
}
var nextMessage = MessageExtractor.Extract(_readBuffer);
if (nextMessage != null)
{
Message = nextMessage;
}
return(nextMessage != null);
}
//test comment
public void Encode(string file)
{
var message = MessageExtractor.ExtractMessage(file);
var frequencyTable = SymbolFrequencyCounter.CountFrequenciesForLetters(message);
var tree = new BinaryTree <int, string>();
var charSequence = string.Empty;
foreach (var c in frequencyTable)
{
charSequence += c.Key;
}
tree.Add(message.Length, charSequence);
//отдельно выделить случай сообщения из одной повторяющейся буквы
var currentLevelNode = tree.Root;
while (tree.CountLeaves(tree.Root) != frequencyTable.Count)
{
var currentHalf = currentLevelNode.Key / 2;
var currentSum = 0;
var currentPositionOfDivision = 0;
var firstNodeString = string.Empty;
while (currentSum <= currentHalf)
{
firstNodeString += frequencyTable.ElementAt(currentPositionOfDivision).Key;
currentSum += frequencyTable.ElementAt(currentPositionOfDivision).Value;
currentPositionOfDivision++;
}
var secondNodeString = currentLevelNode.Value.Substring(currentPositionOfDivision + 1,
currentLevelNode.Value.Length - currentPositionOfDivision);
tree.Add(currentSum, firstNodeString);
tree.Add(currentLevelNode.Key - currentSum, secondNodeString);
if (currentLevelNode.Left.Value.Length != 1)
{
currentLevelNode = currentLevelNode.Left;
}
else if (currentLevelNode.Right.Value.Length != 1)
{
currentLevelNode = currentLevelNode.Right;
}
}
}
public void Encode(string file)
{
var message = MessageExtractor.ExtractMessage(file);
GetFrequencyTable(message);
while (_frequencyTable.Count > 1)
{
AddNewLeaf();
}
SetCodes();
var encodedMessage = MakeCode(message);
MessageFileWriter.WriteEncodedMessageToFile("HuffmanEncoderOutput.txt", encodedMessage);
}
public void Encode(string file)
{
var message = MessageExtractor.ExtractMessage(file);
var dictionary = new Dictionary <string, int>();
var encodedMessage = String.Empty;
var newEntrylength = 1;
for (int i = 0; i < message.Length; i += newEntrylength)
{
newEntrylength = 1;
var newEntry = message.Substring(i, newEntrylength);
while (dictionary.ContainsKey(newEntry))
{
newEntrylength++;
newEntry = message.Substring(i, newEntrylength);
}
if (newEntrylength == 1)
{
if (!dictionary.ContainsKey(newEntry))
{
dictionary.Add(newEntry, dictionary.Count + 1);
encodedMessage += "0" + newEntry;
}
else
{
newEntrylength++;
encodedMessage += dictionary[newEntry] + message[newEntrylength];
dictionary.Add(message.Substring(i, newEntrylength), dictionary.Count + 1);
}
}
else
{
encodedMessage += dictionary[newEntry.Substring(0, newEntrylength - 1)] +
newEntry.Substring(newEntrylength - 1, 1);
dictionary.Add(newEntry, dictionary.Count + 1);
}
}
//test comment 2
MessageFileWriter.WriteEncodedMessageToFile("output.txt", encodedMessage);
}
public void Encode(string file)
{
var message = MessageExtractor.ExtractMessage(file);
var messageAfterBW = ApplyBWTransformation(message);
var messageAfterRLE = string.Empty;
int increment = 0;
for (int i = 0; i < message.Length; i += increment)
{
var currentCharacter = messageAfterBW.Key.Substring(i, 1);
increment = 0;
var nextCharacterPosition = i + increment + 1;
if (nextCharacterPosition < message.Length)
{
while (messageAfterBW.Key.Substring(nextCharacterPosition, 1) == currentCharacter)
{
increment++;
nextCharacterPosition++;
if (nextCharacterPosition >= message.Length)
{
break;
}
}
}
if (increment == 0)
{
messageAfterRLE += currentCharacter;
increment++;
}
else
{
increment++;
messageAfterRLE += currentCharacter + increment;
}
}
messageAfterRLE += " " + messageAfterBW.Value;
MessageFileWriter.WriteEncodedMessageToFile("output1.txt", messageAfterRLE);
}
public void AggregateSagaIdentityExtractor_ValidMessage_ExtractsShardValue(int shardSize)
{
var aggregateId = TestAggregateId.New;
var receiverId = TestAggregateId.New;
var testId = TestId.New;
var test = new Test(testId);
var now = DateTimeOffset.UtcNow;
var aggregateSequenceNumber = 3;
var message =
new DomainEvent <TestAggregate, TestAggregateId, TestSentEvent>(
aggregateId,
new TestSentEvent(test, receiverId),
new Metadata(),
now,
aggregateSequenceNumber);
var shardResolver = new MessageExtractor <TestSagaManager, TestSaga, TestSagaId, TestSagaLocator>(shardSize);
var extractedShard = shardResolver.ShardId(message);
var extractedShardValue = int.Parse(extractedShard);
extractedShardValue.Should().BeInRange(0, shardSize);
}
public void Decode(string file)
{
var message = MessageExtractor.ExtractMessage(file);
var dictionary = new Dictionary <int, string>();
var decodedMessage = string.Empty;
int symbolPosition = 0;
int numberPosition = 0;
int numberLength = 0;
int newNumber = 0;
while (symbolPosition <= message.Length - 1 && numberPosition <= message.Length - 2)
{
numberLength = 0;
while (numberPosition + numberLength <= message.Length - 2 && char.IsDigit(message[numberPosition + numberLength]))
{
numberLength++;
}
int.TryParse(message.Substring(numberPosition, numberLength), out newNumber);
symbolPosition = numberPosition + numberLength;
if (newNumber == 0)
{
dictionary.Add(dictionary.Count + 1, message[symbolPosition].ToString());
decodedMessage += message[symbolPosition];
}
else
{
dictionary.Add(dictionary.Count + 1, dictionary[newNumber] + message[symbolPosition]);
decodedMessage += dictionary[newNumber] + message[symbolPosition];
}
numberPosition = symbolPosition + 1;
}
MessageFileWriter.WriteEncodedMessageToFile("output.txt", decodedMessage);
}
public void ShouldExtractMessageProperlyWhenMessageIsCorrect(string message)
{
var convertedMessage = MessageExtractor.Extract(CorrectMessage);
convertedMessage.Should().Be(CorrectMessage);
}
/// <summary>
/// Extracts the message.
/// </summary>
/// <param name="regex">The regex.</param>
/// <param name="input">The input.</param>
/// <param name="extractor">The extractor.</param>
/// <returns></returns>
private static StringBuilder CleanDirtyMessage(Regex regex, StringBuilder input, MessageExtractor extractor)
{
Match match = regex.Match(input.ToString());
return(match.Success ?
input.Replace(match.Groups[0].Value, extractor.Invoke(match)) :
input);
}
public SocketReader(ProcessorConfig config)
: base(config)
{
m_Extractor = new MessageExtractor();
}
