public void SerializeStream() { const int size = 10 * 1024 * 1024; var dataBuffer = CreateRandomBuffer(size); var data = new TestModel { Name = "Test", Stream = new MemoryStream(dataBuffer) }; var buffer = BinaryConvert.Serialize(data); Assert.NotNull(buffer); var result = BinaryConvert.Deserialize <TestModel>(buffer); Assert.Equal(result.Name, data.Name); Assert.NotNull(result.Stream); Assert.Equal(result.Stream.Length, size); var memory = result.Stream as MemoryStream; var memoryBuffer = memory.ToArray(); for (int i = 0; i < size; i++) { Assert.Equal(dataBuffer[i], memoryBuffer[i]); } }
public async Task ShouldUploadImageMultipartBinary() { var client = _fixture.CreateClient(); if (File.Exists("Image2.png")) { File.Delete("Image2.png"); } using var fs = File.OpenRead("cybtan.png"); var content = new MultipartFormDataContent("----WebKitFormBoundarymx2fSWqWSd0OxQq1"); var bytes = BinaryConvert.Serialize(new { Size = fs.Length, Name = "Image2.png" }); var byteArrayContent = new ByteArrayContent(bytes); byteArrayContent.Headers.ContentType = MediaTypeHeaderValue.Parse($"{BinarySerializer.MEDIA_TYPE}; charset={BinarySerializer.DefaultEncoding.WebName}"); content.Add(byteArrayContent); content.Add(new StreamContent(fs, (int)fs.Length), "Image", "Image.png"); var response = await client.PostAsync("/api/order/upload", content); Assert.NotNull(response); Assert.True(response.IsSuccessStatusCode); }
public async Task <T> GetOrSet <T>(string key, Func <Task <T> > func, TimeSpan?expire = null) where T : class { T cacheEntry; RedisValue entry = await _db.StringGetAsync(key).ConfigureAwait(false); if (!entry.HasValue) { cacheEntry = await func(); if (cacheEntry == null) { throw new InvalidOperationException($"Cache entry can not be null"); } var bytes = BinaryConvert.Serialize(cacheEntry); var result = await _db.StringSetAsync(key, bytes, expiry : expire).ConfigureAwait(false); if (!result) { throw new InvalidOperationException("cache error"); } return(cacheEntry); } return(BinaryConvert.Deserialize <T>(entry)); }
public void BinarySerializeWithMetadataProvider() { var buffer = BinaryConvert.Serialize(_products); var result = BinaryConvert.Deserialize <List <Product> >(buffer); AssertProducts(result); }
public void BinarySerialize() { var buffer = BinaryConvert.Serialize(_modelA); var result = BinaryConvert.Deserialize <ModelA>(buffer); Assert(result); }
public async Task Set(string key, object item, TimeSpan?expire = null) { var bytes = BinaryConvert.Serialize(item); var result = await _db.StringSetAsync(key, bytes, expiry : expire).ConfigureAwait(false); if (!result) { throw new InvalidOperationException("cache error"); } }
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var response = new HttpResponseMessage { Content = new ByteArrayContent(BinaryConvert.Serialize(new Customer { Id = Guid.NewGuid(), Name = "" })), StatusCode = System.Net.HttpStatusCode.OK }; response.Content.Headers.ContentType = new MediaTypeHeaderValue(BinarySerializer.MEDIA_TYPE); return(Task.FromResult(response)); }
public async Task Publish(object message, string?exchange, string?topic) { if (exchange == null || topic == null) { Type type = message.GetType(); var binding = _subscriptionManager.GetBindingForType(type, exchange, topic); if (binding == null) { throw new QueuePublishException($"Exchange not found for {message.GetType()}", message); } exchange = binding.Exchange; topic = binding.Topic; } var data = BinaryConvert.Serialize(message); await _subscriptionManager.HandleMessage(exchange, topic, data).ConfigureAwait(false); }
public void SerializeValidationResult() { var result = new ValidationResult("An error occurred while updating the entries. See the inner exception for details.\r\n----Inner Exception-- -\r\nSQLite Error 19: 'UNIQUE constraint failed: Ordes.Id'.\r\n") { StackTrace = " at Cybtans.Entities.EntityFrameworkCore.EfUnitOfWork.SaveChangesAsyncInternal() in C:\\projects\\Cybtans\\cybtans-sdk\\CybtansSDK\\Cybtans.Entities.EntityFrameworkCore\\EfUnitOfWork.cs:line 122\r\n at Cybtans.Entities.EntityFrameworkCore.EfUnitOfWork.SaveChangesAsync() in C:\\projects\\Cybtans\\cybtans-sdk\\CybtansSDK\\Cybtans.Entities.EntityFrameworkCore\\EfUnitOfWork.cs:line 143\r\n at Cybtans.Entities.EventLog.EntityEventPublisher.PublishAll(IEnumerable`1 entityEvents) in C:\\projects\\Cybtans\\cybtans-sdk\\CybtansSDK\\Cybtans.Entities.EventLog\\EntityEventPublisher.cs:line 117\r\n at Cybtans.Entities.EntityFrameworkCore.EfUnitOfWork.SaveChangesAsync() in C:\\projects\\Cybtans\\cybtans-sdk\\CybtansSDK\\Cybtans.Entities.EntityFrameworkCore\\EfUnitOfWork.cs:line 155\r\n at Cybtans.Services.CrudService`8.Create(TEntityDto request) in C:\\projects\\Cybtans\\cybtans-sdk\\CybtansSDK\\Cybtans.Services\\CrudService.cs:line 339\r\n at lambda_method(Closure , Object )\r\n at Microsoft.Extensions.Internal.ObjectMethodExecutorAwaitable.Awaiter.GetResult()\r\n at Microsoft.AspNetCore.Mvc.Infrastructure.ActionMethodExecutor.AwaitableObjectResultExecutor.Execute(IActionResultTypeMapper mapper, ObjectMethodExecutor executor, Object controller, Object[] arguments)\r\n at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.<InvokeActionMethodAsync>g__Awaited|12_0(ControllerActionInvoker invoker, ValueTask`1 actionResultValueTask)\r\n at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.<InvokeNextActionFilterAsync>g__Awaited|10_0(ControllerActionInvoker invoker, Task lastTask, State next, Scope scope, Object state, Boolean isCompleted)\r\n at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.Rethrow(ActionExecutedContextSealed context)\r\n at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.Next(State& next, Scope& scope, Object& state, Boolean& isCompleted)\r\n at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.InvokeInnerFilterAsync()\r\n--- End of stack trace from previous location where exception was thrown ---\r\n at Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeNextExceptionFilterAsync>g__Awaited|25_0(ResourceInvoker invoker, Task lastTask, State next, Scope scope, Object state, Boolean isCompleted)" }; var bytes = BinaryConvert.Serialize(result); Assert.NotEmpty(bytes); var obj = BinaryConvert.Deserialize <ValidationResult>(bytes); Assert.NotNull(obj); Assert.NotEmpty(obj.ErrorMessage); Assert.NotEmpty(obj.StackTrace); }
public Task Publish(object message, string?exchange, string?topic) { if (exchange == null || topic == null) { Type type = message.GetType(); var binding = _subscriptionManager.GetBindingForType(type, exchange, topic); if (binding == null) { throw new QueuePublishException($"Exchange not found for {message.GetType()}", message); } exchange = binding.Exchange; topic = binding.Topic; } var bytes = BinaryConvert.Serialize(message); return(Task.Run(() => PublishInternal(exchange, topic, bytes))); }
private async Task <EntityEventLog> PublishInternal(EntityEvent entityEvent) { entityEvent.CreateTime = DateTime.Now; var type = entityEvent.GetType(); var data = EntityUtilities.ToDictionary(entityEvent); EntityEventLog log = new EntityEventLog { CreateTime = DateTime.Now, Data = BinaryConvert.Serialize(data), EntityEventType = type.FullName, State = EventStateEnum.NotPublished }; entityEvent.State = EventStateEnum.NotPublished; var binding = _messageQueue.GetBinding(type, entityEvent.Topic); if (binding == null) { throw new QueuePublishException($"Bindindg information not found for {type}"); } log.Exchange = binding.Exchange; log.Topic = binding.Topic; try { entityEvent.State = EventStateEnum.Published; log.State = EventStateEnum.Published; await _messageQueue.Publish(log.Data, binding.Exchange, binding.Topic).ConfigureAwait(false); } catch (Exception ex) { entityEvent.State = EventStateEnum.NotPublished; log.State = EventStateEnum.NotPublished; log.ErrorMessage = ex.Message; _logger?.LogError(ex, $"Unable to publish event {type.Name} Exchange:{log.Exchange} Topic:{log.Topic}"); } return(log); }
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { HttpResponseMessage response; if (request.Headers.Authorization != null && request.Headers.Authorization.Parameter == null) { response = new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden) { ReasonPhrase = "Access Token Expired", RequestMessage = request, }; } else { _retry++; if (_retry >= 3) { var data = new GetAllOrderStateResponse { Items = Enumerable.Range(1, 100).Select(x => new OrderStateDto { Id = x, Name = $"{x}" }).ToList(), Page = 0, TotalCount = 100, TotalPages = 1 }; response = new HttpResponseMessage(System.Net.HttpStatusCode.OK); response.Content = new ByteArrayContent(BinaryConvert.Serialize(data)); response.Content.Headers.ContentType = new MediaTypeHeaderValue(BinarySerializer.MEDIA_TYPE); } else { response = new HttpResponseMessage(System.Net.HttpStatusCode.Unauthorized) { ReasonPhrase = "Access Token Expired", RequestMessage = request, }; } } return(Task.FromResult(response)); }
public void SerializeTest() { ValidationResult result = new ValidationResult(); result.AddError("Name", "Name is required"); result.AddError("Name", "Name is not valid"); result.AddError("Lastname", "LastName is required"); var bytes = BinaryConvert.Serialize(result); result = BinaryConvert.Deserialize <ValidationResult>(bytes); Assert.True(result.HasErrors); Assert.Equal(2, result.Errors.Count); Assert.Equal(2, result.Errors["Name"].Count); Assert.Single(result.Errors["Lastname"]); Assert.Equal("Name is required", result.Errors["Name"][0]); Assert.Equal("Name is not valid", result.Errors["Name"][1]); Assert.Equal("LastName is required", result.Errors["Lastname"][0]); }
private async Task HandleExceptionAsync(HttpContext context, Exception exception) { if (context.Request.Headers.ContainsKey("Accept") && context.Request.Headers["Accept"].FirstOrDefault() == BinarySerializer.MEDIA_TYPE) { context.Response.ContentType = BinarySerializer.MEDIA_TYPE; context.Response.StatusCode = (int)HttpStatusCode.InternalServerError; await context.Response.BodyWriter.WriteAsync(BinaryConvert.Serialize( new { context.Response.StatusCode, Message = $"Internal Server Error {exception.Message}", })); } else { context.Response.ContentType = "application/json"; context.Response.StatusCode = (int)HttpStatusCode.InternalServerError; await context.Response.WriteAsync(System.Text.Json.JsonSerializer.Serialize(new { context.Response.StatusCode, Message = $"Internal Server Error {exception.Message}", })); } }