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); }