/// <summary>
/// Returns an instance of the IODataRequestMessage
/// </summary>
/// <param name="requestMessageArgs">Arguments for creating the request message.</param>
/// <returns>an instance of the IODataRequestMessage </returns>
internal DataServiceClientRequestMessage CreateRequestMessage(BuildingRequestEventArgs requestMessageArgs)
{
var headersDictionary = requestMessageArgs.HeaderCollection.UnderlyingDictionary;
// We are implementing the PostTunneling logic here. The reason for doing this is
// 1> In this public class, the Method property returns the actual method (PUT, PATCH, DELETE),
// and not the verb that goes in the wire. So this class needs to know about
// actual verb since it will be using this verb to send over http.
if (this.UsePostTunneling)
{
bool setXHttpMethodHeader = false;
if (string.CompareOrdinal(XmlConstants.HttpMethodGet, requestMessageArgs.Method) != 0 &&
string.CompareOrdinal(XmlConstants.HttpMethodPost, requestMessageArgs.Method) != 0)
{
setXHttpMethodHeader = true;
}
// Setting the actual method in the header
if (setXHttpMethodHeader)
{
headersDictionary[XmlConstants.HttpXMethod] = requestMessageArgs.Method;
}
// Set the Content-length of a Delete to 0. Important for post tunneling when its a post, content-length must be zero in this case.
if (string.CompareOrdinal(XmlConstants.HttpMethodDelete, requestMessageArgs.Method) == 0)
{
headersDictionary[XmlConstants.HttpContentLength] = "0";
#if DEBUG
if (!this.UserModifiedRequestInBuildingRequest)
{
Debug.Assert(!requestMessageArgs.HeaderCollection.HasHeader(XmlConstants.HttpContentType), "Content-Type header must not be set for DELETE requests");
}
#endif
}
}
#if !ASTORIA_LIGHT
var clientRequestMessageArgs = new DataServiceClientRequestMessageArgs(requestMessageArgs.Method, requestMessageArgs.RequestUri, this.UseDefaultCredentials, this.UsePostTunneling, headersDictionary);
#else
var clientRequestMessageArgs = new DataServiceClientRequestMessageArgs(requestMessageArgs.Method, requestMessageArgs.RequestUri, this.UsePostTunneling, this.UseDefaultCredentials, headersDictionary, requestMessageArgs.ClientHttpStack);
#endif
DataServiceClientRequestMessage clientRequestMessage;
if (this.Configurations.RequestPipeline.OnMessageCreating != null)
{
clientRequestMessage = this.Configurations.RequestPipeline.OnMessageCreating(clientRequestMessageArgs);
if (clientRequestMessage == null)
{
throw Error.InvalidOperation(Strings.Context_OnMessageCreatingReturningNull);
}
}
else
{
clientRequestMessage = new HttpWebRequestMessage(clientRequestMessageArgs);
}
return(clientRequestMessage);
}
private static HttpWebRequest CreateRequest(string method, Uri requestUrl, DataServiceClientRequestMessageArgs args)
{
HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(requestUrl);
// KeepAlive not available
httpRequest.KeepAlive = true;
httpRequest.Method = method;
return(httpRequest);
}
public CustomizedRequestMessage(DataServiceClientRequestMessageArgs args, ConnectionProperties properties)
: base(args)
{
HttpWebRequest.Proxy = properties.GetWebProxy();
HttpWebRequest.Headers.Add(properties.GetCustomHeaders());
var cert = properties.GetClientCertificate();
if (cert != null)
{
HttpWebRequest.ClientCertificates.Add(cert);
}
}
/// <summary>
/// Creates an instance of the IODataRequestMessage
/// </summary>
/// <param name="requestMessageArgs">Arguments for creating the request message.</param>
/// <returns>an instance of the IODataRequestMessage </returns>
internal DataServiceClientRequestMessage CreateMessage(DataServiceClientRequestMessageArgs requestMessageArgs)
{
var requestMessage = this.getRequestMessage();
requestMessage.Url = requestMessageArgs.RequestUri;
requestMessage.Method = requestMessageArgs.Method;
foreach (var header in requestMessageArgs.Headers)
{
requestMessage.SetHeader(header.Key, header.Value);
}
return new TestDataServiceClientRequestMessage(requestMessage, getResponseMessage);
}
private static HttpWebRequest CreateRequest(string method, Uri requestUrl, DataServiceClientRequestMessageArgs args)
{
HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(requestUrl);
#if PORTABLELIB
// Set same default as Silverlight when running silverlight in .Net Portable
if (IsRunningOnSilverlight)
{
httpRequest.UseDefaultCredentials = args.UseDefaultCredentials;
}
#else
// KeepAlive not available
httpRequest.KeepAlive = true;
#endif
httpRequest.Method = method;
return(httpRequest);
}
/// <summary>
/// Constructor for HttpClientRequestMessage.
/// Initializes the <see cref="HttpClientRequestMessage"/> class.
/// The args.ActualMethod is the actual method. In post tunneling situations method will be POST instead of the specified verb method.
/// The args.method is the specified verb method
/// </summary>
/// </summary>
public HttpClientRequestMessage(DataServiceClientRequestMessageArgs args)
: base(args.ActualMethod)
{
_messageStream = new MemoryStream();
_handler = new HttpClientHandler();
_client = new HttpClient(_handler, disposeHandler: true);
_contentHeaderValueCache = new Dictionary <string, string>();
_effectiveHttpMethod = args.Method;
_requestUrl = args.RequestUri;
_requestMessage = new HttpRequestMessage(new HttpMethod(this.ActualMethod), _requestUrl);
// Now set the headers.
foreach (KeyValuePair <string, string> keyValue in args.Headers)
{
this.SetHeader(keyValue.Key, keyValue.Value);
}
}
public HttpWebRequestMessage(DataServiceClientRequestMessageArgs args)
: base(args.ActualMethod)
{
Util.CheckArgumentNull(args, "args");
Debug.Assert(args.RequestUri.IsAbsoluteUri, "request uri is not absolute uri");
Debug.Assert(
args.RequestUri.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase) ||
args.RequestUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase),
"request uri is not for HTTP");
this.effectiveHttpMethod = args.Method;
this.requestUrl = args.RequestUri;
this.httpRequest = HttpWebRequestMessage.CreateRequest(this.ActualMethod, this.Url, args);
// Now set the headers.
foreach (var keyValue in args.Headers)
{
this.SetHeader(keyValue.Key, keyValue.Value);
}
}
public void ChangeMergeToPatch()
{
Func<DataServiceClientRequestMessageArgs, DataServiceClientRequestMessage> addHeader =
(args) =>
{
if (args.Method == "MERGE")
{
var newArgs = new DataServiceClientRequestMessageArgs("PATCH", args.RequestUri, true, args.UsePostTunneling, args.Headers);
// PATCH verb not supported in V1 or V2
newArgs.Headers.Remove("DataServiceVersion");
newArgs.Headers.Add("DataServiceVersion", "3.0");
return new HttpWebRequestMessage(newArgs);
}
return new HttpWebRequestMessage(args);
};
var ctx = this.CreateContext(addHeader);
Product product = null;
var query = ctx.Context.Product.Take(1) as DataServiceQuery<Product>;
var ar = query.BeginExecute(null, null).EnqueueWait(this);
product = query.EndExecute(ar).Single();
this.lastRequestMessage = null;
product.Description = "New Description " + Guid.NewGuid().ToString();
ctx.UpdateObject(product);
var ar2 = ctx.BeginSaveChanges(null, null).EnqueueWait(this);
ctx.EndSaveChanges(ar2);
Assert.IsNotNull(this.lastRequestMessage, "No request sent");
Assert.AreEqual("PATCH", this.lastRequestMessage.Method);
}
public HttpWebRequestMessage(DataServiceClientRequestMessageArgs args)
: base(args.ActualMethod)
{
Util.CheckArgumentNull(args, "args");
Debug.Assert(args.RequestUri.IsAbsoluteUri, "request uri is not absolute uri");
Debug.Assert(
args.RequestUri.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase) ||
args.RequestUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase),
"request uri is not for HTTP");
this.effectiveHttpMethod = args.Method;
this.requestUrl = args.RequestUri;
this.httpRequest = HttpWebRequestMessage.CreateRequest(this.ActualMethod, this.Url, args);
// Now set the headers.
foreach (var keyValue in args.Headers)
{
this.SetHeader(keyValue.Key, keyValue.Value);
}
}
public TestHttpWebRequestMessage(
DataServiceClientRequestMessageArgs args,
Action<HttpWebRequestMessage> sendRequest,
Action<HttpWebResponseMessage> sendResponse,
Func<Stream, Stream> wrapRequestStream,
Func<Stream, Stream> wrapResponseStream) : base(args)
{
this.SendRequest = sendRequest;
this.SendResponse = sendResponse;
this.WrapRequestStream = wrapRequestStream;
this.WrapResponseStream = wrapResponseStream;
}
/// <summary>
/// Loads the metadata and converts it into an EdmModel that is then used by a dataservice context
/// This allows the user to use the DataServiceContext directly without having to manually pass an IEdmModel in the Format
/// </summary>
/// <returns>A service model to be used in format tracking</returns>
internal IEdmModel LoadServiceModelFromNetwork()
{
HttpWebRequestMessage httpRequest;
BuildingRequestEventArgs requestEventArgs = null;
// test hook for injecting a network request to use instead of the default
if (InjectMetadataHttpNetworkRequest != null)
{
httpRequest = InjectMetadataHttpNetworkRequest();
}
else
{
requestEventArgs = new BuildingRequestEventArgs(
"GET",
context.GetMetadataUri(),
null,
null,
context.HttpStack);
// fire the right events if they exist to allow user to modify the request
if (context.HasBuildingRequestEventHandlers)
{
requestEventArgs = context.CreateRequestArgsAndFireBuildingRequest(
requestEventArgs.Method,
requestEventArgs.RequestUri,
requestEventArgs.HeaderCollection,
requestEventArgs.ClientHttpStack,
requestEventArgs.Descriptor);
}
DataServiceClientRequestMessageArgs args = new DataServiceClientRequestMessageArgs(
requestEventArgs.Method,
requestEventArgs.RequestUri,
context.UseDefaultCredentials,
context.UsePostTunneling,
requestEventArgs.Headers);
httpRequest = new HttpWebRequestMessage(args);
}
Descriptor descriptor = requestEventArgs != null ? requestEventArgs.Descriptor : null;
// fire the right events if they exist
if (context.HasSendingRequest2EventHandlers)
{
SendingRequest2EventArgs eventArgs = new SendingRequest2EventArgs(
httpRequest,
descriptor,
false);
context.FireSendingRequest2(eventArgs);
}
Task <IODataResponseMessage> asyncResponse =
Task <IODataResponseMessage> .Factory.FromAsync(httpRequest.BeginGetResponse, httpRequest.EndGetResponse,
httpRequest);
IODataResponseMessage response = asyncResponse.GetAwaiter().GetResult();
ReceivingResponseEventArgs responseEvent = new ReceivingResponseEventArgs(response, descriptor);
context.FireReceivingResponseEvent(responseEvent);
using (StreamReader streamReader = new StreamReader(response.GetStream()))
using (XmlReader xmlReader = XmlReader.Create(streamReader))
{
return(CsdlReader.Parse(xmlReader));
}
}
protected virtual InMemoryMessage CreateRequestMessage(DataServiceClientRequestMessageArgs requestMessageArgs)
{
var requestMessage = new InMemoryMessage { Url = requestMessageArgs.RequestUri, Method = requestMessageArgs.Method, Stream = new MemoryStream() };
foreach (var header in requestMessageArgs.Headers)
{
requestMessage.SetHeader(header.Key, header.Value);
}
return requestMessage;
}
protected override InMemoryMessage CreateRequestMessage(DataServiceClientRequestMessageArgs requestMessageArgs)
{
this.lastMessageCreated = base.CreateRequestMessage(requestMessageArgs);
return this.lastMessageCreated;
}
public void HttpMergeIsNoLongerSupported()
{
Func<DataServiceClientRequestMessageArgs, DataServiceClientRequestMessage> addHeader =
(args) =>
{
if (args.Method == "PATCH")
{
// use Merge
var newArgs = new DataServiceClientRequestMessageArgs("MERGE", args.RequestUri, true, args.UsePostTunneling, args.Headers);
// use V4 since Merge is removed only in V4
newArgs.Headers["DataServiceVersion"] = "4.0";
return new HttpWebRequestMessage(newArgs);
}
return new HttpWebRequestMessage(args);
};
var ctx = this.CreateContext(addHeader);
Product product = null;
var query = ctx.Context.Product.Take(1) as DataServiceQuery<Product>;
var ar = query.BeginExecute(null, null).EnqueueWait(this);
product = query.EndExecute(ar).Single();
product.Description = "New Description " + Guid.NewGuid().ToString();
ctx.UpdateObject(product);
try
{
var ar2 = ctx.BeginSaveChanges(null, null).EnqueueWait(this);
ctx.EndSaveChanges(ar2);
Assert.Fail("Expected error not thrown");
}
catch (DataServiceRequestException e)
{
#if !PORTABLELIB && !SILVERLIGHT
StringResourceUtil.VerifyDataServicesClientString(e.Message, "DataServiceException_GeneralError");
#else
Assert.IsNotNull(e);
#endif
}
}
private TestHttpWebRequestMessage OnMessageCreating(DataServiceClientRequestMessageArgs args)
{
this.testMessage = new TestHttpWebRequestMessage(args, this.SendRequest, this.SendResponse, this.GetRequestWrappingStream, this.GetResponseWrappingStream);
return this.testMessage;
}
public ExtendedHttpWebRequestMessage(DataServiceClientRequestMessageArgs args) : base(args)
{
}
private static HttpWebRequest CreateRequest(string method, Uri requestUrl, DataServiceClientRequestMessageArgs args)
{
HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(requestUrl);
#if PORTABLELIB
// Set same default as Silverlight when running silverlight in .Net Portable
if (IsRunningOnSilverlight)
{
httpRequest.UseDefaultCredentials = args.UseDefaultCredentials;
}
#else
// KeepAlive not available
httpRequest.KeepAlive = true;
#endif
httpRequest.Method = method;
return httpRequest;
}
public CustomizedHttpWebRequestMessage(DataServiceClientRequestMessageArgs args, string response, Dictionary<string, string> headers)
: base(args)
{
this.Response = response;
this.CutomizedHeaders = headers;
}
public CustomizedHttpWebRequestMessage(DataServiceClientRequestMessageArgs args)
: base(args)
{
}
public void QueryWithFormat()
{
Dictionary<string, string> testCases = new Dictionary<string, string>()
{
{"People?$format=application/json", "application/json"},
// ODL Bug: https://github.com/OData/odata.net/issues/313
////{"People?$format=application/json;odata.metadata=full", "application/json; odata.metadata=full"},
{"People?$format=json", "application/json"},
};
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings() { BaseUri = ServiceBaseUri };
foreach (var testCase in testCases)
{
DataServiceClientRequestMessageArgs args = new DataServiceClientRequestMessageArgs(
"GET",
new Uri(ServiceBaseUri.AbsoluteUri + testCase.Key, UriKind.Absolute),
false, false, new Dictionary<string, string>() { });
var requestMessage = new HttpWebRequestMessage(args);
using (var responseMessage = requestMessage.GetResponse() as HttpWebResponseMessage)
{
Assert.Equal(200, responseMessage.StatusCode);
string contentType = responseMessage.Headers.FirstOrDefault(x => x.Key.Equals("Content-Type")).Value;
Assert.True(contentType.StartsWith(testCase.Value));
using (var messageReader = new ODataMessageReader(
responseMessage,
readerSettings,
this.TestClientContext.Format.LoadServiceModel()))
{
var reader = messageReader.CreateODataFeedReader();
while (reader.Read())
{
if (reader.State == ODataReaderState.EntryEnd)
{
ODataEntry entry = reader.Item as ODataEntry;
Assert.NotNull(entry.Properties.Single(p => p.Name == "PersonId").Value);
}
else if (reader.State == ODataReaderState.FeedEnd)
{
Assert.NotNull(reader.Item as ODataFeed);
}
}
Assert.Equal(ODataReaderState.Completed, reader.State);
}
}
}
}
internal TestHttpRequestMessage(DataServiceClientRequestMessageArgs args, Func<Stream, Stream> requestStreamInterceptor, Func<Stream, Stream> responseStreamInterceptor) : base(args)
{
this.requestStreamInterceptor = requestStreamInterceptor;
this.responseStreamInterceptor = responseStreamInterceptor;
}
/// <summary>
/// Returns an instance of the IODataRequestMessage
/// </summary>
/// <param name="requestMessageArgs">Arguments for creating the request message.</param>
/// <returns>an instance of the IODataRequestMessage </returns>
internal DataServiceClientRequestMessage CreateRequestMessage(BuildingRequestEventArgs requestMessageArgs)
{
var headersDictionary = requestMessageArgs.HeaderCollection.UnderlyingDictionary;
// We are implementing the PostTunneling logic here. The reason for doing this is
// 1> In this public class, the Method property returns the actual method (PUT, PATCH, DELETE),
// and not the verb that goes in the wire. So this class needs to know about
// actual verb since it will be using this verb to send over http.
if (this.UsePostTunneling)
{
bool setXHttpMethodHeader = false;
if (string.CompareOrdinal(XmlConstants.HttpMethodGet, requestMessageArgs.Method) != 0 &&
string.CompareOrdinal(XmlConstants.HttpMethodPost, requestMessageArgs.Method) != 0)
{
setXHttpMethodHeader = true;
}
// Setting the actual method in the header
if (setXHttpMethodHeader)
{
headersDictionary[XmlConstants.HttpXMethod] = requestMessageArgs.Method;
}
// Set the Content-length of a Delete to 0. Important for post tunneling when its a post, content-length must be zero in this case.
if (string.CompareOrdinal(XmlConstants.HttpMethodDelete, requestMessageArgs.Method) == 0)
{
headersDictionary[XmlConstants.HttpContentLength] = "0";
#if DEBUG
if (!this.UserModifiedRequestInBuildingRequest)
{
Debug.Assert(!requestMessageArgs.HeaderCollection.HasHeader(XmlConstants.HttpContentType), "Content-Type header must not be set for DELETE requests");
}
#endif
}
}
var clientRequestMessageArgs = new DataServiceClientRequestMessageArgs(requestMessageArgs.Method, requestMessageArgs.RequestUri, this.UseDefaultCredentials, this.UsePostTunneling, headersDictionary);
DataServiceClientRequestMessage clientRequestMessage;
if (this.Configurations.RequestPipeline.OnMessageCreating != null)
{
clientRequestMessage = this.Configurations.RequestPipeline.OnMessageCreating(clientRequestMessageArgs);
if (clientRequestMessage == null)
{
throw Error.InvalidOperation(Strings.Context_OnMessageCreatingReturningNull);
}
}
else
{
clientRequestMessage = new HttpWebRequestMessage(clientRequestMessageArgs);
}
return clientRequestMessage;
}
/// <summary>
/// Creates a new instance of HttpWebRequestMessage.
/// </summary>
/// <param name="args">Arguments for creating the request message.</param>
/// <param name="requestInfo">RequestInfo instance.</param>
internal HttpWebRequestMessage(DataServiceClientRequestMessageArgs args, RequestInfo requestInfo)
: this(args)
{
Debug.Assert(requestInfo != null, "requestInfo != null");
this.requestInfo = requestInfo;
}
public AnnotationRequestMessage(DataServiceClientRequestMessageArgs args)
: base(args)
{
}