public async Task <byte[]> Serialize(HttpResponseMessage response, CancellationToken token) { var request = response.RequestMessage; response.RequestMessage = null; if (response.Content != null) { await response.Content.LoadIntoBufferAsync(); } var httpMessageContent = new HttpMessageContent(response); token.ThrowIfCancellationRequested(); var buffer = await httpMessageContent.ReadAsByteArrayAsync(); response.RequestMessage = request; using (var stream = new MemoryStream()) { await stream.WriteAsync(buffer, 0, buffer.Length, token); return(stream.ToArray()); } }
public Task SerializeAsync(HttpRequestMessage request, Stream stream) { if (request.Content != null) { return request.Content.LoadIntoBufferAsync() .Then(() => { var httpMessageContent = new HttpMessageContent(request); // All in-memory and CPU-bound so no need to async httpMessageContent.ReadAsByteArrayAsync().Then( buffer => { return Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer, 0, buffer.Length, null, TaskCreationOptions.AttachedToParent); }); }); } else { var httpMessageContent = new HttpMessageContent(request); // All in-memory and CPU-bound so no need to async return httpMessageContent.ReadAsByteArrayAsync().Then( buffer => { return Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer, 0, buffer.Length, null, TaskCreationOptions.AttachedToParent); } ); } }
/// <inheritdoc /> public async Task <Message <byte[], byte[]> > Convert(HttpRequestMessage request) { _log.LogTrace("create full HttpRequestMessage to kafka"); var content = new HttpMessageContent(request); var bytesTask = content.ReadAsByteArrayAsync(); var message = new Message <byte[], byte[]> { Key = null, Value = await bytesTask, Timestamp = new Timestamp(DateTimeOffset.Now.ToUnixTimeMilliseconds(), TimestampType.CreateTime), }; if (request.Headers.TryGetValues(KafkaQueueConsts.KafkaKey, out var key)) { var firstKey = key.FirstOrDefault(); if (string.IsNullOrWhiteSpace(firstKey)) { throw new ArgumentException($"If header {KafkaQueueConsts.KafkaKey} set, then header cannot be null or empty"); } _log.LogTrace($"Add key", firstKey); message.Key = KafkaExtensions.HeaderValue(firstKey); } return(message); }
public async Task <HttpResponseMessage> Send(HttpRequestMessage request, CancellationToken token) { var options = request.Properties.ContainsKey(NatsQueueClientOption.ConnectionProperty) ? request.Properties[NatsQueueClientOption.ConnectionProperty] as Options : _clientOption.Options; if (options == null) { throw new ArgumentException( $"ConnectionFactory in option or {nameof(request.Properties)} key name {NatsQueueClientOption.ConnectionProperty} must be set"); } var content = new HttpMessageContent(request); var bytesTask = content.ReadAsByteArrayAsync(); var correlation = request.Headers.GetCorrelationHeader(); var connection = _connection.CreateConnection(options); if (correlation != null) { var responseMsg = await connection.RequestAsync(request.RequestUri.Host, await bytesTask, token); var responseMessage = await _responseParser.Parse(responseMsg.Data, token); return(responseMessage); } var bytes = await bytesTask; connection.Publish(request.RequestUri.Host, bytes); _log.LogTrace("Message to {url} sended", request.RequestUri.Host); return(new HttpResponseMessage(HttpStatusCode.OK)); }
public Task SerializeAsync(Task <HttpResponseMessage> response, Stream stream) { return(response.Then(r => { if (r.Content != null) { return r.Content.LoadIntoBufferAsync() .Then(() => { var httpMessageContent = new HttpMessageContent(r); // All in-memory and CPU-bound so no need to async return httpMessageContent.ReadAsByteArrayAsync(); }) .Then(buffer => { return Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer, 0, buffer.Length, null, TaskCreationOptions.AttachedToParent); } ); ; } else { var httpMessageContent = new HttpMessageContent(r); // All in-memory and CPU-bound so no need to async var buffer = httpMessageContent.ReadAsByteArrayAsync().Result; return Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer, 0, buffer.Length, null, TaskCreationOptions.AttachedToParent); } } )); }
public async Task SerializeAsync(Task <HttpResponseMessage> response, Stream stream) { var r = await response; if (r.Content != null) { await r.Content.LoadIntoBufferAsync(); var httpMessageContent = new HttpMessageContent(r); // All in-memory and CPU-bound so no need to async var buffer = await httpMessageContent.ReadAsByteArrayAsync(); await Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer, 0, buffer.Length, null, TaskCreationOptions.AttachedToParent); } else { var httpMessageContent = new HttpMessageContent(r); // All in-memory and CPU-bound so no need to async var buffer = await httpMessageContent.ReadAsByteArrayAsync(); await Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer, 0, buffer.Length, null, TaskCreationOptions.AttachedToParent); } }
public async Task <byte[]> Convert(HttpResponse response) { if (response.Body.CanSeek) { response.Body.Position = 0; } var message = new HttpResponseMessage { StatusCode = (HttpStatusCode)response.StatusCode, Content = new StreamContent(response.Body), }; message.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(response.ContentType); message.Content.Headers.ContentLength = response.Body.Length; foreach (var header in response.Headers) { message.Headers.TryAddWithoutValidation(header.Key, header.Value.AsEnumerable()); } var content = new HttpMessageContent(message); var bytes = await content.ReadAsByteArrayAsync(); return(bytes); }
public async Task SerializeAsync(HttpRequestMessage request, Stream stream) { if (request.Content != null && _bufferContent) { await request.Content.LoadIntoBufferAsync(); } var httpMessageContent = new HttpMessageContent(request); var buffer = await httpMessageContent.ReadAsByteArrayAsync(); stream.Write(buffer, 0, buffer.Length); }
public Task SerializeAsync(Task <HttpResponseMessage> response, Stream stream) { return(response.Then(r => { if (r.Content != null) { TraceWriter.WriteLine("SerializeAsync - before load", TraceLevel.Verbose); return r.Content.LoadIntoBufferAsync() .Then(() => { TraceWriter.WriteLine("SerializeAsync - after load", TraceLevel.Verbose); var httpMessageContent2 = new HttpMessageContent(r); // All in-memory and CPU-bound so no need to async return httpMessageContent2.ReadAsByteArrayAsync(); }) .Then(buffer => { TraceWriter.WriteLine("SerializeAsync - after ReadAsByteArrayAsync", TraceLevel.Verbose); return Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer, 0, buffer.Length, null, TaskCreationOptions.AttachedToParent); } ); ; } TraceWriter.WriteLine("Content NULL - before load", TraceLevel.Verbose); var httpMessageContent = new HttpMessageContent(r); // All in-memory and CPU-bound so no need to async var buffer2 = httpMessageContent.ReadAsByteArrayAsync().Result; return Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, buffer2, 0, buffer2.Length, null, TaskCreationOptions.AttachedToParent); } )); }
/// <summary> /// /// </summary> /// <param name="args"></param> /// <param name="context"></param> /// <param name="connection"></param> /// <returns></returns> public async Task ProcessResponse(MsgHandlerEventArgs args, HttpContext context, IConnection connection) { if (args.Message.Reply != null) { _log.LogTrace($"Create response to reply {args.Message.Reply}"); if (context.Response.Body.CanSeek) { context.Response.Body.Position = 0; } var response = new HttpResponseMessage { StatusCode = (HttpStatusCode)context.Response.StatusCode, Content = new StreamContent(context.Response.Body), }; response.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(context.Response.ContentType); response.Content.Headers.ContentLength = context.Response.Body.Length; foreach (var header in context.Response.Headers) { response.Headers.TryAddWithoutValidation(header.Key, header.Value.AsEnumerable()); } var content = new HttpMessageContent(response); var bytes = await content.ReadAsByteArrayAsync(); _log.LogTrace($"Send response to reply {args.Message.Reply}"); connection.Publish(args.Message.Reply, bytes); _log.LogTrace($"Response to reply {args.Message.Reply} sended"); } else { _log.LogTrace($"reply is empty, response not be sended. request url {context.Request.GetDisplayUrl()}"); } }
public async Task SerializeAsync(HttpResponseMessage response, Stream stream) { if (response.Content != null) { TraceWriter.WriteLine("SerializeAsync - before load", TraceLevel.Verbose); if (_bufferContent) { await response.Content.LoadIntoBufferAsync(); } TraceWriter.WriteLine("SerializeAsync - after load", TraceLevel.Verbose); } else { TraceWriter.WriteLine("Content NULL - before load", TraceLevel.Verbose); } var httpMessageContent = new HttpMessageContent(response); var buffer = await httpMessageContent.ReadAsByteArrayAsync(); TraceWriter.WriteLine("SerializeAsync - after ReadAsByteArrayAsync", TraceLevel.Verbose); stream.Write(buffer, 0, buffer.Length); }