public IServiceRemotingResponseMessageBody Deserialize(IIncomingMessageBody messageBody)
{
using (var reader = new BsonDataReader(messageBody.GetReceivedBuffer()))
{
return(serializer.Deserialize <BsonRemotingResponseBody>(reader));
}
}
public void WriteBigInteger()
{
BigInteger i = BigInteger.Parse("1999999999999999999999999999999999999999999999999999999999990");
MemoryStream ms = new MemoryStream();
BsonDataWriter writer = new BsonDataWriter(ms);
writer.WriteStartObject();
writer.WritePropertyName("Blah");
writer.WriteValue(i);
writer.WriteEndObject();
string bson = BytesToHex(ms.ToArray());
Assert.AreEqual("2A-00-00-00-05-42-6C-61-68-00-1A-00-00-00-00-F6-FF-FF-FF-FF-FF-FF-1F-B2-21-CB-28-59-84-C4-AE-03-8A-44-34-2F-4C-4E-9E-3E-01-00", bson);
ms.Seek(0, SeekOrigin.Begin);
BsonDataReader reader = new BsonDataReader(ms);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Bytes, reader.TokenType);
CollectionAssert.AreEqual(new byte[] { 246, 255, 255, 255, 255, 255, 255, 31, 178, 33, 203, 40, 89, 132, 196, 174, 3, 138, 68, 52, 47, 76, 78, 158, 62, 1 }, (byte[])reader.Value);
Assert.AreEqual(i, new BigInteger((byte[])reader.Value));
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
Assert.IsFalse(reader.Read());
}
public void bson_serialize_object_test()
{
var propName = "Value";
var propValue = "Dummy";
MemoryStream ms = new MemoryStream();
var bs = new BsonDataWriter(ms);
bs.WriteStartObject();
bs.WritePropertyName(propName);
bs.WriteValue(propValue);
bs.WriteEnd();
ms.Seek(0, SeekOrigin.Begin);
var reader = new BsonDataReader(ms);
// object
reader.Read();
// property name
reader.Read();
Assert.Equal(propName, (string)reader.Value);
reader.Read();
Assert.Equal(propValue, (string)reader.Value);
}
public jcCCResponseItem DecompressFile(byte[] compressedData)
{
var response = new jcCCResponseItem();
var ms = new MemoryStream(compressedData);
using (var reader = new BsonDataReader(ms)) {
var serializer = new JsonSerializer();
var obj = serializer.Deserialize <jcCCA>(reader);
response.OutputFile = obj.Filename + ".org";
response.compressedData = new byte[0];
var data = new List <byte>();
foreach (var patternID in obj.Patterns)
{
data.AddRange(obj.Data.FirstOrDefault(a => a.Index == (patternID - 1))?.Data ?? throw new InvalidOperationException());
}
response.compressedData = data.ToArray();
}
return(response);
}
public void WriteOid()
{
MemoryStream ms = new MemoryStream();
BsonDataWriter writer = new BsonDataWriter(ms);
byte[] oid = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
writer.WriteStartObject();
writer.WritePropertyName("_oid");
writer.WriteObjectId(oid);
writer.WriteEndObject();
string bson = BytesToHex(ms.ToArray());
Assert.AreEqual("17-00-00-00-07-5F-6F-69-64-00-01-02-03-04-05-06-07-08-09-0A-0B-0C-00", bson);
ms.Seek(0, SeekOrigin.Begin);
BsonDataReader reader = new BsonDataReader(ms);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Bytes, reader.TokenType);
CollectionAssert.AreEquivalent(oid, (byte[])reader.Value);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
}
/// <summary>
/// Decodes a message from the specified memory stream.
/// </summary>
/// <param name="stream">The memory stream.</param>
/// <returns></returns>
public override object Decode(MemoryStream stream)
{
using (BsonDataReader reader = new BsonDataReader(stream))
{
return(_serializer.Deserialize(reader));
}
}
public T Deserialize <T>()
{
using (var mr = new MemoryStream(contents))
using (var br = new BsonDataReader(mr)) {
return(JsonSerializer.CreateDefault().Deserialize <T>(br));
}
}
/// TODO BE REMOVED!
private static IEnumerable <QsNamespace> ReadBinary(string file)
{
using var stream = new MemoryStream(File.ReadAllBytes(Path.GetFullPath(file)));
using var reader = new BsonDataReader(stream);
reader.ReadRootValueAsArray = false;
return(Json.Serializer.Deserialize <QsCompilation>(reader).Namespaces);
}
internal override async Task <int> Transform(Stream input, Stream output, CancellationToken cancellationToken)
{
JObject obj;
using (var reader = new BsonDataReader(input, IsArray, DateTimeKindHandling))
{
obj = await JObject.LoadAsync(reader, cancellationToken)
.ConfigureAwait(false);
}
var enc = AddBom ? Encoding.UTF8 : Encodings.Utf8NoBom;
var writer = new JsonTextWriter(new StreamWriter(output, enc, 1024, true));
if (IndentOutput)
{
writer.Formatting = Formatting.Indented;
}
using (writer)
{
await obj.WriteToAsync(writer, cancellationToken).ConfigureAwait(false);
}
return(ExitCodes.Ok);
}
static void MemoryToJSON(JsonWriter writer, MemoryStream input)
{
BinaryReader reader = new BinaryReader(input);
int count = reader.ReadInt32();
writer.WritePropertyName("MemoryList");
writer.WriteStartArray();
for (int i = 0; i < count; i++)
{
writer.WriteStartObject();
writer.WriteNameValue("Key", reader.ReadString());
writer.WriteNameValue("Scope", reader.ReadInt32());
string type = reader.ReadString();
writer.WriteNameValue("Type", type);
using (var bson = new BsonDataReader(reader)
{
CloseInput = false, ReadRootValueAsArray = true
}) {
writer.WritePropertyName("Value");
writer.WriteToken(bson);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
NamedObjectToJSON(CopyBSONToJSON, writer, reader, "VariableReference");
NamedObjectToJSON(CopyBSONToJSON, writer, reader, "Flags");
}
public static T DeserializeObject <T>(byte[] value)
{
using var stream = new MemoryStream(value);
using var reader = new BsonDataReader(stream);
return(new JsonSerializer().Deserialize <T>(reader));
}
static void Main(string[] args)
{
byte[] byteArray = null;
byteArray = File.ReadAllBytes(file);
var prettifiedData = new Tuple <int, byte[]>(0, byteArray);
Stopwatch sw = Stopwatch.StartNew();
var dataASJson = JsonConvert.SerializeObject(byteArray);
Console.WriteLine(sw.ElapsedMilliseconds);
sw.Restart();
File.WriteAllText(fileAsJson, dataASJson);
using (MemoryStream memStream = new MemoryStream())
{
using (BsonDataWriter writer = new BsonDataWriter(memStream))
{
using (FileStream fileStream = new FileStream(fileAsBson, FileMode.Create, FileAccess.Write))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(writer, prettifiedData);
Console.WriteLine(sw.ElapsedMilliseconds);
memStream.Position = 0;
memStream.CopyTo(fileStream);
}
}
}
Console.WriteLine("Чтение файла в виде Bson.");
byteArray = File.ReadAllBytes(fileAsBson);
sw.Restart();
using (MemoryStream memStream = new MemoryStream(byteArray))
{
using (BsonDataReader writer = new BsonDataReader(memStream))
{
using (FileStream fileStream = new FileStream(fileAsBsonDeserialized, FileMode.Create, FileAccess.Write))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Deserialize <Tuple <int, byte[]> >(writer);
Console.WriteLine(sw.ElapsedMilliseconds);
memStream.Position = 0;
memStream.CopyTo(fileStream);
}
}
}
Console.WriteLine("Чтение файла в виде Json.");
var jsonFile = File.ReadAllText(fileAsJson);
sw.Restart();
byteArray = JsonConvert.DeserializeObject <byte[]>(jsonFile);
Console.WriteLine(sw.ElapsedMilliseconds);
File.WriteAllBytes(fileAsJsonDeserialized, byteArray);
Console.ReadLine();
}
T ReadBsonMessage <T>()
{
//TODO: Remove these debugging checks once we're done investigating https://trello.com/c/0gHf4v7m/2974-null-ref-exceptions-in-halibut
if (stream == null)
{
throw new Exception("stream is null");
}
if (serializer == null)
{
throw new Exception("serializer is null");
}
using (var zip = new DeflateStream(stream, CompressionMode.Decompress, true))
using (var bson = new BsonDataReader(zip)
{
CloseInput = false
})
{
var messageEnvelope = serializer.Deserialize <MessageEnvelope>(bson);
if (messageEnvelope == null)
{
throw new Exception("messageEnvelope is null");
}
return((T)messageEnvelope.Message);
}
}
public object Deserialize(byte[] data, MessageEncoding encoding)
{
using (var stream = new MemoryStream(data))
{
if (encoding == MessageEncoding.Json)
{
using (var reader = new JsonTextReader(new StreamReader(stream, Encoding.UTF8)))
{
return(_jsonSerializer.Deserialize(reader, typeof(object)));
}
}
else if (encoding == MessageEncoding.Bson)
{
using (var reader = new BsonDataReader(stream))
{
return(_jsonSerializer.Deserialize(reader, typeof(object)));
}
}
else if (encoding == MessageEncoding.BinarySerialized)
{
return(_binaryFormatter.Deserialize(stream));
}
else
{
throw new UnsupportedEncodingException();
}
}
}
public virtual T Deserialize <T>(CacheItem item)
{
if (typeof(T).GetTypeCode() != TypeCode.Object || typeof(T) == typeof(Byte[]))
{
var value = Deserialize(item);
if (value != null)
{
if (typeof(T) == typeof(Guid))
{
return((T)(object)new Guid((string)value));
}
else
{
return((T)value);
}
}
else
{
return(default(T));
}
}
using (var ms = new MemoryStream(item.Data.ToArray()))
{
using (var reader = new BsonDataReader(ms))
{
if (typeof(T).GetTypeInfo().ImplementedInterfaces.Contains(typeof(IEnumerable)))
{
reader.ReadRootValueAsArray = true;
}
var serializer = new JsonSerializer();
return(serializer.Deserialize <T>(reader));
}
}
}
public virtual T Deserialize <T>(Stream input)
{
using (var reader = new BsonDataReader(input, IsArray(typeof(T)), DateTimeKind.Utc))
{
return(Deserialize <T>(reader));
}
}
public async Task <bool> SendAsync(string topic, byte[] payload, bool retain = false)
{
const string rpcCall = "$upstream/rpc/";
if (topic.StartsWith(rpcCall))
{
var guid = topic.Substring(rpcCall.Length);
await dispatcher.HandleAsync(new MqttPublishInfo("$downstream/rpc/ack/" + guid, new byte[0]));
var packet = default(RpcPacket);
using (var reader = new BsonDataReader(new MemoryStream(payload)))
{
var serializer = new JsonSerializer
{
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
};
packet = serializer.Deserialize <RpcPacket>(reader);
}
this.spy.ForEach(s => s(packet));
}
return(true);
}
public ConsumeContext Deserialize(ReceiveContext receiveContext)
{
try
{
using (var body = receiveContext.GetBodyStream())
{
using (var disposingCryptoStream = _cryptoStreamProvider.GetDecryptStream(body, receiveContext))
{
using (var jsonReader = new BsonDataReader(disposingCryptoStream))
{
var messageEnvelope = _deserializer.Deserialize <MessageEnvelope>(jsonReader);
return(new JsonConsumeContext(_deserializer, _objectTypeDeserializer, receiveContext,
messageEnvelope));
}
}
}
}
catch (JsonSerializationException ex)
{
throw new SerializationException(
"A JSON serialization exception occurred while deserializing the message envelope", ex);
}
catch (SerializationException)
{
throw;
}
catch (Exception ex)
{
throw new SerializationException("An exception occurred while deserializing the message envelope", ex);
}
}
public void ConvertRegexWithAllOptionsBson()
{
Regex regex = new Regex(
"/",
RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.ExplicitCapture);
MemoryStream ms = new MemoryStream();
BsonDataWriter writer = new BsonDataWriter(ms);
JsonSerializer serializer = new JsonSerializer();
serializer.Converters.Add(new BsonDataRegexConverter());
serializer.Serialize(writer, new RegexTestClass {
Regex = regex
});
string expected = "14-00-00-00-0B-52-65-67-65-78-00-2F-00-69-6D-73-75-78-00-00";
string bson = BytesToHex(ms.ToArray());
Assert.AreEqual(expected, bson);
ms.Seek(0, SeekOrigin.Begin);
BsonDataReader reader = new BsonDataReader(ms);
serializer.Converters.Add(new BsonDataRegexConverter());
RegexTestClass c = serializer.Deserialize <RegexTestClass>(reader);
Assert.AreEqual("/", c.Regex.ToString());
Assert.AreEqual(RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.ExplicitCapture, c.Regex.Options);
}
public static TEntity DeserializeObject <TEntity>(byte[] document)
{
if (document == null)
{
throw new StorageArgumentNullException("document cannot be null");
}
using (MemoryStream ms = new MemoryStream(document))
{
JsonSerializer serializer = new JsonSerializer
{
DateFormatHandling = DateFormatHandling.IsoDateFormat,
NullValueHandling = NullValueHandling.Ignore,
DateTimeZoneHandling = DateTimeZoneHandling.Utc,
DateParseHandling = DateParseHandling.DateTime,
TypeNameHandling = TypeNameHandling.Auto,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple
};
using (BsonDataReader reader = new BsonDataReader(ms, false, DateTimeKind.Utc))
{
TEntity entity = serializer.Deserialize <TEntity>(reader);
return(entity);
}
}
}
public object Deserialize(Type type)
{
using (var mr = new MemoryStream(contents))
using (var br = new BsonDataReader(mr)) {
return(JsonSerializer.CreateDefault().Deserialize(br, type));
}
}
public object Deserialize(Stream input, Type type)
{
using (var reader = new BsonDataReader(input))
{
return(this.serializer.Deserialize(reader, type));
}
}
public void WriteBytes()
{
byte[] data = Encoding.UTF8.GetBytes("Hello world!");
MemoryStream ms = new MemoryStream();
BsonDataWriter writer = new BsonDataWriter(ms);
writer.WriteStartArray();
writer.WriteValue("a");
writer.WriteValue("b");
writer.WriteValue(data);
writer.WriteEndArray();
writer.Flush();
ms.Seek(0, SeekOrigin.Begin);
string expected = "2B-00-00-00-02-30-00-02-00-00-00-61-00-02-31-00-02-00-00-00-62-00-05-32-00-0C-00-00-00-00-48-65-6C-6C-6F-20-77-6F-72-6C-64-21-00";
string bson = BytesToHex(ms.ToArray());
Assert.AreEqual(expected, bson);
BsonDataReader reader = new BsonDataReader(new MemoryStream(ms.ToArray()));
reader.ReadRootValueAsArray = true;
reader.Read();
reader.Read();
reader.Read();
reader.Read();
Assert.AreEqual(JsonToken.Bytes, reader.TokenType);
CollectionAssert.AreEquivalent(data, (byte[])reader.Value);
}
public static void Bson_ValueOnly <TItem>(TItem value, Action <JsonWriter, TItem> write, Func <JsonReader, Database, TItem> read)
{
TItem roundTripped = default;
using (MemoryStream stream = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true))
using (BsonDataWriter bdw = new BsonDataWriter(bw))
{
// Write value alone
write(bdw, value);
}
long bytesWritten = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
using (BinaryReader br = new BinaryReader(stream, Encoding.UTF8, leaveOpen: true))
using (BsonDataReader bdr = new BsonDataReader(br))
{
bdr.Read();
// Read value
roundTripped = read(bdr, default(Database));
}
// Ensure everything written is read back
Assert.Equal(bytesWritten, stream.Position);
// Ensure value returned matches value written
Assert.Equal(value, roundTripped);
}
}
public void SerializeEmptyAndNullStrings()
{
Product p = new Product();
p.ExpiryDate = DateTime.Parse("2009-04-05T14:45:00Z");
p.Name = null;
p.Price = 9.95m;
p.Sizes = new[] { "Small", "", null };
MemoryStream ms = new MemoryStream();
JsonSerializer serializer = new JsonSerializer();
BsonDataWriter writer = new BsonDataWriter(ms);
serializer.Serialize(writer, p);
ms.Seek(0, SeekOrigin.Begin);
BsonDataReader reader = new BsonDataReader(ms);
Product deserializedProduct = serializer.Deserialize <Product>(reader);
Console.WriteLine(deserializedProduct.Name);
Assert.AreEqual(null, deserializedProduct.Name);
Assert.AreEqual(9.95m, deserializedProduct.Price);
Assert.AreEqual(3, deserializedProduct.Sizes.Length);
Assert.AreEqual("Small", deserializedProduct.Sizes[0]);
Assert.AreEqual("", deserializedProduct.Sizes[1]);
Assert.AreEqual(null, deserializedProduct.Sizes[2]);
}
/// <summary>
/// Deserialize bson string to given object type
/// </summary>
/// <typeparam name="T">Object type</typeparam>
/// <param name="value">Value will be deserialized</param>
/// <returns>Deserialized object</returns>
private static T DeserializeFromBson <T>(this string value)
{
if (string.IsNullOrEmpty(value))
{
return(default(T));
}
try
{
var data = Convert.FromBase64String(value);
using (var ms = new MemoryStream(data))
{
using (var reader = new BsonDataReader(ms))
{
var serializer = new JsonSerializer();
return(serializer.Deserialize <T>(reader));
}
}
}
catch (Exception)
{
//Change type to string if there is an exception and type of T is string
if (typeof(T) == typeof(string))
{
return((T)Convert.ChangeType(value, typeof(T)));
}
//Otherwise return default of T
else
{
return(default(T));
}
}
}
ConsumeContext IMessageDeserializer.Deserialize(ReceiveContext receiveContext)
{
try
{
MessageEnvelope envelope;
using (var body = receiveContext.GetBodyStream())
using (var jsonReader = new BsonDataReader(body))
{
envelope = _deserializer.Deserialize <MessageEnvelope>(jsonReader);
}
return(new JsonConsumeContext(_deserializer, receiveContext, envelope));
}
catch (JsonSerializationException ex)
{
throw new SerializationException("A JSON serialization exception occurred while deserializing the message envelope", ex);
}
catch (SerializationException)
{
throw;
}
catch (Exception ex)
{
throw new SerializationException("An exception occurred while deserializing the message envelope", ex);
}
}
IObservable <T> DeserializeObject <T>(byte[] data)
{
var settings = Locator.Current.GetService <JsonSerializerSettings>() ?? new JsonSerializerSettings();
settings.ContractResolver = new JsonDateTimeContractResolver(settings?.ContractResolver); // This will make us use ticks instead of json ticks for DateTime.
var serializer = JsonSerializer.Create(settings);
var reader = new BsonDataReader(new MemoryStream(data));
var forcedDateTimeKind = BlobCache.ForcedDateTimeKind;
if (forcedDateTimeKind.HasValue)
{
reader.DateTimeKindHandling = forcedDateTimeKind.Value;
}
try
{
try
{
var boxedVal = serializer.Deserialize <ObjectWrapper <T> >(reader).Value;
return(Observable.Return(boxedVal));
}
catch (Exception ex)
{
this.Log().WarnException("Failed to deserialize data as boxed, we may be migrating from an old Akavache", ex);
}
var rawVal = serializer.Deserialize <T>(reader);
return(Observable.Return(rawVal));
}
catch (Exception ex)
{
return(Observable.Throw <T>(ex));
}
}
public void bson_serialize_message_test()
{
var prop1 = "prop1";
var prop2 = "prop2";
var msg = new WoftamEvent(prop1, prop2);
MemoryStream ms = new MemoryStream();
var bs = new BsonDataWriter(ms);
bs.WriteStartObject();
bs.WritePropertyName(msg.GetType().FullName);
bs.WriteValue(JsonConvert.SerializeObject(msg));
bs.WriteEnd();
ms.Seek(0, SeekOrigin.Begin);
Message msg2;
var reader = new BsonDataReader(ms);
// read object
reader.Read();
// read type name
reader.Read();
var messageType = MessageHierarchy.GetTypeByFullName((string)reader.Value);
reader.Read(); //property value
msg2 = (Message)JsonConvert.DeserializeObject((string)reader.Value, messageType);
Assert.IsType <WoftamEvent>(msg2);
Assert.Equal(prop1, ((WoftamEvent)msg2).Property1);
}
public T restoreObject <T>(Stream stream, SaverOutputType format)
{
stream = new NoCloseStream(stream);
switch (format)
{
case SaverOutputType.Json:
using (var reader = new JsonTextReader(new StreamReader(stream)))
{
return(jsonSaver.Value.restoreObject <T>(reader));
}
case SaverOutputType.Bson:
using (var reader = new BsonDataReader(stream)
{
ReadRootValueAsArray = true
})
{
return(jsonSaver.Value.restoreObject <T>(reader));
}
case SaverOutputType.Xml:
using (var reader = new XmlTextReader(stream))
{
return((T)xmlSaver.Value.restoreObject(reader));
}
default:
throw new NotImplementedException($"{nameof(SaverOutputType)} format {format} not supported.");
}
}