public void TestEnumResolution()
{
Schema writerSchema = Schema.Parse("{\"type\":\"record\",\"name\":\"EnumRecord\",\"namespace\":\"Avro.Test\"," +
"\"fields\":[{\"name\":\"enumType\",\"type\": { \"type\": \"enum\", \"name\": \"EnumType\", \"symbols\": [\"FIRST\", \"SECOND\"]} }]}");
Schema readerSchema = Schema.Parse("{\"type\":\"record\",\"name\":\"EnumRecord\",\"namespace\":\"Avro.Test\"," +
"\"fields\":[{\"name\":\"enumType\",\"type\": { \"type\": \"enum\", \"name\": \"EnumType\", \"symbols\": [\"THIRD\", \"FIRST\", \"SECOND\"]} }]}");
EnumRecord testRecord = new EnumRecord();
testRecord.enumType = EnumType.SECOND;
// serialize
var stream = new MemoryStream();
var binEncoder = new BinaryEncoder(stream);
var writer = new SpecificWriter <EnumRecord>(writerSchema);
writer.Write(testRecord, binEncoder);
// deserialize
stream.Position = 0;
var decoder = new BinaryDecoder(stream);
var reader = new SpecificReader <EnumRecord>(writerSchema, readerSchema);
var rec2 = reader.Read(null, decoder);
Assert.AreEqual(EnumType.SECOND, rec2.enumType);
}
private static S deserialize <S>(Stream ms, Schema ws, Schema rs) where S : class, ISpecificRecord
{
long initialPos = ms.Position;
var r = new SpecificReader <S>(ws, rs);
Decoder d = new BinaryDecoder(ms);
S output = r.Read(null, d);
Assert.AreEqual(ms.Length, ms.Position); // Ensure we have read everything.
checkAlternateDeserializers(output, ms, initialPos, ws, rs);
return(output);
}
public Func <Stream, T> BuildDeserializer(string writerSchemaJson)
{
var writerSchema = Schema.Parse(writerSchemaJson);
var avroReader = new SpecificReader <T>(writerSchema, _schema);
return((Stream stream) =>
{
var result = default(T);
var decoder = new BinaryDecoder(stream);
result = avroReader.Read(result, decoder);
return result;
});
}
/// <summary>
/// Decodes the message body using the specified decoder.
/// </summary>
/// <typeparam name="T">The type of the message.</typeparam>
/// <param name="decoder">The decoder.</param>
/// <param name="body">The message body.</param>
/// <returns>The decoded message body.</returns>
public static T Decode <T>(this Decoder decoder, string body) where T : ISpecificRecord
{
if (!string.IsNullOrWhiteSpace(body))
{
return(Deserialize <T>(body));
}
var record = Activator.CreateInstance <T>();
var reader = new SpecificReader <T>(new EtpSpecificReader(record.Schema, record.Schema));
reader.Read(record, decoder);
return(record);
}
private Protocol Handshake(Decoder input, Encoder output, Transceiver connection)
{
if (connection != null && connection.IsConnected)
{
return(connection.Remote);
}
HandshakeRequest request = handshakeReader.Read(null, input);
Protocol remote;
lock (protocolsLock)
{
remote = protocols[request.clientHash.Schema];
if (remote == null && request.clientProtocol != null)
{
remote = Protocol.Parse(request.clientProtocol);
protocols[request.clientHash.Schema] = remote;
}
}
var response = new HandshakeResponse();
if (localHash.Schema.Equals(request.serverHash.Schema))
{
response.match =
remote == null ? HandshakeMatch.NONE : HandshakeMatch.BOTH;
}
else
{
response.match =
remote == null ? HandshakeMatch.NONE : HandshakeMatch.CLIENT;
}
if (response.match != HandshakeMatch.BOTH)
{
response.serverProtocol = local.ToString();
response.serverHash = localHash;
}
handshakeWriter.Write(response, output);
if (connection != null && response.match != HandshakeMatch.NONE)
{
connection.Remote = remote;
}
return(remote);
}
public static ISpecificRecord unpackMessage <T>(IBytesMessage message)
{
long len = message.BodyLength;
byte[] data = new byte[(int)len];
int read = message.ReadBytes(data);
MemoryStream ins = new MemoryStream(data);
Avro.IO.Decoder dc = new Avro.IO.BinaryDecoder(ins);
// Decode<T> r = new Decode<T>();
// SpecificReader<T> r = new SpecificReader<T>(c);
SpecificDefaultReader sdr = new SpecificDefaultReader(x, z);
DatumReader <T> reader = new SpecificReader <T>(sdr);
T actual = reader.Read(typeof(T), dc);
//T actual = r(dc);
ins.Close();
return((ISpecificRecord)actual);
}
public void TestEnumResolution()
{
Schema writerSchema = Schema.Parse("{\"type\":\"record\",\"name\":\"EnumRecord\",\"namespace\":\"Avro.Test\"," +
"\"fields\":[{\"name\":\"enumType\",\"type\": { \"type\": \"enum\", \"name\": \"EnumType\", \"symbols\": [\"FIRST\", \"SECOND\"]} }]}");
Schema readerSchema = Schema.Parse("{\"type\":\"record\",\"name\":\"EnumRecord\",\"namespace\":\"Avro.Test\"," +
"\"fields\":[{\"name\":\"enumType\",\"type\": { \"type\": \"enum\", \"name\": \"EnumType\", \"symbols\": [\"THIRD\", \"FIRST\", \"SECOND\"]} }]}");
EnumRecord testRecord = new EnumRecord();
testRecord.enumType = EnumType.SECOND;
// serialize
var stream = new MemoryStream();
var binEncoder = new BinaryEncoder(stream);
var writer = new SpecificWriter<EnumRecord>(writerSchema);
writer.Write(testRecord, binEncoder);
// deserialize
stream.Position = 0;
var decoder = new BinaryDecoder(stream);
var reader = new SpecificReader<EnumRecord>(writerSchema, readerSchema);
var rec2 = reader.Read(null, decoder);
Assert.AreEqual( EnumType.SECOND, rec2.enumType );
}
protected void Decode(byte[] data)
{
var receivedTime = DateTime.UtcNow;
using (var inputStream = new MemoryStream(data))
{
// create avro binary decoder to read from memory stream
var decoder = new BinaryDecoder(inputStream);
var record = Activator.CreateInstance <MessageHeader>();
var reader = new SpecificReader <MessageHeader>(new EtpSpecificReader(record.Schema, record.Schema));
MessageHeader header = reader.Read(record, decoder);
// string message = Encoding.UTF8.GetString(inputStream.ToArray());
if (header.Protocol == 0 && header.MessageType == 2)
{
lock (m_ConnectionLock)
{
m_HasConnected = true;
}
var recordSession = Activator.CreateInstance <OpenSession>();
var readerSession = new SpecificReader <OpenSession>(new EtpSpecificReader(recordSession.Schema, recordSession.Schema));
readerSession.Read(recordSession, decoder);
string message = ToString(recordSession);
var timediff = receivedTime - m_Time;
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Info);
}
else if (header.Protocol == 3 && header.MessageType == 2)
{
var responce = Activator.CreateInstance <GetResourcesResponse>();
var bodyreader = new SpecificReader <GetResourcesResponse>(new EtpSpecificReader(responce.Schema, responce.Schema));
GetResourcesResponse bodyheader = bodyreader.Read(responce, decoder);
RequestInformation parent;
lock (m_RequestInformation)
{
parent = m_RequestInformation[header.CorrelationId];
}
var timediff = receivedTime - parent.RequestTime;
string message = ToString(responce);
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Info);
if (parent.ChannelItem == null)
{
ChannelItem channelItem = new ChannelItem()
{
Name = responce.Resource.Name,
Uid = responce.Resource.Uuid,
Eml = responce.Resource.Uri,
Level = 0,
ChildrensCount = responce.Resource.HasChildren
};
ChannelItemsReceived?.Invoke(channelItem);
}
else
{
ChannelItem channelItem = new ChannelItem()
{
Name = responce.Resource.Name,
Uid = responce.Resource.Uuid,
Eml = responce.Resource.Uri,
Level = parent.ChannelItem.Level + 1,
ChildrensCount = responce.Resource.HasChildren
};
ChannelChildrensReceived?.Invoke(channelItem, parent.ChannelItem);
}
}
else if (header.Protocol == 1 && header.MessageType == 2)
{
var timediff = receivedTime - m_Time;
string message = "Channels received: [";
var recordMetadata = Activator.CreateInstance <ChannelMetadata>();
var readerMetadata = new SpecificReader <ChannelMetadata>(new EtpSpecificReader(recordMetadata.Schema, recordMetadata.Schema));
readerMetadata.Read(recordMetadata, decoder);
ChannelMetadata metadata = new ChannelMetadata();
metadata.Channels = new List <ChannelMetadataRecord>();
lock (m_ChannelStreamingInfo)
{
foreach (var channel in recordMetadata.Channels)
{
if (m_LogCurveEml.Contains(channel.ChannelUri, StringComparer.InvariantCultureIgnoreCase))
{
metadata.Channels.Add(channel);
ChannelStreamingInfo channelStreamingInfo = new ChannelStreamingInfo()
{
ChannelId = channel.ChannelId,
StartIndex = new StreamingStartIndex()
{
Item = null
},
ReceiveChangeNotification = true
};
m_ChannelStreamingInfo.Add(channelStreamingInfo);
message = message + $"\n{channel.ChannelId} {channel.ChannelName}";
ChannelMetaDataVM channelMetaData_VM = ETPMapper.Instance().Map <ChannelMetaDataVM>(channel);
string json = JsonConvert.SerializeObject(channelMetaData_VM, Formatting.Indented);
Message?.Invoke(json, timediff.TotalMilliseconds, TraceLevel.Info);
}
}
ChannelInfoReceived?.Invoke(metadata);
}
message = message + "\n]";
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Info);
HasDescribing = false;
}
else if (header.Protocol == 1 && header.MessageType == 3)
{
var recordData = Activator.CreateInstance <ChannelData>();
var readerdata = new SpecificReader <ChannelData>(new EtpSpecificReader(recordData.Schema, recordData.Schema));
readerdata.Read(recordData, decoder);
ChannelDataReceived?.Invoke(recordData.Data);
}
else if (header.MessageType == 1000)
{
var timediff = receivedTime - m_Time;
var bodyrecord = Activator.CreateInstance <ProtocolException>();
var bodyreader = new SpecificReader <ProtocolException>(new EtpSpecificReader(bodyrecord.Schema, bodyrecord.Schema));
ProtocolException bodyheader = bodyreader.Read(bodyrecord, decoder);
string message = $"Error Received ({bodyrecord.ErrorCode}): {bodyrecord.ErrorMessage}";
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Error);
HasDescribing = false;
}
else
{
HasDescribing = false;
}
}
}