public static HttpRequestPacket ToHttpRequestPacket (this HttpRequestMessage request)
{
var packet = new HttpRequestPacket();
foreach (var hdr in request.Headers)
{
packet.AddHeader(hdr);
}
if (request.Content != null)
{
foreach (var hdr in request.Content.Headers)
{
packet.AddHeader(hdr);
}
}
packet.Method = request.Method.Method;
packet.Version = request.Version.ToString();
packet.Resource = request.RequestUri.IsAbsoluteUri ? request.RequestUri.PathAndQuery : request.RequestUri.OriginalString;
if (request.Content != null)
{
packet.Content = request.Content.ReadAsByteArrayAsync().Result;
}
return packet;
}
public static HttpRequestPacket ToHttpRequestPacket(this HttpRequestMessage request)
{
var packet = new HttpRequestPacket();
foreach (var hdr in request.Headers)
{
packet.AddHeader(hdr);
}
if (request.Content != null)
{
foreach (var hdr in request.Content.Headers)
{
packet.AddHeader(hdr);
}
}
packet.Method = request.Method.Method;
packet.Version = request.Version.ToString();
packet.Resource = request.RequestUri.IsAbsoluteUri ? request.RequestUri.PathAndQuery : request.RequestUri.OriginalString;
if (request.Content != null)
{
packet.Content = request.Content.ReadAsByteArrayAsync().Result;
}
return(packet);
}
public static HttpRequestPacket ToHttpRequestPacket(this HttpRequestMessage request)
{
var packet = new HttpRequestPacket();
foreach (var hdr in request.Headers)
{
packet.AddHttpHeader(hdr);
}
if (request.Content != null)
{
foreach (var hdr in request.Content.Headers)
{
packet.AddHttpHeader(hdr);
}
}
packet.Method = request.Method.Method;
packet.Version = request.Version.ToString();
packet.Resource = request.RequestUri.IsAbsoluteUri ? request.RequestUri.PathAndQuery : request.RequestUri.OriginalString;
if (request.Content != null)
{
using (MemoryStream ms = new MemoryStream())
{
request.Content.CopyToAsync(ms).Wait();
packet.Content = ms.ToArray();
}
}
return packet;
}
///<summary>Adds a header to the request packet. </summary>
///<remarks>NOTE: This method folds the headers as expected in WebAPI 2's Request.Header object.</remarks>
private static void AddHeader(this HttpRequestPacket packet, KeyValuePair <string, IEnumerable <string> > hdr)
{
if (packet == null)
{
throw new ArgumentNullException("packet");
}
if (packet.Headers.ContainsKey(hdr.Key))
{
var headerValue = ((List <string>)packet.Headers[hdr.Key])[0];
if (String.IsNullOrEmpty(headerValue))
{
headerValue = String.Join(", ", hdr.Value);
}
else
{
headerValue = headerValue + ", " + String.Join(", ", hdr.Value);
}
((List <string>)packet.Headers[hdr.Key])[0] = headerValue;
}
else
{
packet.Headers.Add(hdr.Key, new List <string>()
{
String.Join(", ", hdr.Value)
});
}
}
protected virtual void HandleOnPacketFlow(HttpRequestPacket packet)
{
OnPacketFlowHandler handler = OnPacketFlow;
if (handler != null)
{
handler(packet);
}
}
public RequestWrapper(HttpRequestPacket request)
{
//Add Content-Length Header if request has content.
if (request.Content != null && request.Content.Length > 0)
{
request.Headers["Content-Length"] = new string[] { request.Content.Length.ToString() };
}
this.request = request;
}
private bool TryGetRequest(ConcurrentQueueingConsumer consumer, out HttpRequestPacket request, out MessageDispatch dispatch)
{
request = null;
dispatch = null;
BasicDeliverEventArgs item;
if (!consumer.TryInstantDequeue(out item, throwIfClosed: false))
{
return(false);
}
//TODO: Pool MessageDispatch
//Get message
dispatch = new MessageDispatch {
Consumer = consumer, Delivery = item
};
//Deserialize message
bool wasDeserialized = true;
try
{
request = HttpRequestPacket.Deserialize(item.Body);
}
catch
{
wasDeserialized = false;
}
if (wasDeserialized)
{
//Add/Update Subscriber-Id header
request.Headers[Common.Shared.SUBSCRIBER_ID_HEADER] = this.subscriberIdHeader;
//Add redelivered header if item was redelivered.
if (item.Redelivered)
{
request.Headers[Common.Shared.REDELIVERED_HEADER] = TRUE_STRING_ARRAY;
}
}
//Reject message if deserialization failed.
else if (!wasDeserialized && Settings.AckBehavior != SubscriberAckBehavior.Automatic)
{
consumer.Model.BasicReject(item.DeliveryTag, false);
return(false);
}
return(true);
}
/// <summary>
/// Grabs the basic request headers from the first valid response packet from capture device
/// </summary>
public void Initialize(HttpRequestPacket requestPacket)
{
MergeHeaders(new Dictionary <string, string> {
{ "signin-session", requestPacket.HeaderSigninSession },
{ "signin-userId", requestPacket.HeaderSigninUserId },
{ "signin-authKey", requestPacket.HeaderSigninAuthKey },
{ "sign-code", requestPacket.HeaderSignCode },
{ "client-ver", requestPacket.HeaderClientVersion },
{ "platform-id", requestPacket.HeaderPlatformId },
{ "locale-name", requestPacket.HeaderClientLocaleName },
});
TargetUrl = "http://" + requestPacket.RequestHost + requestPacket.RequestUrl;
IsInitialized = true;
}
private IEnumerable <string> GetHeaderValues(HttpRequestPacket request, string header)
{
header = header.Trim().ToUpperInvariant();
var hdrs = request.Headers;
if (hdrs == null)
{
return(Enumerable.Empty <String>());
}
foreach (var kvp in hdrs)
{
if (kvp.Key.ToUpperInvariant() == header)
{
return(kvp.Value);
}
}
return(Enumerable.Empty <String>());
}
private static bool TryGetHttpRequestMessage(HttpRequestPacket packet, string virtualPath, string hostname, out HttpRequestMessage request)
{
try
{
request = new HttpRequestMessage
{
Content = packet.Content == null ? _emptyByteArrayContent : new ByteArrayContent(packet.Content),
Version = packet.Version == "1.1" ? VERSION_1_1 : new Version(packet.Version),
Method = new HttpMethod(packet.Method ?? "GET"),
RequestUri = packet.BuildUri(virtualPath, hostname)
};
packet.PopulateHeaders(request.Content.Headers, request.Headers);
}
catch
{
request = null;
return(false);
}
return(true);
}
internal static bool TryGetServiceMessage(this HttpRequestPacket request, out ServiceMessage message)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
message = new ServiceMessage();
//Build Request
IHttpRequestFeature req = message as IHttpRequestFeature;
Uri uri;
try
{
uri = request.BuildUri(null, null);
}
catch
{
message = null;
return(false);
}
req.Path = uri.AbsolutePath;
req.Protocol = "HTTP/" + request.Version;
req.QueryString = uri.Query;
req.Method = request.Method;
if (request.Content != null && request.Content.Length > 0)
{
message.CreateRequestBody(request.Content);
}
//Add Request Headers
{
var headers = new HeaderDictionary();
foreach (var hdr in request.Headers)
{
if (hdr.Key != null && hdr.Key.Trim().ToUpperInvariant() == "CONTENT-LENGTH")
{
continue; // Content-length is calculated based on actual content.
}
//NOTE: Client already folds Request Headers into RequestPacket, so there's no need to fold it again here.
headers.Add(hdr.Key, hdr.Value.ToArray());
}
if (message.OriginalRequestBody != null)
{
headers.Add("Content-Length", request.Content.Length.ToString());
}
req.Headers = headers;
}
//Create Response
message.CreateResponseBody();
IHttpResponseFeature resp = message as IHttpResponseFeature;
resp.StatusCode = 200;
//Add Response Headers
{
var headers = new HeaderDictionary();
headers.Add("Server", HTTP_RESPONSE_SERVER_HEADER[0]);
resp.Headers = headers;
}
return(true);
}
private bool TryGetRequest(SharedQueue <BasicDeliverEventArgs> queue, out HttpRequestPacket request, out IBasicProperties properties)
{
object obj;
BasicDeliverEventArgs evt;
request = null;
properties = null;
obj = queue.DequeueNoWait(null);
if (obj != null)
{
evt = (BasicDeliverEventArgs)obj;
}
else
{
return(false);
}
//Get message properties
properties = evt.BasicProperties;
//Deserialize message
bool wasDeserialized = true;
try
{
request = HttpRequestPacket.Deserialize(evt.Body);
//Add/Update Content-Length Header
request.Headers["Content-Length"] = new string[] { (request.Content == null ? 0 : request.Content.Length).ToString() };
//Add/Update Subscriber-Id header
request.Headers[Common.Shared.SUBSCRIBER_ID_HEADER] = new string[] { this.subscriberId };
}
catch
{
wasDeserialized = false;
}
//Ack or reject message
if (evt.ConsumerTag == workConsumer.ConsumerTag)
{
if (wasDeserialized)
{
workConsumer.Model.BasicAck(evt.DeliveryTag, false);
return(true);
}
else
{
workConsumer.Model.BasicReject(evt.DeliveryTag, false);
return(false);
}
}
else if (evt.ConsumerTag == subscriberConsumer.ConsumerTag)
{
if (wasDeserialized)
{
subscriberConsumer.Model.BasicAck(evt.DeliveryTag, false);
return(true);
}
else
{
subscriberConsumer.Model.BasicReject(evt.DeliveryTag, false);
return(false);
}
}
else
{
throw new InvalidOperationException("Message was dequeued by an unexpected/unknown consumer");
}
}
public RequestWrapper(HttpRequestPacket request)
{
this.request = request;
}
