public async Task<Stream> PostAsync(RestHost host, string url, string data, Action<HttpWebRequest> adjustRequest)
{
bool retry = true;
HttpWebRequest request = null;
ExceptionDispatchInfo capturedException = null;
while (retry)
{
retry = false;
try
{
byte[] bytes = null;
request = BuildStandardPostRequest(host, url, data, null, adjustRequest, out bytes);
using (var requestStream = await request.GetRequestStreamAsync())
{
await requestStream.WriteAsync(bytes, 0, bytes.Length);
requestStream.Close();
}
var response = (HttpWebResponse)request.GetResponse();
return response.GetResponseStream();
}
catch (WebException ex)
{
capturedException = ExceptionDispatchInfo.Capture(ex);
}
if (capturedException != null)
{
var webException = capturedException.SourceException as WebException;
if (webException != null)
{
var errorResponse = webException.Response as HttpWebResponse;
if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.Forbidden && host.RetryFailedRemoteRequest(request))
retry = true;
else if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.InternalServerError)
return errorResponse.GetResponseStream();
else
capturedException.Throw();
}
else
{
capturedException.Throw();
}
}
}
return null;
}
private HttpWebRequest BuildStandardPostRequest(RestHost host, string url, string data, Stream stream, Action<HttpWebRequest> adjustRequest, out byte[] bytes)
{
HttpWebRequest request = null;
request = CreateRequest(host, url, adjustRequest, host.PostTimeout);
request.Method = "POST";
bytes = null;
if (data == null)
request.ContentLength = 0;
else
{
bytes = Encoding.UTF8.GetBytes(data);
request.ContentType = isXmlRegex.IsMatch(data) ? "text/xml; charset=utf-8" : "application/x-www-form-urlencoded; charset=utf-8";
request.ContentLength = bytes.Length;
}
return request;
}
public Stream PostEndpointStream(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestPostOptions options = null)
{
if (options == null)
options = new RestPostOptions();
var processedEndpoint = ProcessPostEndpoint(endpoint, options);
string postData = options.PostParameters.MakeQuerystring(true);
return _proxy.Post(host, MakeEndpointUrl(host, version, processedEndpoint), postData,
(req) => AdjustPostRequest(host, req, enableImpersonation, options));
}
public Stream DeleteEndpointStream(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestDeleteOptions options = null)
{
if (options == null)
options = new RestDeleteOptions();
var processedEndpoint = ProcessDeleteEndpoint(endpoint, options);
return _proxy.Post(host, MakeEndpointUrl(host, version, processedEndpoint), null,
(req) => AdjustDeleteRequest(host, req, enableImpersonation, options));
}
private void AdjustFileRequest(RestHost host, HttpWebRequest request, RestFileOptions options)
{
if (options != null && options.AdditionalHeaders != null)
SetAdditionalHeaders(request, options.AdditionalHeaders);
}
private void AdjustBatchRequest(RestHost host, HttpWebRequest request, bool enableImpersonation, BatchRequestOptions options)
{
AdjustRequestBase(host, request, enableImpersonation);
if (options != null && options.AdditionalHeaders != null)
SetAdditionalHeaders(request, options.AdditionalHeaders);
}
public async Task<Stream> GetAsync(RestHost host, string url, Action<HttpWebRequest> adjustRequest)
{
bool retry = true;
HttpWebRequest request = null;
ExceptionDispatchInfo capturedException = null;
while (retry)
{
retry = false;
try
{
request = BuildGetRequest(host, url, adjustRequest);
var response = await request.GetResponseAsync();
return ((HttpWebResponse)response).GetResponseStream();
}
catch (WebException ex)
{
capturedException = ExceptionDispatchInfo.Capture(ex);
}
}
if (capturedException != null)
{
var webException = capturedException.SourceException as WebException;
if (webException != null)
{
var errorResponse = webException.Response as HttpWebResponse;
if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.Forbidden && host.RetryFailedRemoteRequest(request))
retry = true;
else if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.InternalServerError)
return errorResponse.GetResponseStream();
else
capturedException.Throw();
}
else
{
capturedException.Throw();
}
}
return null;
}
private HttpWebRequest CreateRequest(RestHost host, string url, Action<HttpWebRequest> adjustRequest, int timeout)
{
var request = (HttpWebRequest)WebRequest.Create(url);
adjustRequest(request);
request.Timeout = timeout;
var httpContext = host.GetCurrentHttpContext();
if (httpContext != null && httpContext.Request != null)
{
if (!string.IsNullOrEmpty(httpContext.Request.UserAgent))
request.UserAgent = httpContext.Request.UserAgent;
if (!string.IsNullOrEmpty(httpContext.Request.Headers["Cookie"]))
request.Headers["Cookie"] = httpContext.Request.Headers["Cookie"];
}
return request;
}
public async Task<Stream> PostEndpointStream(RestHost host, int version, string endpoint, Stream postStream, bool enableImpersonation, Action<WebResponse> responseAction, RestPostOptions options = null)
{
//TODO: Review this for refactor, is it necessary or can it be collpased
return
await
_proxy.PostEndpointStream(host, MakeEndpointUrl(host, version, endpoint), postStream,
(request) => AdjustPostRequest(host, request, enableImpersonation, options), responseAction);
}
public Stream Post(RestHost host, string url, string data, Action<HttpWebRequest> adjustRequest)
{
bool retry = true;
HttpWebRequest request = null;
while (retry)
{
retry = false;
try
{
byte[] bytes = null;
request = BuildStandardPostRequest(host, url, data, null, adjustRequest, out bytes);
using (var requestStream = request.GetRequestStream())
{
requestStream.Write(bytes, 0, bytes.Length);
requestStream.Close();
}
var response = (HttpWebResponse)request.GetResponse();
return response.GetResponseStream();
}
catch (WebException ex)
{
var errorResponse = ex.Response as HttpWebResponse;
if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.Forbidden && host.RetryFailedRemoteRequest(request))
retry = true;
else if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.InternalServerError)
return errorResponse.GetResponseStream();
else
throw ex;
}
}
return null;
}
public async Task<XElement> GetEndpointXmlAsync(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestGetOptions options = null)
{
if (options == null)
options = new RestGetOptions();
var processedEndpoint = ProcessGetEndpoint(endpoint, options);
return XElement.Parse(await ReadResponseStreamAsync(await _proxy.GetAsync(host, MakeEndpointUrl(host, version, processedEndpoint), (request) => AdjustGetRequest(host, request, enableImpersonation, options))));
}
public async Task<XElement> PostEndpointXmlAsync(RestHost host, int version, string endpoint, HttpPostedFileBase file = null, bool enableImpersonation = true, RestPostOptions options = null)
{
if (options == null)
options = new RestPostOptions();
var processedEndpoint = ProcessPostEndpoint(endpoint, options);
string postData = options.PostParameters.MakeQuerystring(true);
return XElement.Parse(await ReadResponseStreamAsync(await _proxy.PostAsync(host, MakeEndpointUrl(host, version, processedEndpoint), postData, (request) => AdjustPostRequest(host, request, true, options))));
}
public XElement DeleteEndpointXml(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestDeleteOptions options = null)
{
if (options == null)
options = new RestDeleteOptions();
var processedEndpoint = ProcessDeleteEndpoint(endpoint, options);
return XElement.Parse(ReadResponseStream(_proxy.Post(host, MakeEndpointUrl(host, version, processedEndpoint), null, (request) => AdjustDeleteRequest(host, request, enableImpersonation, options))));
}
public XElement PutEndpointXml(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestPutOptions options = null)
{
if (options == null)
options = new RestPutOptions();
var processedEndpoint = ProcessPutEndpoint(endpoint, options);
string postData = options.PostParameters.MakeQuerystring(true);
return XElement.Parse(ReadResponseStream(_proxy.Post(host, MakeEndpointUrl(host, version, processedEndpoint), postData, (request) => AdjustPutRequest(host, request, enableImpersonation, options))));
}
private void AdjustRequestBase(RestHost host, HttpWebRequest request, bool enableImpersonation)
{
host.ApplyAuthenticationToHostRequest(request, enableImpersonation);
host.ApplyRemoteHeadersToRequest(request);
}
public Stream BatchEndpointStream(RestHost host, int version, IList<BatchRequest> requests, bool enableImpersonation = true, BatchRequestOptions options = null)
{
var postData = CreatePostBatchData(requests, options);
return _proxy.Post(host, MakeEndpointUrl(host, version, "batch.json"), postData, (request) => AdjustBatchRequest(host, request, enableImpersonation, options));
}
public string GetEndpointString(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestGetOptions options = null)
{
if (options == null)
options = new RestGetOptions();
var processedEndpoint = ProcessGetEndpoint(endpoint, options);
Stream stream = _proxy.Get(host, MakeEndpointUrl(host, version, processedEndpoint), (request) => AdjustGetRequest(host, request, enableImpersonation, options));
return ReadResponseStream(stream);
}
public Task<UploadedFileInfo> TransmitFileAsync(RestHost host, UploadedFile file, RestFileOptions options = null)
{
if (options == null)
options = new RestFileOptions();
string url = GetUploadUrl(host.EvolutionRootUrl, file.UploadContext);
return _proxy.TransmitFileAsync(host, url, file, options.UploadProgress,
(request) => AdjustFileRequest(host, request, options));
}
public async Task<string> PostEndpointStringAsync(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestPostOptions options = null)
{
if (options == null)
options = new RestPostOptions();
var processedEndpoint = ProcessPostEndpoint(endpoint, options);
string postData = options.PostParameters.MakeQuerystring(true);
var stream = await _proxy.PostAsync(host, MakeEndpointUrl(host, version, processedEndpoint), postData, (request) => AdjustPostRequest(host, request, true, options));
return await ReadResponseStreamAsync(stream);
}
public async Task<Stream> PostEndpointStream(RestHost host, string url, Stream postStream, Action<HttpWebRequest> adjustRequest, Action<WebResponse> responseAction)
{
bool retry = true;
HttpWebRequest request = null;
ExceptionDispatchInfo capturedException = null;
while (retry)
{
retry = false;
try
{
request = CreateRequest(host, url, adjustRequest, host.PostTimeout);
request.Method = "POST";
request.ContentType = "application/octet-stream";
if (postStream == null)
{
request.ContentLength = 0;
}
else
{
request.ContentLength = postStream.Length;
using (var requestStream = await request.GetRequestStreamAsync())
{
byte[] buffer = new byte[64 * 1024];
int read;
while ((read = await postStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
{
await requestStream.WriteAsync(buffer, 0, read);
}
requestStream.Close();
}
}
var response = await request.GetResponseAsync();
if (responseAction != null)
responseAction(response);
return response.GetResponseStream();
}
catch (WebException ex)
{
capturedException = ExceptionDispatchInfo.Capture(ex);
}
if (capturedException != null)
{
var webException = capturedException.SourceException as WebException;
if (webException != null)
{
var errorResponse = webException.Response as HttpWebResponse;
if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.Forbidden &&
host.RetryFailedRemoteRequest(request))
retry = true;
else
capturedException.Throw();
}
else
{
capturedException.Throw();
}
}
}
return null;
}
public UploadedFileInfo TransmitFile(RestHost host, string url, UploadedFile file,Action<FileUploadProgress> progressAction,
Action<HttpWebRequest> adjustRequest)
{
int totalChunks = (int)Math.Ceiling((double)file.FileData.Length / MAX_CHUNK_SIZE_BYTES);
int currentChunk = 1;
UploadedFileInfo fileResponse = new UploadedFileInfo(file.UploadContext);
using (var rdr = new BinaryReader(file.FileData))
for(var i =currentChunk;i<= totalChunks;i++)
{
FileUploadProgress progress = new FileUploadProgress() {UploadContext = file.UploadContext };
string boundary = Guid.NewGuid().ToString("N");
var chunk = rdr.ReadBytes(MAX_CHUNK_SIZE_BYTES);
var bytesToSend = PrepareDataChunk(chunk, currentChunk, boundary, totalChunks, file);
var request = CreateRequest(host, url, adjustRequest, host.PostTimeout);
request.Method = "POST";
try
{
request.ContentType = "multipart/form-data; boundary=" + boundary;
request.ContentLength = bytesToSend.Length;
using (var requestStream = request.GetRequestStream())
{
requestStream.Write(bytesToSend, 0, bytesToSend.Length);
requestStream.Close();
}
using (var response = (HttpWebResponse)request.GetResponse())
{
var stream = response.GetResponseStream();
if (stream != null)
{
using (var reader = new StreamReader(stream))
{
var responseData = reader.ReadToEnd();
if (!string.IsNullOrEmpty(responseData))
{
var uploadResponse = JsonConvert.Deserialize(responseData);
fileResponse.DownloadUrl = uploadResponse.result.downloadUrl;
}
}
}
}
if (progressAction != null)
progressAction(progress);
currentChunk ++;
}
catch (Exception ex)
{
fileResponse.IsError = true;
fileResponse.Message =ex.Message;
var webException = ex as WebException;
if (webException != null)
{
var errorResponse = webException.Response as HttpWebResponse;
if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.InternalServerError)
{
var resp = ReadUploadError(errorResponse.GetResponseStream());
if (resp != null && resp.error != null)
{
fileResponse.Message = resp.error.message;
}
}
}
}
}
return fileResponse;
}
public Stream Get(RestHost host, string url, Action<HttpWebRequest> adjustRequest)
{
bool retry = true;
HttpWebRequest request = null;
ExceptionDispatchInfo capturedException = null;
while (retry)
{
retry = false;
try
{
request = BuildGetRequest(host, url, adjustRequest);
var response = (HttpWebResponse)request.GetResponse();
Stream stream = null;
var str = response.GetResponseStream();
return str;
}
catch (WebException ex)
{
var errorResponse = ex.Response as HttpWebResponse;
if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.Forbidden && host.RetryFailedRemoteRequest(request))
retry = true;
else if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.InternalServerError)
return errorResponse.GetResponseStream();
else
throw ex;
}
}
return null;
}
private HttpWebRequest BuildGetRequest(RestHost host, string url, Action<HttpWebRequest> adjustRequest)
{
HttpWebRequest request = CreateRequest(host, url, adjustRequest, host.GetTimeout);
request.Method = "GET";
return request;
}
public async Task<string> DeleteEndpointStringAsync(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestDeleteOptions options = null)
{
if (options == null)
options = new RestDeleteOptions();
var processedEndpoint = ProcessDeleteEndpoint(endpoint, options);
var stream = await _proxy.PostAsync(host, MakeEndpointUrl(host, version, processedEndpoint), null, (request) => AdjustDeleteRequest(host, request, enableImpersonation, options));
return await ReadResponseStreamAsync(stream);
}
private void AdjustDeleteRequest(RestHost host, HttpWebRequest request, bool enableImpersonation, RestDeleteOptions options)
{
AdjustRequestBase(host, request, enableImpersonation);
if (options != null && options.AdditionalHeaders != null)
SetAdditionalHeaders(request, options.AdditionalHeaders);
request.Headers["Rest-Method"] = "DELETE";
}
public async Task<UploadedFileInfo> TransmitFileAsync(RestHost host, string url, UploadedFile file, Action<FileUploadProgress> progressAction,
Action<HttpWebRequest> adjustRequest)
{
ExceptionDispatchInfo capturedException = null;
int totalChunks = (int)Math.Ceiling((double)file.FileData.Length / MAX_CHUNK_SIZE_BYTES);
int currentChunk = 1;
UploadedFileInfo fileResponse = new UploadedFileInfo(file.UploadContext);
using (var rdr = new BinaryReader(file.FileData))
for (var i = currentChunk; i <= totalChunks; i++)
{
FileUploadProgress progress = new FileUploadProgress() { UploadContext = file.UploadContext };
string boundary = Guid.NewGuid().ToString("N");
var chunk = rdr.ReadBytes(MAX_CHUNK_SIZE_BYTES);
var bytesToSend = PrepareDataChunk(chunk, currentChunk, boundary, totalChunks, file);
var request = CreateRequest(host, url, adjustRequest, host.PostTimeout);
request.Method = "POST";
try
{
request.ContentType = "multipart/form-data; boundary=" + boundary;
request.ContentLength = bytesToSend.Length;
using (var requestStream =await request.GetRequestStreamAsync())
{
await requestStream.WriteAsync(bytesToSend, 0, bytesToSend.Length);
requestStream.Close();
}
using (HttpWebResponse response = (HttpWebResponse)await request.GetResponseAsync())
{
var str = response.GetResponseStream();
}
if (progressAction != null)
progressAction(progress);
currentChunk++;
}
catch (Exception ex)
{
capturedException = ExceptionDispatchInfo.Capture(ex);
}
if (capturedException != null )
{
fileResponse.IsError = true;
fileResponse.Message = capturedException.SourceException.Message;
var webException = capturedException.SourceException as WebException;
if (webException != null )
{
var errorResponse = webException.Response as HttpWebResponse;
if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.InternalServerError)
{
var resp = await ReadUploadErrorAsync(errorResponse.GetResponseStream());
if (resp != null && resp.error != null)
{
fileResponse.Message = resp.error.message;
}
}
}
}
}
return fileResponse;
}
public async Task<XElement> BatchEndpointXmlAsync(RestHost host, int version, IList<BatchRequest> requests, bool enableImpersonation = true, BatchRequestOptions options = null)
{
var postData = CreatePostBatchData(requests, options);
return XElement.Parse(await ReadResponseStreamAsync(await _proxy.PostAsync(host, MakeEndpointUrl(host, version, "batch.json"), postData, (request) => AdjustBatchRequest(host, request, enableImpersonation, options))));
}
public Task<Stream> GetEndpointStreamAsync(RestHost host, int version, string endpoint, bool enableImpersonation = true, RestGetOptions options = null)
{
if (options == null)
options = new RestGetOptions();
var processedEndpoint = ProcessGetEndpoint(endpoint, options);
return _proxy.GetAsync(host, MakeEndpointUrl(host, version, processedEndpoint),
(req) => AdjustGetRequest(host, req, enableImpersonation, options));
}
public string MakeEndpointUrl(RestHost host, int version, string endpoint)
{
string restUrl = host.EvolutionRootUrl;
if (!restUrl.EndsWith("/"))
restUrl += "/";
return string.Concat(restUrl, "api.ashx/v", version, "/", endpoint);
}
