public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
var taskCompletionSource = new TaskCompletionSource<object>();
try
{
BsonReader reader = new BsonReader(readStream);
if (typeof(IEnumerable).IsAssignableFrom(type)) reader.ReadRootValueAsArray = true;
using (reader)
{
var jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
var output = jsonSerializer.Deserialize(reader, type);
if (formatterLogger != null)
{
jsonSerializer.Error += (sender, e) =>
{
Exception exception = e.ErrorContext.Error;
formatterLogger.LogError(e.ErrorContext.Path, exception.Message);
e.ErrorContext.Handled = true;
};
}
taskCompletionSource.SetResult(output);
}
}
catch (Exception ex)
{
if (formatterLogger == null) throw;
formatterLogger.LogError(String.Empty, ex.Message);
taskCompletionSource.SetResult(GetDefaultValueForType(type));
}
return taskCompletionSource.Task;
}
private object ReadBson(BsonReader reader)
{
string regexText = (string)reader.Value;
int patternOptionDelimiterIndex = regexText.LastIndexOf(@"/");
string patternText = regexText.Substring(1, patternOptionDelimiterIndex - 1);
string optionsText = regexText.Substring(patternOptionDelimiterIndex + 1);
RegexOptions options = RegexOptions.None;
foreach (char c in optionsText)
{
switch (c)
{
case 'i':
options |= RegexOptions.IgnoreCase;
break;
case 'm':
options |= RegexOptions.Multiline;
break;
case 's':
options |= RegexOptions.Singleline;
break;
case 'x':
options |= RegexOptions.ExplicitCapture;
break;
}
}
return new Regex(patternText, options);
}
public void UseBsonSerializer()
{
var message = GetMyJsonTestMessage();
var serializer = new JsonSerializer();
byte[] serializedMessage;
using (var stream = new MemoryStream())
using (var writer = new BsonWriter(stream))
{
serializer.Serialize(writer, message);
serializedMessage = stream.GetBuffer();
}
MyJsonTestMessage deserializedMessage;
using (var stream = new MemoryStream(serializedMessage))
using (var reader = new BsonReader(stream))
{
deserializedMessage = serializer.Deserialize<MyJsonTestMessage>(reader);
}
Console.Out.WriteLine(deserializedMessage.GetHashCode() == message.GetHashCode());
}
public static object Deserialize(Stream stream, System.Type type)
{
using (var reader = new BsonReader(stream))
{
return serializer.Deserialize(reader, type);
}
}
public void Import(Stream stream)
{
using (BsonReader reader = new BsonReader(stream))
{
_jsonSerializer.Populate(reader, _cardsByID);
}
}
public void DateTimeKindHandling()
{
DateTime value = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
MemoryStream ms = new MemoryStream();
BsonWriter writer = new BsonWriter(ms);
writer.WriteStartObject();
writer.WritePropertyName("DateTime");
writer.WriteValue(value);
writer.WriteEndObject();
byte[] bson = ms.ToArray();
JObject o;
BsonReader reader;
reader = new BsonReader(new MemoryStream(bson), false, DateTimeKind.Utc);
o = (JObject)JToken.ReadFrom(reader);
Assert.AreEqual(value, (DateTime)o["DateTime"]);
reader = new BsonReader(new MemoryStream(bson), false, DateTimeKind.Local);
o = (JObject)JToken.ReadFrom(reader);
Assert.AreEqual(value.ToLocalTime(), (DateTime)o["DateTime"]);
reader = new BsonReader(new MemoryStream(bson), false, DateTimeKind.Unspecified);
o = (JObject)JToken.ReadFrom(reader);
Assert.AreEqual(DateTime.SpecifyKind(value.ToLocalTime(), DateTimeKind.Unspecified), (DateTime)o["DateTime"]);
}
public override object Deserialize(Stream stream, System.Type type)
{
using (var reader = new BsonReader(stream))
{
return this.Deserialize(reader, type);
}
}
ConsumeContext IMessageDeserializer.Deserialize(ReceiveContext receiveContext)
{
try
{
MessageEnvelope envelope;
using (Stream body = receiveContext.GetBody())
using (var jsonReader = new BsonReader(body))
{
envelope = _deserializer.Deserialize<MessageEnvelope>(jsonReader);
}
return new JsonConsumeContext(_deserializer, _objectTypeDeserializer, 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);
}
}
/// <inheritdoc />
public virtual IDictionary<string, object> LoadTempData([NotNull] HttpContext context)
{
if (!IsSessionEnabled(context))
{
// Session middleware is not enabled. No-op
return null;
}
var tempDataDictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
var session = context.Session;
byte[] value;
if (session != null && session.TryGetValue(TempDataSessionStateKey, out value))
{
using (var memoryStream = new MemoryStream(value))
using (var writer = new BsonReader(memoryStream))
{
tempDataDictionary = jsonSerializer.Deserialize<Dictionary<string, object>>(writer);
}
// If we got it from Session, remove it so that no other request gets it
session.Remove(TempDataSessionStateKey);
}
else
{
// Since we call Save() after the response has been sent, we need to initialize an empty session
// so that it is established before the headers are sent.
session[TempDataSessionStateKey] = new byte[] { };
}
return tempDataDictionary;
}
public ConsumeContext Deserialize(ReceiveContext receiveContext)
{
try
{
MessageEnvelope envelope;
using (Stream body = receiveContext.GetBody())
using (Stream cryptoStream = _provider.GetDecryptStream(body, receiveContext))
using (var jsonReader = new BsonReader(cryptoStream))
{
envelope = _deserializer.Deserialize<MessageEnvelope>(jsonReader);
}
return new JsonConsumeContext(_deserializer, _objectTypeDeserializer, _sendEndpointProvider, _publishEndpoint, 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);
}
}
public async Task ReadStateAsync(string grainType, GrainReference grainReference, IGrainState grainState)
{
var tableResult = await _table.ExecuteAsync(TableOperation.Retrieve<DynamicTableEntity>(grainReference.ToKeyString(), grainType));
if (tableResult.Result == null)
{
return;
}
var entity = tableResult.Result as DynamicTableEntity;
var serializer = new JsonSerializer();
using (var memoryStream = new MemoryStream())
{
foreach (var propertyName in entity.Properties.Keys.Where(p => p.StartsWith("d")).OrderBy(p => p))
{
var dataPart = entity.Properties[propertyName];
await memoryStream.WriteAsync(dataPart.BinaryValue, 0, dataPart.BinaryValue.Length);
}
memoryStream.Position = 0;
using (var bsonReader = new BsonReader(memoryStream))
{
var data = serializer.Deserialize<Dictionary<string, object>>(bsonReader);
grainState.SetAll(data);
}
}
}
public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
var tcs = new TaskCompletionSource<object>();
if (content != null && content.Headers.ContentLength == 0) return null;
try
{
var reader = new BsonReader(readStream);
if (typeof(IEnumerable).IsAssignableFrom(type)) reader.ReadRootValueAsArray = true;
using (reader)
{
var jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
var output = jsonSerializer.Deserialize(reader, type);
tcs.SetResult(output);
}
}
catch (Exception)
{
tcs.SetResult(GetDefaultValueForType(type));
}
return tcs.Task;
}
public override async Task<CreditInfo> RetrieveCreditInfo(string username, string password, string Type, Guid dev_id)
{
var dsrz = new JsonSerializer();
using (var httpclient = new HttpClient())
{
httpclient.DefaultRequestHeaders.ExpectContinue = false;
httpclient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/bson"));
using (var httpstrAuthJson = await httpclient.PostAsync("https://wauth.apphb.com/api/AuthServ/GetData", new StringContent(JsonConvert.SerializeObject(new { q = username, x = password, t = Type, dev_id = dev_id }), Encoding.UTF8, "application/json")))
{
using (var strData = await httpstrAuthJson.Content.ReadAsStreamAsync())
{
var bson = new BsonReader(strData);
if (httpstrAuthJson.StatusCode == HttpStatusCode.BadRequest)
{
var obj = dsrz.Deserialize<MessageError>(bson);
throw new Exception(obj.Message);
}
if (httpstrAuthJson.StatusCode == HttpStatusCode.NotFound)
{
var obj = new { Message = "Error during server connection." };
throw new Exception(obj.Message);
}
httpstrAuthJson.RequestMessage.Content.Dispose();
return dsrz.Deserialize<CreditInfo>(bson);
}
}
}
}
// Constructor
/// <summary>
/// Open a profile (create if not exist) and load it.
/// </summary>
/// <param name="profileDirectory">The root directory of the profile</param>
public CraftitudeProfile(DirectoryInfo profileDirectory)
{
Directory = profileDirectory;
_craftitudeDirectory = Directory.CreateSubdirectory("craftitude");
_craftitudeDirectory.CreateSubdirectory("repositories"); // repository package lists
_craftitudeDirectory.CreateSubdirectory("packages"); // cached package setups
_bsonFile = _craftitudeDirectory.GetFile("profile.bson");
if (!_bsonFile.Exists)
{
ProfileInfo = new ProfileInfo();
}
else
{
using (FileStream bsonStream = _bsonFile.Open(FileMode.OpenOrCreate))
{
using (var bsonReader = new BsonReader(bsonStream))
{
var jsonSerializer = new JsonSerializer();
ProfileInfo = jsonSerializer.Deserialize<ProfileInfo>(bsonReader) ?? new ProfileInfo();
}
}
}
}
public override Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
var request = context.HttpContext.Request;
using (var reader = new BsonReader(request.Body))
{
var successful = true;
EventHandler<ErrorEventArgs> errorHandler = (sender, eventArgs) =>
{
successful = false;
var exception = eventArgs.ErrorContext.Error;
eventArgs.ErrorContext.Handled = true;
};
var jsonSerializer = CreateJsonSerializer();
jsonSerializer.Error += errorHandler;
var type = context.ModelType;
object model;
try
{
model = jsonSerializer.Deserialize(reader, type);
}
finally
{
_jsonSerializerPool.Return(jsonSerializer);
}
if (successful)
{
return InputFormatterResult.SuccessAsync(model);
}
return InputFormatterResult.FailureAsync();
}
}
public object Deserialize(Stream s)
{
using (var r = new BsonReader(s))
{
return Serializer.Deserialize(r);
}
}
private object ReadBson(BsonReader reader)
{
string str1 = (string) reader.Value;
int num = str1.LastIndexOf('/');
string pattern = str1.Substring(1, num - 1);
string str2 = str1.Substring(num + 1);
RegexOptions options = RegexOptions.None;
foreach (char ch in str2)
{
switch (ch)
{
case 's':
options |= RegexOptions.Singleline;
break;
case 'x':
options |= RegexOptions.ExplicitCapture;
break;
case 'i':
options |= RegexOptions.IgnoreCase;
break;
case 'm':
options |= RegexOptions.Multiline;
break;
}
}
return (object) new Regex(pattern, options);
}
public void ReadSingleObject()
{
byte[] data = MiscellaneousUtils.HexToBytes("0F-00-00-00-10-42-6C-61-68-00-01-00-00-00-00");
MemoryStream ms = new MemoryStream(data);
BsonReader reader = new BsonReader(ms);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
Assert.AreEqual("Blah", reader.Value);
Assert.AreEqual(typeof(string), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(1L, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
Assert.IsFalse(reader.Read());
Assert.AreEqual(JsonToken.None, reader.TokenType);
}
public static async Task<SongTransferMessage> ReadNextFileTransferMessageAsync(this Stream stream)
{
byte[] messageLength = await stream.ReadAsync(4);
if (messageLength.Length == 0)
{
return null;
}
int realMessageLength = BitConverter.ToInt32(messageLength, 0);
byte[] messageContent = await stream.ReadAsync(realMessageLength);
if (messageContent.Length == 0)
{
return null;
}
using (var memoryStream = new MemoryStream(messageContent))
{
using (var reader = new BsonReader(memoryStream))
{
var deserializer = new JsonSerializer();
return deserializer.Deserialize<SongTransferMessage>(reader);
}
}
}
public static JObject Read(FileStream stream)
{
using (var br = new Newtonsoft.Json.Bson.BsonReader(stream))
{
var serializer = new Newtonsoft.Json.JsonSerializer();
return((JObject)serializer.Deserialize(br));
}
}
public object Deserialize(byte[] data)
{
using (var s = new MemoryStream(data))
using (var r = new BsonReader(s))
{
return Serializer.Deserialize(r);
}
}
protected override object OnReadFromStream(Type type, Stream stream, HttpContentHeaders contentHeaders)
{
var serializer = new JsonSerializer();
using (var reader = new BsonReader(stream)) {
var result = serializer.Deserialize(reader, type);
return result;
}
}
public virtual object Deserialize(byte[] data, Type type)
{
using (var inStream = new MemoryStream(data))
using (var bsonReader = new BsonReader(inStream))
{
return CreateSerializer().Deserialize(bsonReader, type);
}
}
private static object DeserializeInternal(byte[] bytes, Type type)
{
using (var ms = new MemoryStream(bytes))
using (var reader = new BsonReader(ms))
{
var serializer = new JsonSerializer();
return serializer.Deserialize(reader, type);
}
}
public static StoredEvent<JObject> ReadStoredEvent(this byte[] eventBytes, Guid id, long version)
{
var input = new MemoryStream(eventBytes);
var reader = new BinaryReader(input);
var bsonReader = new BsonReader(input);
return new StoredEvent<JObject>(new Guid(reader.ReadBytes(16)), new DateTime(reader.ReadInt64()),
reader.ReadString(), new Version(reader.ReadString()), id, version,
JObject.Load(bsonReader));
}
public static object Deserialize(byte[] bsonData)
{
using (MemoryStream memoryStream = new MemoryStream(bsonData))
{
object objReturn = null;
using (BsonReader reader = new BsonReader(memoryStream))
{
JsonSerializer serializer = new JsonSerializer();
BsonObject bsonObject = serializer.Deserialize<BsonObject>(reader);
string type = bsonObject.Payload[0] as string;
Type objectType = bsonObject.Payload[1].GetType();
if (objectType == typeof(JArray))
{
if (type.Contains("List"))
{
Type genericType = Type.GetType(type);
objReturn = JsonConvert.DeserializeObject(bsonObject.Payload[1].ToString(), genericType);
}
else
{
//TODO: map and others collections!
}
}
else if (objectType != Type.GetType(type))
{
switch (type)
{
case "System.Int32":
objReturn = Convert.ToInt32(bsonObject.Payload[1]);
break;
case "System.UInt32":
objReturn = Convert.ToUInt32(bsonObject.Payload[1]);
break;
case "System.Int16":
objReturn = Convert.ToUInt16(bsonObject.Payload[1]);
break;
case "System.UInt16":
objReturn = Convert.ToUInt16(bsonObject.Payload[1]);
break;
case "System.Double":
objReturn = Convert.ToDouble(bsonObject.Payload[1]);
break;
case "System.Single":
objReturn = Convert.ToSingle(bsonObject.Payload[1]);
break;
}
}
else
{
objReturn = bsonObject.Payload[1];
}
}
return objReturn;
}
}
public object Deserialize(byte[] messageBytes, Type messageType)
{
using (var stream = new MemoryStream(messageBytes))
{
using (var reader = new BsonReader(stream))
{
return JsonSerializer.Deserialize(reader, messageType);
}
}
}
public static JObject Deserialize(Stream stream)
{
JObject obj;
using (var jsonReader = new BsonReader(stream))
{
jsonReader.CloseInput = true;
obj = JObject.Load(jsonReader);
}
return obj;
}
public void Execute(ClientInformation client, Stream clientStream)
{
using (var reader = new BsonReader(clientStream))
using (var writer = new BsonWriter(clientStream))
{
try
{
Log.Info("Deserializing JSON-RPC request");
var request = serializer.Deserialize<JsonRpcRequest>(reader);
if (request == null) throw new ArgumentException("No JSON-RPC request was sent");
var activityName = string.Format("{0} : {1}", client.RemoteAddress, request.Id);
using (Log.BeginActivity(activityName, request.ActivityId))
{
try
{
Log.Info("Validating request");
if (string.IsNullOrWhiteSpace(request.Service)) throw new ArgumentException("No service name was specified in the JSON-RPC request");
if (string.IsNullOrWhiteSpace(request.Method)) throw new ArgumentException("No service method was specified in the JSON-RPC request");
Log.InfoFormat("Resolving service {0}", request.Service);
var serviceType = services.GetService(request.Service);
if (serviceType == null)
{
throw new ArgumentException(string.Format("The service type {0} is not implemented on this server", request.Service));
}
Log.InfoFormat("Constructing service {0}", serviceType.FullName);
JsonRpcResponse response;
using (var lease = serviceFactory.CreateService(serviceType))
{
var service = lease.Service;
response = serviceInvoker.Invoke(service, request);
}
SendResponse(writer, response);
}
catch (Exception ex)
{
SendResponse(writer, CreateError(ex, request));
}
}
}
catch (Exception ex)
{
SendResponse(writer, CreateError(ex, null));
}
}
}
public void DeserializeLargeBsonObject()
{
byte[] data = System.IO.File.ReadAllBytes(@"SpaceShipV2.bson");
MemoryStream ms = new MemoryStream(data);
BsonReader reader = new BsonReader(ms);
JObject o = (JObject)JToken.ReadFrom(reader);
Assert.AreEqual("1", (string)o["$id"]);
}
/// <summary>
/// Loads loads the raw data from the NCldr data file and returns an NCldrData object
/// </summary>
/// <returns>An INCldrData object from the NCldr data file</returns>
public INCldrData Load()
{
if (!this.Exists())
{
return null;
}
NCldrData ncldrData = null;
using (FileStream stream = File.OpenRead(this.NCldrDataFilename))
{
try
{
BsonReader bsonReader = new BsonReader(stream);
JsonSerializer serializer = new JsonSerializer();
ncldrData = serializer.Deserialize<NCldrData>(bsonReader);
}
catch (SerializationException exception)
{
Console.WriteLine("Failed to deserialize. Reason: " + exception.Message);
throw;
}
}
return ncldrData;
}