private ServiceResponse SendRequestAsyncTPL(WebRequest request) { return _retryPolicy.ExecuteAction<ServiceResponse>(() => { var task = Task.Factory.FromAsync( request.BeginGetResponse, asyncResult => request.EndGetResponse(asyncResult), null) .ContinueWith((t) => { var response = (HttpWebResponse)t.Result; var reader = new StreamReader(response.GetResponseStream()); var message = reader.ReadToEnd(); return new ServiceResponse() { IsSuccess = true, Message = message }; }); try { return task.Result; } catch (AggregateException ae) { throw MappedAggregateException(ae); } }); }
public override WebResponse EndGetResponse(IAsyncResult asyncResult) { var response = _internalWebRequest.EndGetResponse(asyncResult); if (response.Headers[HttpRequestHeader.ContentEncoding] == "gzip" && response is HttpWebResponse) { return(new GZipWebResponse(response as HttpWebResponse)); } else { return(response); } }
XElement ToXml(WebRequest request, IAsyncResult result) { if (result.IsCompleted) { using (var response = request.EndGetResponse(result)) using (var input = response.GetResponseStream()) { return ToXml(input); } } return null; }
private string ReadResult(WebRequest webRequest, IAsyncResult asyncResult) { try { using (var response = webRequest.EndGetResponse(asyncResult)) { var result = response.GetResponseString(); return result; } } catch { return "Error"; } }
private void GeneralProcessResponse(WebRequest request, IAsyncResult result, Action<Stream> responseStreamHandler) { IsLoading = false; try { var response = request.EndGetResponse(result); using (var stream = response.GetResponseStream()) { responseStreamHandler(stream); } } catch (Exception exception) { ReportError("Sorry - problem seen " + exception.Message); } }
private static void RequestAsync(WebRequest request, byte[] bodyBytes, Action<TrackResult> callback) { request.BeginGetRequestStream((r1) => { try { var stream = request.EndGetRequestStream(r1); stream.BeginWrite(bodyBytes, 0, bodyBytes.Length, (r2) => { try { stream.EndWrite(r2); stream.Dispose(); request.BeginGetResponse((r3) => { try { using (var response = request.EndGetResponse(r3)) { using (var reader = new StreamReader(response.GetResponseStream())) { if (callback != null) callback(new TrackResult(reader.ReadToEnd())); } } } catch (Exception ex) { HandleError(callback, ex); } }, null); } catch (Exception ex) { HandleError(callback, ex); } }, null); } catch(Exception ex) { HandleError(callback, ex); } }, null); }
private static WebResponse GetResponseInternal(WebRequest request) { // build the envent using (var revent = new ManualResetEvent(false)) { // start the async call IAsyncResult result = request.BeginGetResponse(new AsyncCallback(CallStreamCallback), revent); // wait for event revent.WaitOne(); // get the response WebResponse response = request.EndGetResponse(result); // go ahead return response; } }
/// <summary> /// This sets the event handler with request and response data and /// translates storage exceptions. /// </summary> /// <param name="req">The request.</param> /// <param name="asyncResult">The async result.</param> /// <param name="handler">The handler.</param> /// <param name="sender">The sender.</param> /// <returns>The processed response.</returns> internal static WebResponse ProcessWebResponse(WebRequest req, IAsyncResult asyncResult, EventHandler<ResponseReceivedEventArgs> handler, object sender) { WebResponse response = null; Exception exception = null; try { response = req.EndGetResponse(asyncResult); return response as HttpWebResponse; } catch (WebException e) { response = e.Response; exception = Utilities.TranslateWebException(e); throw exception; } finally { EventHelper.OnResponseReceived(req, response, handler, sender, exception); } }
private void ProcessResponse(WebRequest request, IAsyncResult result) { try { var fileService = MvxFileStoreHelper.SafeGetFileStore(); var tempFilePath = DownloadPath + ".tmp"; using (var resp = request.EndGetResponse(result)) { using (var s = resp.GetResponseStream()) { fileService.WriteFile(tempFilePath, fileStream => { var buffer = new byte[4 * 1024]; int count; while ((count = s.Read(buffer, 0, buffer.Length)) > 0) { fileStream.Write(buffer, 0, count); } }); } } fileService.TryMove(tempFilePath, DownloadPath, true); } //#if !NETFX_CORE // catch (ThreadAbortException) // { // throw; // } //#endif catch (Exception exception) { FireDownloadFailed(exception); return; } FireDownloadComplete(); }
private AsyncCallback HandleResponse( WebRequest request, Uri uri, IWebAction action, byte[] content, IAuthenticator authenticator) { return ar => { try { using (var response = (HttpWebResponse) request.EndGetResponse(ar)) { using (var stream = response.GetResponseStream()) action.Complete(response.StatusCode, stream); } } catch (WebException ex) { if (authenticator != _auth) { // Another thread has already updated the authenticator Request(action, uri, content); return; } // Do we have any alternative? var next = _auth.Next(ex); _auth = next; if (next != null) Request(action, uri, content); else action.Error(ex); } }; }
private void HandleResponse(WebRequest request) { WebResponse response = null; Stream responseStream = null; StreamReader responseStreamReader = null; request.BeginGetResponse((responseResult) => { try { response = request.EndGetResponse(responseResult); responseStream = response.GetResponseStream(); responseStreamReader = new StreamReader(responseStream); ResponseText = responseStreamReader.ReadToEnd(); } finally { try { if (response != null) response.Dispose(); } catch { } try { if (responseStream != null) responseStream.Dispose(); } catch { } try { if (responseStreamReader != null) ((IDisposable)responseStreamReader).Dispose(); } catch { } DisableProgressIndicator(); } }, null); }
private void _IrosHPost(IntPtr handle, ref IrosHPostData data) { string url = Marshal.PtrToStringAnsi(data.url); string ctype = Marshal.PtrToStringAnsi(data.contentType); System.Net.WebRequest req = System.Net.WebRequest.Create(url); req.ContentType = ctype; //req.Method = data.len > 0 ? "POST" : "GET"; req.Method = "POST"; TraceLogger(String.Format("{3}ing {2} bytes to {0} handle {1}", url, handle, data.len, req.Method)); byte[] buffer = new byte[data.len]; Marshal.Copy(data.data, buffer, 0, buffer.Length); WebTask t = new WebTask() { Req = req, Handle = handle, writeBack = data.writeBack }; _http[handle] = t; AsyncCallback doResponse = ar2 => { try { var resp = req.EndGetResponse(ar2); var rs = req.GetResponse().GetResponseStream(); t.Async = rs.BeginRead(t.ReceiveBuffer, 0, t.ReceiveBuffer.Length, AsyncReceive, t); } catch (WebException e) { ErrorLogger(String.Format("Error receiving from {0}: {1}", handle, e.ToString())); t.ReceiveDone = true; if (e.Response != null) { t.Status = (int)((HttpWebResponse)e.Response).StatusCode; } else { t.Status = 500; } } catch (Exception e) { ErrorLogger(String.Format("Error receiving from {0}: {1}", handle, e.ToString())); t.ReceiveDone = true; t.Status = 500; } }; t.ReceiveBuffer = new byte[0x10000]; if (buffer.Length > 0) { t.Async = req.BeginGetRequestStream(ar => { var s = req.EndGetRequestStream(ar); using (s) { s.Write(buffer, 0, buffer.Length); } t.Completed = t.Size = buffer.Length; TraceLogger(String.Format("Beginning GetResponse for {0}", handle)); t.Async = req.BeginGetResponse(doResponse, t); }, t); } else { TraceLogger(String.Format("Beginning GetResponse [no request data] for {0}", handle)); t.Async = req.BeginGetResponse(doResponse, t); } }
BEncodedDictionary DecodeResponse(WebRequest request, IAsyncResult result) { int bytesRead = 0; int totalRead = 0; byte[] buffer = new byte[2048]; WebResponse response = request.EndGetResponse(result); using (MemoryStream dataStream = new MemoryStream(response.ContentLength > 0 ? (int)response.ContentLength : 256)) { using (BinaryReader reader = new BinaryReader(response.GetResponseStream())) { // If there is a ContentLength, use that to decide how much we read. if (response.ContentLength > 0) { while (totalRead < response.ContentLength) { bytesRead = reader.Read(buffer, 0, buffer.Length); dataStream.Write(buffer, 0, bytesRead); totalRead += bytesRead; } } else // A compact response doesn't always have a content length, so we { // just have to keep reading until we think we have everything. while ((bytesRead = reader.Read(buffer, 0, buffer.Length)) > 0) dataStream.Write(buffer, 0, bytesRead); } } response.Close(); dataStream.Seek(0, SeekOrigin.Begin); return (BEncodedDictionary)BEncodedValue.Decode(dataStream); } }
private static void RaiseWebResponse(WebRequest request, IAsyncResult result, Action<WebResponseEventArgs> callback) { var args = new WebResponseEventArgs {Uri = request.RequestUri}; try { var response = request.EndGetResponse(result); SetLastResponse(response); using ( var reader = new StreamReader(response.GetResponseStream())) { args.Response = reader.ReadToEnd(); } } catch (WebException ex) { args.Response = HandleWebException(ex); } callback.Invoke(args); }
private void RetornarLivrosCarregarCallback(IAsyncResult resultado) { string[] titulos = new string[6]; webRequest = resultado.AsyncState as WebRequest; if (webRequest != null) { WebResponse response = webRequest.EndGetResponse(resultado); Stream streamResponse = response.GetResponseStream(); StreamReader streamReader = new StreamReader(streamResponse); string responseString = streamReader.ReadToEnd(); if (!responseString.Contains("<!-- filename: bor-loan-no-loan-->")) { var ignored1 = activeDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { App.ViewModel.Items.Clear(); }); HtmlDocument doc = new HtmlDocument(); doc.LoadHtml(responseString); HtmlNode table = doc.DocumentNode.Descendants().Where(n => n.Name == "table").ToList()[4]; int idCount = 0; int count = 0; foreach (HtmlNode tr in table.ChildNodes.Where(n => n.Name == "tr")) { if (count == 0) { count++; continue; } else { var ignored2 = activeDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { App.ViewModel.Items.Add(new ItemViewModel() { Id = idCount++.ToString(), Titulo = tr.ChildNodes.Where(n => n.Name == "td").ToList()[3].InnerText, StringDevolucao = tr.ChildNodes.Where(n => n.Name == "td").ToList()[5].InnerText.Substring(0,8) }); }); } } var ignored3 = activeDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { callbackLivros(resultado); }); } else { callbackLivros(resultado); } } else { erro = true; callbackLogin(null); } }
// Note: Adapted from OAuthWebQuery.SetAuthorizationHeader() public WebResponse GetWebResponseShim(WebRequest request, IAsyncResult result) { try { Response = request.EndGetResponse(result); return Response; } catch (WebException ex) { Exception = ex; return HandleWebException(ex); } }
private HttpWebResponse SmartGetWebResponse(WebRequest req) { try { if (req == null) return null; IAsyncResult arGet = req.BeginGetResponse(null, null); if (!arGet.AsyncWaitHandle.WaitOne(DEFAULT_READ_TIMEOUT)) { return null; } return req.EndGetResponse(arGet) as HttpWebResponse; } catch (Exception ex) { bool bShouldLog = true; WebException exw = ex as WebException; if (exw != null) { if (exw.Status == WebExceptionStatus.RequestCanceled) { bShouldLog = false; } else if (exw.Status == WebExceptionStatus.ProtocolError) { try { System.Net.HttpWebResponse httpRes = exw.Response as System.Net.HttpWebResponse; if (httpRes != null && httpRes.StatusCode == HttpStatusCode.NotFound) { SetFeedActive(false, false); FirePropertyChangedAction(false); LongSmartSleep(FEED_NOT_ACTIVE_SLEEP_SECS, "SmartGetWebResponse - Inactive Stream (404)"); // sleeping for 15 minutes on this stream! } } catch { } } } if (bShouldLog) { Common.DebugHelper.WriteExceptionToLog("WaveStreamProcessor.SmartGetWebResponse", ex, false, _streamURL); } return null; } }
protected virtual WebResponse GetWebResponse(WebRequest request, IAsyncResult result) { return(request.EndGetResponse(result)); }
private static Task<HttpWebResponse> GetResponseWithRetryAsync(WebRequest request, int retries) { if (retries < 0) throw new ArgumentOutOfRangeException("Invalid number of retries to make"); Func<Task<WebResponse>, Task<HttpWebResponse>> proceedToNextStep = null; Func<Task<HttpWebResponse>> doStep = () => { var ds = Task.Factory.FromAsync( (asyncCallback, state) => request.BeginGetResponse(asyncCallback, state), (asyncResult) => request.EndGetResponse(asyncResult), null ); return ds.ContinueWith(proceedToNextStep).Unwrap(); }; proceedToNextStep = (prevTask) => { if (prevTask.IsCanceled) throw new TaskCanceledException(); if (prevTask.IsFaulted && --retries > 0) return doStep(); var tcs = new TaskCompletionSource<HttpWebResponse>(); tcs.SetResult((HttpWebResponse)prevTask.Result); return tcs.Task; }; return doStep(); }
protected virtual WebResponse GetWebResponse (WebRequest request, IAsyncResult result) { if (abort) throw new WebException ("The operation has been aborted.", WebExceptionStatus.RequestCanceled); return request.EndGetResponse (result); }
public void LogarUsuarioCallback(IAsyncResult resultado) { try { webRequest = resultado.AsyncState as WebRequest; if (webRequest != null) { WebResponse response = (WebResponse)webRequest.EndGetResponse(resultado); Stream streamResponse = response.GetResponseStream(); StreamReader streamReader = new StreamReader(streamResponse); string responseString = streamReader.ReadToEnd(); HtmlDocument doc = new HtmlDocument(); doc.LoadHtml(responseString); HtmlNode link = doc.DocumentNode.Descendants().Where(n => n.Name == "form").FirstOrDefault(); string tokenLogin = ""; if (link != null) { tokenLogin = link.Attributes["action"].Value; tokenLogin = tokenLogin.Remove(0, tokenLogin.IndexOf("/F/") + 3); Token = tokenLogin; webRequest = WebRequest.Create(SiteAthenaLogin); webRequest.Headers["Connection"] = "Keep-Alive"; webRequest.BeginGetResponse(LoginExecutadoCallback, webRequest); } } else { erro = true; callbackLogin(null); } } catch (Exception e) { erro = true; callbackLogin(null); } }
private static void ProcessResponse(IAsyncResult asyncResult, WebRequest request, HttpResponse resp, Action<HttpResponse> action) { lock (pendingRequests) { if (pendingRequests.Contains(resp)) { pendingRequests.Remove(resp); } } try { var response = request.EndGetResponse(asyncResult); resp.IsConnected = true; var origResponse = response; using (response) { if (resp.Request.ResponseAsStream) { resp.ResponseStream = response.GetResponseStream(); } else { resp.RawResponse = response.GetResponseStream().ReadToEnd(); } if (origResponse.Headers.AllKeys.Contains("Set-Cookie")) { var cookies = origResponse.Headers["Set-Cookie"]; var index = cookies.IndexOf(';'); if (index != -1) { foreach (var c in ParseQueryString(cookies.Substring(0, index))) { resp.Cookies.Add(new Cookie(c.Key, c.Value)); } } } foreach (var key in origResponse.Headers.AllKeys) { var value = origResponse.Headers[key]; resp.Headers.Add(key, value); } } } catch (System.Exception ex) { var we = ex as WebException; if (we != null) { var temp = we.Response as HttpWebResponse; if (temp != null) { resp.HttpStatusCode = temp.StatusCode; } } if (resp.ResponseStream != null) { resp.ResponseStream.Dispose(); resp.ResponseStream = null; } resp.Exception = ex; if (action != null) { action(resp); } return; } if (action != null) { action(resp); } }
public void RenovarLivrosCarregarCallback(IAsyncResult resultado) { webRequest = resultado.AsyncState as WebRequest; if(webRequest != null) { WebResponse response = webRequest.EndGetResponse(resultado); Stream streamResponse = response.GetResponseStream(); StreamReader streamReader = new StreamReader(streamResponse); string responseString = streamReader.ReadToEnd(); if (responseString.Contains("<!--filename: bor-renew-all-body-->")) { var ignored1 = activeDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { App.ViewModel.Items.Clear(); }); HtmlDocument doc = new HtmlDocument(); doc.LoadHtml(responseString); List<HtmlNode> node = doc.DocumentNode.Descendants().Where(n => n.Name == "table").ToList(); HtmlNode table = doc.DocumentNode.Descendants().Where(n => n.Name == "table").ToList()[3]; int idcount = 0, count =0; foreach(HtmlNode tr in table.ChildNodes.Where(n => n.Name == "tr")) { if (count == 0) { count++; continue; } else { var ignored2 = activeDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { string motivoParaNaoRenovacao = tr.ChildNodes.Where(n => n.Name == "td").ToList()[8].InnerText; bool reservado = motivoParaNaoRenovacao.Equals("Item possui reservas."); App.ViewModel.Items.Add(new ItemViewModel() { Id = idcount++.ToString(), Reservado = reservado, Titulo = tr.ChildNodes.Where(n => n.Name == "td").ToList()[1].InnerText, StringDevolucao = tr.ChildNodes.Where(n => n.Name == "td").ToList()[3].InnerText.Substring(0,8) }); }); } } var ignored3 = activeDispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { erro = false; callbackRenovar(resultado); }); } else { erro = true; callbackRenovar(null); } } else { erro = true; callbackLogin(null); } }
int EndGetMailCount(WebRequest request) { if (currentRequestResult == null) return -1; var requestResult = currentRequestResult; currentRequestResult = null; var response = request.EndGetResponse(requestResult); using (var unreadStream = response.GetResponseStream()) { var unreadMailXmlDoc = new XmlDocument(); unreadMailXmlDoc.Load(unreadStream); var unreadMailEntries = unreadMailXmlDoc.GetElementsByTagName("entry"); return unreadMailEntries.Count; } }
private static WebResponse Nested1(IAsyncResult result, WebRequest request) { return request.EndGetResponse(result); }
private void OnGetResponseCompleted(IAsyncResult ar, WebRequest request) { Debug.Assert(ar != null); Debug.Assert(request != null); try { Debug.Assert(request != null); request.EndGetResponse(ar).Close(); // Not interested; assume OK _requests.Remove(request); } catch (Exception e) { OnWebPostError(request, e); } }
/// <include file='doc\ClientProtocol.uex' path='docs/doc[@for="WebClientProtocol.GetWebResponse1"]/*' /> /// <devdoc> /// <para> /// Gets the <see cref='System.Net.WebResponse'/> from the given request by calling /// EndGetResponse(). Derived classes can override this method to do additional /// processing on the response instance. This method is only called during /// async request processing. /// </para> /// </devdoc> protected virtual WebResponse GetWebResponse(WebRequest request, IAsyncResult result) { WebResponse response = request.EndGetResponse(result); #if !MONO if (response != null && debugger != null) debugger.NotifyClientCallReturn(response); #endif return response; }
private static void PostRequest(WebRequest request, IAsyncResult ar, byte[] data) { using (var output = request.EndGetRequestStream(ar)) { output.Write(data, 0, data.Length); } request.BeginGetResponse(ErrorReportingAsyncCallback(rar => request.EndGetResponse(rar).Close()), null); }
void LoginExecutadoCallback(IAsyncResult resultado) { try { webRequest = resultado.AsyncState as WebRequest; if (webRequest != null) { WebResponse response = webRequest.EndGetResponse(resultado); Stream responseStream = response.GetResponseStream(); StreamReader responseStreamReader = new StreamReader(responseStream); string responseString = responseStreamReader.ReadToEnd(); if (responseString.Contains("<!-- filename: login-session-uep01 -->")) { erro = true; dadosIncorretos = true; callbackLogin(null); } else { erro = false; dadosIncorretos = false; callbackLogin(resultado); } } else { erro = true; callbackLogin(null); } } catch (Exception e) { erro = true; callbackLogin(null); } }
protected virtual WebResponse GetWebResponse (WebRequest request, IAsyncResult result) { WebResponse response = request.EndGetResponse (result); responseHeaders = response.Headers; return response; }
internal static WebResponse EndGetResponse(WebRequest request, IAsyncResult ar) { WebResponse response = request.EndGetResponse(ar); if (response is HttpWebResponse && !(request is HttpWebRequest)) throw new ArgumentException(); // It is not clear whether WebRequest.GetRespone() can ever return null, but some of the v1 code had // this check, so it is added here just in case. if (response == null) { Uri requestUri = BaseUriHelper.PackAppBaseUri.MakeRelativeUri(request.RequestUri); throw new IOException(SR.Get(SRID.GetResponseFailed, requestUri.ToString())); } HandleWebResponse(response); return response; }
/// <summary> /// /// </summary> /// <param name="request"></param> /// <param name="result"></param> /// <returns></returns> protected virtual WebResponse GetWebResponse(WebRequest request, IAsyncResult result) { return request.EndGetResponse(result); }
/// <summary> /// Callback used to process server response for download WebRequest. /// </summary> /// <param name="result">Server response state.</param> protected void DownloadCallback(IAsyncResult result) { if (_aborted) { System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => { _downloadStatus.ProgressBar.IsEnabled = false; }); _aborted = false; return; } try { _request = (WebRequest)result.AsyncState; var response = (WebResponse)_request.EndGetResponse(result); using (var stream = response.GetResponseStream()) using (var reader = new StreamReader(stream)) { var contents = reader.ReadToEnd(); contents = contents.Replace("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>", ""); contents = string.Format("<surveys>{0}</surveys>", contents); XDocument documentXML = XDocument.Parse(contents); XElement root = documentXML.Element("surveys"); var surveys = from survey in root.Descendants("survey") select survey; List<XDocument> surveyXDocuments = new List<XDocument>(); if (_downloadStatus.IsCanceled) { return; } foreach (XElement survey in surveys) { if (_operationsOnList.IsSurveySaved(survey.Attribute("id").Value)) { continue; } XDocument doc = new XDocument(); doc.Add(survey); surveyXDocuments.Add(doc); } if (_surveysToDownload.Count == surveyXDocuments.Count) { bool canISave = true; foreach (XDocument doc in surveyXDocuments) { XElement surveyRoot = doc.Element("survey"); var isInListToDownload = from survey in _surveysToDownload where survey.SurveyId == surveyRoot.Attribute("id").Value select survey; if (isInListToDownload.Count<SurveyBasicInfo>() != 1) { canISave = false; break; } } if (canISave) { if (_downloadStatus.IsCanceled) { return; } _downloadStatus.CanCancel = false; try { foreach (XDocument surveyDocument in surveyXDocuments) { SaveSurvey(surveyDocument); } System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => { _operationsOnList.Add(_surveysToDownload); }); SendAcknowledge(); } catch (IsolatedStorageException) { System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => { _downloadStatus.ProgressBar.IsEnabled = false; _downloadStatus.Message.Show(Languages.AppResources.downloadNewSurveys_SavingProblem); _downloadStatus.CanCancel = true; }); } } else { System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => { _downloadStatus.ProgressBar.IsEnabled = false; _downloadStatus.Message.Show(Languages.AppResources.downloadNewSurveys_WrongResponse); }); } } else { System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => { _downloadStatus.ProgressBar.IsEnabled = false; _downloadStatus.Message.Show(Languages.AppResources.downloadNewSurveys_MoreSurveys); }); } } } catch (WebException) { System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => { _downloadStatus.ProgressBar.IsEnabled = false; _downloadStatus.Message.Show(Languages.AppResources.checkForNewSurveyList_ServerNotFound); }); } catch (XmlException) { System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() => { _downloadStatus.ProgressBar.IsEnabled = false; _downloadStatus.Message.Show(Languages.AppResources.checkForNewSurveyList_ServerIncompleteResponse); }); } }