public void TestKeyFrame(ProcessDataPointValue dataPoint)
{
ProcessDataSet dataSet = new ProcessDataSet("test-publisher", "test001", 123, ProcessDataSet.DataSetType.TimeSeries);
dataSet.AddDataPoint(dataPoint);
DecodeMessage decoder = new DecodeMessage();
byte[] encodedMeta = dataSet.GetEncodedMetaFrame(new EncodingOptions(), 1, true);
byte[] encodedKey = dataSet.GetEncodedKeyFrame(2);
NetworkMessage metaNetworkMessage = decoder.ParseBinaryMessage(encodedMeta);
Assert.That(metaNetworkMessage, Is.Not.Null);
Assert.That(metaNetworkMessage, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(metaNetworkMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.False);
NetworkMessage keyNetworkMessage = decoder.ParseBinaryMessage(encodedKey);
Assert.That(keyNetworkMessage, Is.Not.Null);
Assert.That(keyNetworkMessage, Is.InstanceOf(typeof(KeyFrame)));
Assert.That(keyNetworkMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.True);
KeyFrame decodedKeyMessage = (KeyFrame)keyNetworkMessage;
ProcessDataPointValue decodedDataPoint = (ProcessDataPointValue)decodedKeyMessage.Items[0];
Common.AssertDataPointsAreEqual(dataPoint, decodedDataPoint);
Assert.That(decodedKeyMessage, Is.Not.Null);
Assert.That(decodedKeyMessage.Items, Is.Not.Empty);
Assert.That(decodedKeyMessage.Items.Count, Is.EqualTo(1));
Assert.That(decodedKeyMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.True);
}
public void Subscribe(string topic = null)
{
if (!IsConnected)
{
Console.Error.WriteLine("No connection for client: " + ClientId);
throw new Exception("No connection for client: " + ClientId);
}
if (topic == null)
{
topic = Settings.Client.DefaultSubscribeTopicName;
}
if (m_DecoderTask == null && !Settings.Client.RawDataMode)
{
m_MessageQueue = new ConcurrentQueue <DecodeMessage.MqttMessage>();
m_Decoder = new DecodeMessage(m_MessageQueue, Options);
m_Decoder.MessageDecoded += DecoderOnMessageDecoded;
m_DecoderTask = Task.Run(() => m_Decoder.Start());
}
m_MqttClient.SubscribeAsync(new MqttTopicFilter
{
Topic = topic,
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce
}
).Wait();
Logger.Debug($"MQTT SubscribeAsync DONE, Topic: {topic}");
}
public async Task SendSmsQuery()
{
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("isTest", "false"),
new KeyValuePair <string, string>("goformId", "SEND_SMS"),
new KeyValuePair <string, string>("notCallback", "true"),
new KeyValuePair <string, string>("Number", "+79117495435"),
new KeyValuePair <string, string>("sms_time", DecodeMessage.GetCurrentTimeString()),
new KeyValuePair <string, string>("MessageBody", DecodeMessage.EncodeMessage("Privet,!.134577 Егор")),
new KeyValuePair <string, string>("ID", "-1"),
new KeyValuePair <string, string>("encode_type", "UNICODE")
});
using (var myHttpClient = new HttpClient())
{
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(true);
var response = await myHttpClient.PostAsync("http://192.168.0.1" + Constants.Constants.POSTURLPREFIX, formContent);
if (response.IsSuccessStatusCode)
{
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(false);
}
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(false);
}
}
public void KeyFrame(List <ProcessDataPointValue> dataPoints)
{
ProcessDataSet dataSet = new ProcessDataSet("test-publisher", "test001", 123, ProcessDataSet.DataSetType.TimeSeries);
foreach (ProcessDataPointValue dataPoint in dataPoints)
{
dataSet.AddDataPoint(dataPoint);
}
DecodeMessage decoder = new DecodeMessage();
byte[] encodedMeta = dataSet.GetEncodedMetaFrame(new EncodingOptions(), 1, true);
byte[] encodedKey = dataSet.GetEncodedKeyFrame(2);
NetworkMessage metaNetworkMessage = decoder.ParseBinaryMessage(encodedMeta);
Assert.That(metaNetworkMessage, Is.Not.Null);
Assert.That(metaNetworkMessage, Is.InstanceOf(typeof(MetaFrame)));
NetworkMessage keyNetworkMessage = decoder.ParseBinaryMessage(encodedKey);
Assert.That(keyNetworkMessage, Is.Not.Null);
Assert.That(keyNetworkMessage, Is.InstanceOf(typeof(KeyFrame)));
KeyFrame decodedKeyMessage = (KeyFrame)keyNetworkMessage;
Assert.That(decodedKeyMessage, Is.Not.Null);
Assert.That(decodedKeyMessage.Items, Is.Not.Empty);
Assert.That(decodedKeyMessage.Items.Count, Is.EqualTo(dataPoints.Count));
Assert.That(decodedKeyMessage.Items, Is.EqualTo(dataPoints));
}
public async Task <DTOBeelineMessages> GetAllMessages()
{
using (var client = new HttpClient())
{
var uri = new Uri(Constants.Constants.BASEMODEMURL + Constants.Constants.GETURLPREFIX)
.AddQuery("isTest", "false")
.AddQuery("cmd", "sms_data_total")
.AddQuery("page", "0")
.AddQuery("data_per_page", "500")
.AddQuery("mem_store", "1")
.AddQuery("tags", "10")
.AddQuery("order_by", "order+by+number");
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(true);
var result = await client.GetAsync(uri);
if (result.IsSuccessStatusCode)
{
var stringResponse = await result.Content.ReadAsStringAsync();
//TODOs : use custom converter.
var jsonResponse = JsonConvert.DeserializeObject <DTOBeelineMessages>(stringResponse);
foreach (var message in jsonResponse.messages)
{
message.content = DecodeMessage.Decode(message.content);
}
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(false);
return(jsonResponse);
}
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(false);
return(null);
}
}
public async Task <bool> SendSms(Message message)
{
var formContent = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("isTest", "false"),
new KeyValuePair <string, string>("goformId", "SEND_SMS"),
new KeyValuePair <string, string>("notCallback", "true"),
new KeyValuePair <string, string>("Number", message.Number),
new KeyValuePair <string, string>("sms_time", DecodeMessage.GetCurrentTimeString()),
new KeyValuePair <string, string>("MessageBody", DecodeMessage.EncodeMessage(message.Text)),
new KeyValuePair <string, string>("ID", "-1"),
new KeyValuePair <string, string>("encode_type", "UNICODE")
});
using (var myHttpClient = new HttpClient())
{
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(true);
var response = await myHttpClient.PostAsync(Constants.Constants.BASEMODEMURL + Constants.Constants.POSTURLPREFIX, formContent);
if (response.IsSuccessStatusCode)
{
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(false);
return(true);
}
UnsafeHeaderParsing.SetAllowUnsafeHeaderParsing(false);
return(false);
}
}
public void DecodeM()
{
string input =
"0053006B006F006400610020004600610062006900610020043D043000200441043C0435043B044B0445002004430441043B043E04320438044F0445002100200421043F04350448043804420435002004320020041004320442043E002004130430043C043C0443002100200418043D0444043E0020003300340037002D00380036002D00330032";
var result = DecodeMessage.Decode(input);
Assert.AreEqual("1", "1");
}
public void Setup()
{
EncodingOptions options = new EncodingOptions
{
LegacyFieldFlagEncoding = true
};
Decoder = new DecodeMessage(options);
TestDataFolder = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly()
.Location
),
"Regression",
"TypeA"
);
}
public void SetUp()
{
TestDataFolder = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly()
.Location
),
"Regression",
"TypeB",
"TimeSeries"
);
Decoder = new DecodeMessage(new EncodingOptions
{
LegacyFieldFlagEncoding = false
}
);
}
private async Task HandleMessage(BeelineMessage message)
{
if (message.tag == "0" || message.tag == "1")
{
var smsMessage = new SmsMessage(
message.number,
message.content,
DateTime.Now,
Direction.input,
Status.input,
DecodeMessage.ParseDate(message.date),
DateTime.Now,
false);
_repository.AddSmsMessage(smsMessage);
}
await _client.DeleteMessage(message.id);
}
public void SchemaVersion()
{
var data = message.ToArray();
Assert.Equal(ParseResult.Success, DecodeMessage.TryParse(data, out DecodeMessage decodeMessage));
Assert.Equal(2, decodeMessage.SchemaVersion);
Assert.Equal("WSJT-X", decodeMessage.Id);
Assert.True(decodeMessage.New);
Assert.Equal(TimeSpan.FromSeconds(29820), decodeMessage.SinceMidnight);
Assert.Equal(-12, decodeMessage.Snr);
Assert.Equal(0.3, Math.Round(decodeMessage.DeltaTime, 1));
Assert.Equal(367, decodeMessage.DeltaFrequency);
Assert.Equal("~", decodeMessage.Mode);
Assert.Equal("EC1AIJ US2YW KN28", decodeMessage.Message);
Assert.False(decodeMessage.LowConfidence);
Assert.False(decodeMessage.OffAir);
}
public void Disconnect()
{
if (m_Decoder != null)
{
m_Decoder.MessageDecoded -= DecoderOnMessageDecoded;
m_Decoder.Stop();
}
if (m_MqttClient != null)
{
if (m_MqttClient.IsConnected)
{
//m_MqttClient.UnsubscribeAsync(Settings.Client.ClientCertP12).Wait();
m_MqttClient.ApplicationMessageReceivedHandler = null;
m_MqttClient.DisconnectedHandler = null;
}
try
{
m_MqttClient.DisconnectAsync()
.Wait(TimeSpan.FromSeconds(5));
}
catch (TaskCanceledException) { } //don't know why this happens always...
finally
{
m_MqttClient.Dispose();
}
}
m_DecoderTask?.Wait();
m_MessageQueue = null;
m_Decoder = null;
if (m_DecoderTask != null)
{
m_DecoderTask.Dispose();
m_DecoderTask = null;
}
m_MqttClient = null;
ClientDisconnected?.Invoke(this, "");
}
// Use this for initialization
void Start()
{
var ug = new UniverseGen();
var p = ug.MakeRandomStarSystem(0);
Debug.Log(p);
var client = new TcpClient(serverName, serverPort);
Debug.Log(string.Format("Client connected: {0}", client.Connected));
var stream = client.GetStream();
Debug.Log("Grawr!");
var wossname = BsonDocument.ReadFrom(stream);
var pl = DecodeMessage.Place(wossname);
Debug.Log(pl);
var msg = EncodeMessage.PlayerEnteredSystem();
msg.WriteTo(stream);
//var place = DecodeMessage.Place(wossname);
//Debug.Log (place.ToString());
}
public void TestMetaFrame(ProcessDataPointValue dataPoint)
{
ProcessDataSet dataSet = new ProcessDataSet("test-publisher", "test001", 123, ProcessDataSet.DataSetType.TimeSeries);
dataSet.AddDataPoint(dataPoint);
byte[] encodedMeta = dataSet.GetEncodedMetaFrame(new EncodingOptions(), 1, true);
DecodeMessage decoder = new DecodeMessage();
NetworkMessage decodedMeta = decoder.ParseBinaryMessage(encodedMeta);
Assert.That(decodedMeta, Is.Not.Null);
Assert.That(decodedMeta, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(decodedMeta.NetworkMessageHeader.ExtendedFlags2.MessageType, Is.EqualTo(Header.MessageType.DiscoveryResponse));
Assert.That(decodedMeta.NetworkMessageHeader.ExtendedFlags2.Chunk, Is.False);
Assert.That(decodedMeta.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.False);
decoder = new DecodeMessage();
List <byte[]> encodedMetaChunkedZero = dataSet.GetChunkedMetaFrame(0, new EncodingOptions(), 1);
NetworkMessage decodedMetaChunkedZero = decoder.ParseBinaryMessage(encodedMetaChunkedZero[0]);
Assert.That(decodedMetaChunkedZero, Is.Not.Null);
Assert.That(decodedMetaChunkedZero, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(decodedMetaChunkedZero.NetworkMessageHeader.ExtendedFlags2.MessageType, Is.EqualTo(Header.MessageType.DiscoveryResponse));
Assert.That(decodedMetaChunkedZero.NetworkMessageHeader.ExtendedFlags2.Chunk, Is.False);
Assert.That(decodedMetaChunkedZero.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.False);
decoder = new DecodeMessage();
List <byte[]> encodedMetaChunked = dataSet.GetChunkedMetaFrame(1024 * 14, new EncodingOptions(), 1);
NetworkMessage decodedMetaChunked = decoder.ParseBinaryMessage(encodedMetaChunked[0]);
Assert.That(decodedMetaChunked, Is.Not.Null);
Assert.That(decodedMetaChunked, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(decodedMetaChunked.NetworkMessageHeader.ExtendedFlags2.MessageType, Is.EqualTo(Header.MessageType.DiscoveryResponse));
Assert.That(decodedMetaChunked.NetworkMessageHeader.ExtendedFlags2.Chunk, Is.True);
Assert.That(decodedMetaChunked.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.True);
}
public static WsjtxMessage Parse(byte[] datagram)
{
if (!CheckMagicNumber(datagram))
{
return(null);
}
int cur = MAGIC_NUMBER_LENGTH;
int schemaVersion = DecodeQInt32(datagram, ref cur);
var messageType = (MessageType)DecodeQInt32(datagram, ref cur);
try
{
if (schemaVersion == 2)
{
WsjtxMessage result;
if (messageType == MessageType.HEARTBEAT_MESSAGE_TYPE)
{
result = HeartbeatMessage.Parse(datagram);
}
else if (messageType == MessageType.STATUS_MESSAGE_TYPE)
{
result = StatusMessage.Parse(datagram);
}
else if (messageType == MessageType.DECODE_MESSAGE_TYPE)
{
result = DecodeMessage.Parse(datagram);
}
else if (messageType == MessageType.CLEAR_MESSAGE_TYPE)
{
result = ClearMessage.Parse(datagram);
}
else if (messageType == MessageType.QSO_LOGGED_MESSAGE_TYPE)
{
result = QsoLoggedMessage.Parse(datagram);
}
else if (messageType == MessageType.CLOSE_MESSAGE_TYPE)
{
result = CloseMessage.Parse(datagram);
}
else if (messageType == MessageType.WSPR_DECODE_MESSAGE_TYPE)
{
result = WsprDecodeMessage.Parse(datagram);
}
else if (messageType == MessageType.LOGGED_ADIF_MESSAGE_TYPE)
{
result = LoggedAdifMessage.Parse(datagram);
}
else
{
result = new UnknownMessage();
}
result.Datagram = datagram;
return(result);
}
}
catch (Exception ex)
{
throw new ParseFailureException(messageType, datagram, ex);
}
throw new NotImplementedException($"Schema version {schemaVersion}, message type {messageType}");
}
