/// <summary> /// Updates the isURLmissing parameter. /// If the URL returns 404 or the connection is broken, it's missing. Else, we suppose it's fine. /// This should or can be used along with web async instance's isURLcheckingCompleted parameter /// inside a IEnumerator method capable of yield return for it, although it's mostly for clarity. /// Here's an usage example: /// /// WebAsync webAsync = new WebAsync(); StartCoroutine( webAsync.CheckForMissingURL(url) ); /// while (! webAsync.isURLcheckingCompleted) yield return null; /// bool result = webAsync.isURLmissing; /// /// </summary> /// <param name='url'> /// A fully formated URL. /// </param> public IEnumerator CheckForMissingURL (string url) { isURLcheckingCompleted = false; isURLmissing = false; Uri httpSite = new Uri(url); WebRequest webRequest = WebRequest.Create(httpSite); // We need no more than HTTP's head webRequest.Method = "HEAD"; // Get the request's reponse requestState = null; // Manually iterate IEnumerator, because Unity can't do it (and this does not inherit StartCoroutine from MonoBehaviour) IEnumerator e = GetResponse(webRequest); while (e.MoveNext()) yield return e.Current; while (! isResponseCompleted) yield return null; // this while is just to be sure and clear // Deal up with the results if (requestState.errorMessage != null) { if ( requestState.errorMessage.Contains("404") || requestState.errorMessage.Contains("NameResolutionFailure") ) { isURLmissing = true; } else { Debug.LogError("[WebAsync] Error trying to verify if URL '"+ url +"' exists: "+ requestState.errorMessage); } } isURLcheckingCompleted = true; }
public ObsRequestNode(XPathNavigator nav) { ID = nav.SelectSingleNode ("@id").Value; Description = nav.SelectSingleNode ("description").Value; State = new RequestState (nav.SelectSingleNode ("state")); Action = new RequestAction (nav.SelectSingleNode ("action")); }
public virtual Task<Stream> GetStream() { HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(ServiceUrl); request.UserAgent = ApiConstants.UserAgentHeaderValue; TaskCompletionSource<Stream> tcs = new TaskCompletionSource<Stream>(); RequestState state = new RequestState { Manager = this, TaskCompletionSource = tcs, Request = request }; if (Credentials != null) { NetworkCredential networkCred = Credentials.GetCredential( Client.BaseAddress, ApiConstants.BasicAuthorization); string credParameter = Convert.ToBase64String(Encoding.ASCII.GetBytes(networkCred.UserName + ":" + networkCred.Password)); request.Headers[ApiConstants.AuthorizationHeaderName] = string.Format( "{0} {1}", ApiConstants.BasicAuthorization, credParameter); } LogRequest(request); IAsyncResult result = request.BeginGetResponse(RemoteLogStreamManager.OnGetResponse, state); if (result.CompletedSynchronously) { state.Response = (HttpWebResponse)request.EndGetResponse(result); OnGetResponse(state); } return tcs.Task; }
public static HttpWebRequest TestUrl_Async(string url, int index, UrlTestUser caller) { if (!url.StartsWith("http://") && !url.StartsWith("https://")) url = url.Insert(0, "http://"); RequestState requestState = new RequestState(); requestState.index = index; requestState.caller = caller; HttpWebRequest request = null; try { request = (HttpWebRequest)WebRequest.Create(url); System.Net.Cache.HttpRequestCachePolicy policy = new System.Net.Cache.HttpRequestCachePolicy(System.Net.Cache.HttpRequestCacheLevel.BypassCache); request.CachePolicy = policy; request.UserAgent = user_agent; request.AllowAutoRedirect = false; requestState.request = request; IAsyncResult result = (IAsyncResult)request.BeginGetResponse(new AsyncCallback(TestUrl_AsyncCallback), requestState); } catch (WebException we) { requestState.connectionFailure = true; if (we.Status != WebExceptionStatus.RequestCanceled) // old requests that are invalid now shouldn't write into the ListView ResolveUrlTestResult(requestState); } catch (Exception e) { requestState.connectionFailure = true; ResolveUrlTestResult(requestState); } return request; }
public async Task<WebSocket> ConnectAsync(Uri uri, CancellationToken cancellationToken) { var state = new RequestState(uri, _pathBase, cancellationToken, _application); if (ConfigureRequest != null) { ConfigureRequest(state.Context.HttpContext.Request); } // Async offload, don't let the test code block the caller. var offload = Task.Factory.StartNew(async () => { try { await _application.ProcessRequestAsync(state.Context); state.PipelineComplete(); state.ServerCleanup(exception: null); } catch (Exception ex) { state.PipelineFailed(ex); state.ServerCleanup(ex); } finally { state.Dispose(); } }); return await state.WebSocketTask; }
internal void SendRequest(RestRequestArgs args, Action<XElement> success, Failed failed) { if (args == null) throw new ArgumentNullException("args"); if (success == null) throw new ArgumentNullException("success"); if (failed == null) throw new ArgumentNullException("failed"); // create a request state... RequestState state = new RequestState() { Owner = this, Args = args, Success = success, Failed = failed }; // are we authenticated? if we're not, we need to call that first... if (!(IsAuthenticated)) { // call the authenticate routine, and ask it to call the state we just setup // if authentication works... ApiService.Authenticate(new Action(state.DoRequest), failed); } else { // call the method directly... state.DoRequest(); } }
public ActionStatusEventArgs(RequestState state, string msg) { State = state; Message = msg; Time = DateTime.Now; IsDetail = false; }
public ActionStatusEventArgs(RequestState state, string msg, bool detailStatus) { State = state; Message = msg; Time = DateTime.Now; IsDetail = detailStatus; }
//public Run() public void Run() {/*{{{*/ allDone = new ManualResetEvent(false); // Create an instance of the RequestState class. RequestState myRequestState = new RequestState(); // Begin an asynchronous request for information like host name, IP addresses, or // aliases for specified the specified URI. IAsyncResult asyncResult = Dns.BeginGetHostEntry("www.contiioso.com", new AsyncCallback(RespCallback), myRequestState ); // Wait until asynchronous call completes. allDone.WaitOne(); //asyncResult.AsyncWaitHandle.WaitOne(); if(myRequestState.host == null) return; if(asyncResult.IsCompleted) Console.WriteLine("Get IPs!!"); Console.WriteLine("Host name : " + myRequestState.host.HostName); Console.WriteLine("\nIP address list : "); for(int index=0; index < myRequestState.host.AddressList.Length; index++) { Console.WriteLine(myRequestState.host.AddressList[index]); } Console.WriteLine("\nAliases : "); for(int index=0; index < myRequestState.host.Aliases.Length; index++) { Console.WriteLine(myRequestState.host.Aliases[index]); } }/*}}}*/
// This method is called by the timer delegate. public void Update(Object stateInfo) { try { logger.Info(string.Format("start update categories...")); string url = ConfigurationManager.AppSettings["cat_update_url"]; HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(string.Format(@"{0}", url)); RequestState requestState = new RequestState(); requestState.request = httpWebRequest; IAsyncResult result = (IAsyncResult)httpWebRequest.BeginGetResponse(new AsyncCallback(RespCallback), requestState); ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), httpWebRequest, DefaultTimeout, true); // The response came in the allowed time. The work processing will happen in the callback function. allDone.WaitOne(); // Release the HttpWebResponse resource. if (requestState != null && requestState.response != null) requestState.response.Close(); AutoResetEvent autoEvent = (AutoResetEvent)stateInfo; } catch (Exception ex) { logger.Error("update rates error", ex); } }
public void Download() { try { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this.uri); request.Timeout = 500; // Wait for .5 sec only RequestState state = new RequestState(); state.Request = request; state.Completed = this.completed; state.OriginalUri = this.uri; state.Properties = this.properties; IAsyncResult result = (IAsyncResult)request.BeginGetResponse( new AsyncCallback(ResponseCallback), state); ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), state, DEFAULT_TIMEOUT, true); } catch (Exception ex) { completed(new WebDownloaderEventArgs { Exception = ex, Stream = null, ResponseUri = this.uri, IsTimeout = false, Properties = this.properties, Status = HttpStatusCode.Unused }); } }
/// <summary> /// Default constructor that initializes all data members to /// default values /// </summary> public ProcessRequest() { this.user = null; this.infoAboutState = 0; this.newHTTPRequest.sizeOfBody = 0; this.newHTTPResponse.sizeOfBody = 0; }
/// <summary> /// Creates a new control instance. /// </summary> public ControlAddSliceToNodesSlice() { // Initialize the component. this.InitializeComponent(); // Create the request states. this.requestStateSlices = new RequestState(null, this.OnSitesRequestResult, null, null, null); this.requestStateNodes = new RequestState(null, this.OnNodesRequestResult, null, null, null); }
/// <summary> /// Stores the specified request <paramref name="state"/>, overriding /// any previous state with the same key /// </summary> /// <param name="state">Request state</param> public void Store(RequestState state) { if (state == null) throw new ArgumentNullException("state"); lock (this.SyncRoot) { HttpContext.Current.Session[GetStringKey(state.Key)] = state; } }
/// <summary> /// Stores the specified request <paramref name="state"/>, overriding /// any previous state with the same key /// </summary> /// <param name="state">Request state</param> public void Store(RequestState state) { if (state == null) throw new ArgumentNullException("state"); lock (this.SyncRoot) { this.states[state.Key] = state; } }
public void login(string username, string password) { HttpWebRequest request = createLoginRequest(); RequestState state = new RequestState(request, new creds(username, password), this, url.LoginUrl); request.BeginGetRequestStream( new AsyncCallback(GetRequestStreamCallback), state); }
public void DownloadDataAsync(HttpWebRequest request, byte[] d, int millisecondsTimeout, RequestCompletedEventHandler completedCallback) { RequestState state = new RequestState(request, d, millisecondsTimeout, completedCallback, null); IAsyncResult result = request.BeginGetResponse(GetResponse, state); #if !NETFX_CORE ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, TimeoutCallback, state, millisecondsTimeout, true); #endif }
public static void DownloadDataAsync(HttpWebRequest request, int millisecondsTimeout, DownloadProgressEventHandler downloadProgressCallback, RequestCompletedEventHandler completedCallback) { // Create an object to hold all of the state for this request RequestState state = new RequestState(request, null, millisecondsTimeout, null, downloadProgressCallback, completedCallback); // Start the request for the remote server response IAsyncResult result = request.BeginGetResponse(GetResponse, state); // Register a timeout for the request ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, TimeoutCallback, state, millisecondsTimeout, true); }
public void Fetch(ExternalResource resource) { if (resource != null) { var wr = WebRequest.Create(resource.Uri); var rs = new RequestState { Request = wr, Resource = resource }; var ar = wr.BeginGetResponse(ResponseCallback, rs); ThreadPool.RegisterWaitForSingleObject(ar.AsyncWaitHandle, TimeoutCallback, rs, Settings.Default.ExternalResourceTimeout * 1000, true); } }
/// <summary> /// Gets the request state stored for the specified <paramref name="key"/>, /// creating a new state object if none is stored. /// </summary> /// <param name="key">State key</param> /// <returns>State</returns> public RequestState Get(RequestStateKey key) { if (key == null) throw new ArgumentNullException("key"); lock (this.SyncRoot) { if (this.states.ContainsKey(key)) return this.states[key]; var state = new RequestState(key); this.Store(state); return state; } }
public void BeginExecuteQuery(String uriString, QueryExecutedCallback callback, Object tag) { try { RequestState state = new RequestState(); state.callback = callback; state.tag = tag; state.request = HttpWebRequest.Create(uriString); state.request.BeginGetResponse(new AsyncCallback(this.GotResponseCallback), state); } catch (Exception e) { callback(new QueryResult(this, e, tag)); } }
public IOperationResult Cancel() { if (this.State == RequestState.Waiting) { messaging.Publish(this.Requestor.Room, Tuple.Create(this, RequestState.Cancelled)); this.State = RequestState.Cancelled; } if (this.State == RequestState.Cancelled) { return new OperationResult(ResultValue.Success, ""); } return new OperationResult(ResultValue.Fail, "No puede cancelar, porque la batalla ya ha empezado!"); }
/// <summary> /// Gets the request state stored for the specified <paramref name="key"/>, /// creating a new state object if none is stored. /// </summary> /// <param name="key">State key</param> /// <returns>State</returns> public RequestState Get(RequestStateKey key) { if (key == null) throw new ArgumentNullException("key"); lock (this.SyncRoot) { var state = HttpContext.Current.Session[GetStringKey(key)] as RequestState; if (state != null) return state; state = new RequestState(key); this.Store(state); return state; } }
public static string GetName(RequestState RequestStateEnum) { switch (RequestStateEnum) { case RequestState.Selecting: return "SELECTING"; case RequestState.Renewing: return "RENEWING"; case RequestState.Rebinding: return "REBINDING"; case RequestState.InitReboot: return "INIT-REBOOT"; default: return "UNKNOWN"; } }
/// <summary> /// Creates a new control instance. /// </summary> public ControlRenewSlice() { // Initialize the component. this.InitializeComponent(); // Create the refresh request state. this.refreshRequestState = new RequestState( this.OnRefreshStarted, this.OnRefreshResult, this.OnRefreshCanceled, this.OnRefreshException, null); // Create the renew request state. this.renewRequestState = new RequestState( this.OnRenewStarted, this.OnRenewResult, this.OnRenewCanceled, this.OnRenewException, this.OnRenewFinished); }
/// <summary> /// This adapts HttpRequestMessages to ASP.NET requests, dispatches them through the pipeline, and returns the /// associated HttpResponseMessage. /// </summary> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns></returns> protected override async Task<HttpResponseMessage> SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var state = new RequestState(request, _pathBase, _application); var requestContent = request.Content ?? new StreamContent(Stream.Null); var body = await requestContent.ReadAsStreamAsync(); if (body.CanSeek) { // This body may have been consumed before, rewind it. body.Seek(0, SeekOrigin.Begin); } state.Context.HttpContext.Request.Body = body; var registration = cancellationToken.Register(state.AbortRequest); // Async offload, don't let the test code block the caller. var offload = Task.Factory.StartNew(async () => { try { await _application.ProcessRequestAsync(state.Context); state.CompleteResponse(); state.ServerCleanup(exception: null); } catch (Exception ex) { state.Abort(ex); state.ServerCleanup(ex); } finally { registration.Dispose(); } }); return await state.ResponseTask.ConfigureAwait(false); }
/// <summary> /// This adapts HttpRequestMessages to OWIN requests, dispatches them through the OWIN pipeline, and returns the /// associated HttpResponseMessage. /// </summary> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns></returns> protected override async Task<HttpResponseMessage> SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException("request"); } var state = new RequestState(request, cancellationToken); HttpContent requestContent = request.Content ?? new StreamContent(Stream.Null); Stream body = await requestContent.ReadAsStreamAsync(); if (body.CanSeek) { // This body may have been consumed before, rewind it. body.Seek(0, SeekOrigin.Begin); } state.OwinContext.Request.Body = body; CancellationTokenRegistration registration = cancellationToken.Register(state.Abort); // Async offload, don't let the test code block the caller. Task offload = Task.Factory.StartNew(async () => { try { await _next(state.Environment); state.CompleteResponse(); } catch (Exception ex) { state.Abort(ex); } finally { registration.Dispose(); state.Dispose(); } }); return await state.ResponseTask; }
public Task<Stream> GetStream() { HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(ServiceUrl); TaskCompletionSource<Stream> tcs = new TaskCompletionSource<Stream>(); RequestState state = new RequestState { Manager = this, TaskCompletionSource = tcs, Request = request }; if (this._client.DefaultRequestHeaders.Authorization != null) { request.Headers["Authorization"] = this._client.DefaultRequestHeaders.Authorization.Scheme + " " + this._client.DefaultRequestHeaders.Authorization.Parameter; } IAsyncResult result = request.BeginGetResponse(RemoteLogStreamManager.OnGetResponse, state); if (result.CompletedSynchronously) { state.Response = (HttpWebResponse)request.EndGetResponse(result); OnGetResponse(state); } return tcs.Task; }
public void getRequest(string urlS) { if (urlS==null || urlS.Length==0){ return ; } // Get the URI from the command line. Uri httpSite = new Uri(urlS); // Create the request object. WebRequest wreq = WebRequest.Create(httpSite); // Create the state object. RequestState rs = new RequestState(); // Put the request into the state object so it can be passed around. rs.Request = wreq; // Issue the async request. IAsyncResult r = (IAsyncResult) wreq.BeginGetResponse(new AsyncCallback(RespCallback), rs); }
public void CheckPortOpenAsync(int port, bool runTestServer) { // Contact FatAttitude service to determine if port is open if (runTestServer) { if (!StartSimpleServer(port)) { RaiseCheckPortOpenCompletedEvent(false, false, "Could not listen on local test socket -- have you forgotten to stop the Remote Potato server first?"); return; } } try { // Create a HttpWebrequest object to the desired URL. HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create("http://portcheck.remotepotato.com/?port=" + port.ToString() ); // Create an instance of the RequestState and assign the previous myHttpWebRequest object to its request field. RequestState myRequestState = new RequestState(); myRequestState.request = myHttpWebRequest; // Start the asynchronous request. IAsyncResult result = (IAsyncResult)myHttpWebRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), myRequestState); // Timeout: if there is a timeout, the callback fires and the request becomes aborted ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), myHttpWebRequest, DefaultTimeout, true); // The response came in the allowed time. The work processing will happen in the callback function. allDone.WaitOne(); // Release the HttpWebResponse resource. myRequestState.response.Close(); } catch (Exception e) { Functions.WriteLineToLogFile("PortChecker: CheckPortOpenAsync Exception raised"); Functions.WriteExceptionToLogFile(e); } }
private async Task <PNResult <PNChannelMembersResult> > ProcessRemoveChannelMembersOperationRequest(string channel, List <string> removeMemberList, PNPageObject page, int limit, bool includeCount, string includeOptions, List <string> sort, Dictionary <string, object> externalQueryParam) { PNResult <PNChannelMembersResult> ret = new PNResult <PNChannelMembersResult>(); if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim())) { PNStatus errStatus = new PNStatus { Error = true, ErrorData = new PNErrorData("Missing Channel", new ArgumentException("Missing Channel")) }; ret.Status = errStatus; return(ret); } if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0) { PNStatus errStatus = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid Subscribe key", new ArgumentException("Invalid Subscribe key")) }; ret.Status = errStatus; return(ret); } PNPageObject internalPage; if (page == null) { internalPage = new PNPageObject(); } else { internalPage = page; } RequestState <PNChannelMembersResult> requestState = new RequestState <PNChannelMembersResult>(); requestState.ResponseType = PNOperationType.PNRemoveChannelMembersOperation; requestState.Reconnect = false; requestState.EndPointOperation = this; requestState.UsePatchMethod = true; requestState.UsePatchMethod = true; Dictionary <string, object> messageEnvelope = new Dictionary <string, object>(); if (removeMemberList != null) { List <Dictionary <string, Dictionary <string, string> > > removeMemberFormatList = new List <Dictionary <string, Dictionary <string, string> > >(); for (int index = 0; index < removeMemberList.Count; index++) { Dictionary <string, Dictionary <string, string> > currentMemberFormat = new Dictionary <string, Dictionary <string, string> >(); if (!string.IsNullOrEmpty(removeMemberList[index])) { currentMemberFormat.Add("uuid", new Dictionary <string, string> { { "id", removeMemberList[index] } }); removeMemberFormatList.Add(currentMemberFormat); } } if (removeMemberFormatList.Count > 0) { messageEnvelope.Add("delete", removeMemberFormatList); } } string patchMessage = jsonLibrary.SerializeToJsonString(messageEnvelope); IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildMemberAddUpdateRemoveChannelRequest("PATCH", patchMessage, channel, internalPage.Next, internalPage.Prev, limit, includeCount, includeOptions, sort, externalQueryParam); Tuple <string, PNStatus> JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false, patchMessage).ConfigureAwait(false); ret.Status = JsonAndStatusTuple.Item2; string json = JsonAndStatusTuple.Item1; if (!string.IsNullOrEmpty(json)) { List <object> resultList = ProcessJsonResponse(requestState, json); ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog); PNChannelMembersResult responseResult = responseBuilder.JsonToObject <PNChannelMembersResult>(resultList, true); if (responseResult != null) { ret.Result = responseResult; } } return(ret); }
private void GetResponseAsyncCallback(IAsyncResult ar) { // Get the response RequestState r = (RequestState)ar.AsyncState; try { r.response = (HttpWebResponse)r.request.EndGetResponse(ar); } catch (Exception /* ex */) { // OpenSource.Utilities.EventLogger.Log(ex); } if (r.response == null) { PendingRequests--; if (OnRequestCompleted != null) { OnRequestCompleted(this, false, r.tag, r.url, null); } return; } byte[] buf; try { // Now pull everything out of the HTTP response stream Stream sss = r.response.GetResponseStream(); if (r.response.ContentLength > 0) { buf = new byte[(int)(r.response.ContentLength)]; int left = (int)(r.response.ContentLength); int pos = 0; int len = sss.Read(buf, pos, left); while (len != 0) { pos += len; left -= len; len = sss.Read(buf, pos, left); } } else { MemoryStream mem = new MemoryStream(); buf = new byte[10000]; int len = sss.Read(buf, 0, 10000); while (len != 0) { mem.Write(buf, 0, len); len = sss.Read(buf, 0, 10000); } buf = mem.ToArray(); } } catch (Exception ex) { OpenSource.Utilities.EventLogger.Log(ex); PendingRequests--; if (OnRequestCompleted != null) { OnRequestCompleted(this, false, r.tag, r.url, null); } return; } // Notify the caller of the response PendingRequests--; if (OnRequestCompleted != null) { OnRequestCompleted(this, true, r.tag, r.url, buf); } }
private void SharedSetUserState(string[] channels, string[] channelGroups, string uuid, string jsonChannelUserState, string jsonChannelGroupUserState, Dictionary <string, object> externalQueryParam, PNCallback <PNSetStateResult> callback) { List <string> channelList = new List <string>(); List <string> channelGroupList = new List <string>(); string currentUuid = uuid; string[] channelArray = null; if (channels != null && channels.Length > 0) { channelList = new List <string>(channels); channelList = channelList.Where(ch => !string.IsNullOrEmpty(ch) && ch.Trim().Length > 0).Distinct <string>().ToList(); channelArray = channelList.ToArray(); } string[] channelGroupsArray = null; if (channelGroups != null && channelGroups.Length > 0) { channelGroupList = new List <string>(channelGroups); channelGroupList = channelGroupList.Where(cg => !string.IsNullOrEmpty(cg) && cg.Trim().Length > 0).Distinct <string>().ToList(); channelGroupsArray = channelGroupList.ToArray(); } string commaDelimitedChannels = (channelArray != null && channelArray.Length > 0) ? string.Join(",", channelArray.OrderBy(x => x).ToArray()) : ""; string commaDelimitedChannelGroups = (channelGroupsArray != null && channelGroupsArray.Length > 0) ? string.Join(",", channelGroupsArray.OrderBy(x => x).ToArray()) : ""; if (string.IsNullOrEmpty(uuid)) { currentUuid = config.Uuid; } Dictionary <string, object> deserializeChannelUserState = jsonLibrary.DeserializeToDictionaryOfObject(jsonChannelUserState); Dictionary <string, object> deserializeChannelGroupUserState = jsonLibrary.DeserializeToDictionaryOfObject(jsonChannelGroupUserState); for (int channelIndex = 0; channelIndex < channelList.Count; channelIndex++) { string currentChannel = channelList[channelIndex]; ChannelUserState[PubnubInstance.InstanceId].AddOrUpdate(currentChannel.Trim(), deserializeChannelUserState, (oldState, newState) => deserializeChannelUserState); ChannelLocalUserState[PubnubInstance.InstanceId].AddOrUpdate(currentChannel.Trim(), deserializeChannelUserState, (oldState, newState) => deserializeChannelUserState); } for (int channelGroupIndex = 0; channelGroupIndex < channelGroupList.Count; channelGroupIndex++) { string currentChannelGroup = channelGroupList[channelGroupIndex]; ChannelGroupUserState[PubnubInstance.InstanceId].AddOrUpdate(currentChannelGroup.Trim(), deserializeChannelGroupUserState, (oldState, newState) => deserializeChannelGroupUserState); ChannelGroupLocalUserState[PubnubInstance.InstanceId].AddOrUpdate(currentChannelGroup.Trim(), deserializeChannelGroupUserState, (oldState, newState) => deserializeChannelGroupUserState); } string jsonUserState = "{}"; if ((jsonChannelUserState == jsonChannelGroupUserState) || (jsonChannelUserState != "{}" && jsonChannelGroupUserState == "{}")) { jsonUserState = jsonChannelUserState; } else if (jsonChannelUserState == "{}" && jsonChannelGroupUserState != "{}") { jsonUserState = jsonChannelGroupUserState; } else if (jsonChannelUserState != "{}" && jsonChannelGroupUserState != "{}") { jsonUserState = ""; for (int channelIndex = 0; channelIndex < channelList.Count; channelIndex++) { string currentChannel = channelList[channelIndex]; if (jsonUserState == "") { jsonUserState = string.Format("\"{0}\":{{{1}}}", currentChannel, jsonChannelUserState); } else { jsonUserState = string.Format("{0},\"{1}\":{{{2}}}", jsonUserState, currentChannel, jsonChannelUserState); } } for (int channelGroupIndex = 0; channelGroupIndex < channelGroupList.Count; channelGroupIndex++) { string currentChannelGroup = channelGroupList[channelGroupIndex]; if (jsonUserState == "") { jsonUserState = string.Format("\"{0}\":{{{1}}}", currentChannelGroup, jsonChannelGroupUserState); } else { jsonUserState = string.Format("{0},\"{1}\":{{{2}}}", jsonUserState, currentChannelGroup, jsonChannelGroupUserState); } } jsonUserState = string.Format("{{{0}}}", jsonUserState); } IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr); urlBuilder.PubnubInstanceId = (PubnubInstance != null) ? PubnubInstance.InstanceId : ""; Uri request = urlBuilder.BuildSetUserStateRequest(commaDelimitedChannels, commaDelimitedChannelGroups, currentUuid, jsonUserState, externalQueryParam); RequestState <PNSetStateResult> requestState = new RequestState <PNSetStateResult>(); requestState.Channels = channelArray; requestState.ChannelGroups = channelGroupsArray; requestState.ResponseType = PNOperationType.PNSetStateOperation; requestState.PubnubCallback = callback; requestState.Reconnect = false; requestState.EndPointOperation = this; //Set TerminateSubRequest to true to bounce the long-polling subscribe requests to update user state string json = UrlProcessRequest <PNSetStateResult>(request, requestState, true); if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse <PNSetStateResult>(requestState, json); ProcessResponseCallbacks(result, requestState); } }
protected ReqResult(RequestState state) { State = state; }
protected void OnRequestCallbackTimeout(object source, ElapsedEventArgs args) { bool timedOut = true; try { lock (this) { // Take care of the possibilty that this thread started but was paused just outside the lock before // the final request came in (assuming that such a thing is possible) if (m_requestState == RequestState.Completed) { timedOut = false; return; } m_requestState = RequestState.Aborted; } // Calculate which uuids were not found. This is an expensive way of doing it, but this is a failure // case anyway. List <UUID> uuids = new List <UUID>(); foreach (UUID uuid in m_uuids.Keys) { uuids.Add(uuid); } foreach (UUID uuid in m_foundAssetUuids) { uuids.Remove(uuid); } foreach (UUID uuid in m_notFoundAssetUuids) { uuids.Remove(uuid); } m_log.ErrorFormat( "[ARCHIVER]: Asset service failed to return information about {0} requested assets", uuids.Count); int i = 0; foreach (UUID uuid in uuids) { m_log.ErrorFormat("[ARCHIVER]: No information about asset {0} received", uuid); if (++i >= MAX_UUID_DISPLAY_ON_TIMEOUT) { break; } } if (uuids.Count > MAX_UUID_DISPLAY_ON_TIMEOUT) { m_log.ErrorFormat( "[ARCHIVER]: (... {0} more not shown)", uuids.Count - MAX_UUID_DISPLAY_ON_TIMEOUT); } m_log.Error("[ARCHIVER]: Archive save aborted. PLEASE DO NOT USE THIS ARCHIVE, IT WILL BE INCOMPLETE."); } catch (Exception e) { m_log.ErrorFormat("[ARCHIVER]: Timeout handler exception {0}{1}", e.Message, e.StackTrace); } finally { if (timedOut) { Util.RunThreadNoTimeout(PerformAssetsRequestCallback, "AssetsRequestCallback", true); } } }
private RequestState <TResponse> SendWebRequest <TResponse>(string httpMethod, string absoluteUrl, object request, Action <TResponse> onSuccess, Action <TResponse, Exception> onError) { if (httpMethod == null) { throw new ArgumentNullException("httpMethod"); } var requestUri = absoluteUrl; var httpGetOrDeleteOrHead = (httpMethod == "GET" || httpMethod == "DELETE" || httpMethod == "HEAD"); var hasQueryString = request != null && httpGetOrDeleteOrHead; if (hasQueryString) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { requestUri += "?" + queryString; } } #if SILVERLIGHT && !WINDOWS_PHONE && !NETFX_CORE var creator = this.UseBrowserHttpHandling ? System.Net.Browser.WebRequestCreator.BrowserHttp : System.Net.Browser.WebRequestCreator.ClientHttp; var webRequest = (HttpWebRequest)creator.Create(new Uri(requestUri)); if (StoreCookies && !UseBrowserHttpHandling) { if (ShareCookiesWithBrowser) { if (CookieContainer == null) { CookieContainer = new CookieContainer(); } CookieContainer.SetCookies(new Uri(BaseUri), System.Windows.Browser.HtmlPage.Document.Cookies); } webRequest.CookieContainer = CookieContainer; } #else _webRequest = (HttpWebRequest)WebRequest.Create(requestUri); if (StoreCookies) { _webRequest.CookieContainer = CookieContainer; } #endif #if !SILVERLIGHT if (!DisableAutoCompression) { _webRequest.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip,deflate"); _webRequest.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate; } #endif var requestState = new RequestState <TResponse> { HttpMethod = httpMethod, Url = requestUri, #if SILVERLIGHT && !WINDOWS_PHONE && !NETFX_CORE WebRequest = webRequest, #else WebRequest = _webRequest, #endif Request = request, OnSuccess = onSuccess, OnError = onError, #if SILVERLIGHT HandleCallbackOnUIThread = HandleCallbackOnUIThread, #endif }; requestState.StartTimer(this.Timeout.GetValueOrDefault(DefaultTimeout)); #if SILVERLIGHT && !WINDOWS_PHONE && !NETFX_CORE SendWebRequestAsync(httpMethod, request, requestState, webRequest); #else SendWebRequestAsync(httpMethod, request, requestState, _webRequest); #endif return(requestState); }
private void HandleResponseError <TResponse>(Exception exception, RequestState <TResponse> requestState) { var webEx = exception as WebException; if (webEx != null #if !SILVERLIGHT && webEx.Status == WebExceptionStatus.ProtocolError #endif ) { var errorResponse = ((HttpWebResponse)webEx.Response); Log.Error(webEx); Log.DebugFormat("Status Code : {0}", errorResponse.StatusCode); Log.DebugFormat("Status Description : {0}", errorResponse.StatusDescription); var serviceEx = new WebServiceException(errorResponse.StatusDescription) { StatusCode = (int)errorResponse.StatusCode, }; try { using (var stream = errorResponse.GetResponseStream()) { //Uncomment to Debug exceptions: //var strResponse = new StreamReader(stream).ReadToEnd(); //Console.WriteLine("Response: " + strResponse); //stream.Position = 0; serviceEx.ResponseBody = errorResponse.GetResponseStream().ReadFully().FromUtf8Bytes(); #if !MONOTOUCH // MonoTouch throws NotSupportedException when setting System.Net.WebConnectionStream.Position // Not sure if the stream is used later though, so may have to copy to MemoryStream and // pass that around instead after this point? stream.Position = 0; #endif serviceEx.ResponseDto = this.StreamDeserializer(typeof(TResponse), stream); requestState.HandleError((TResponse)serviceEx.ResponseDto, serviceEx); } } catch (Exception innerEx) { // Oh, well, we tried Log.Debug(string.Format("WebException Reading Response Error: {0}", innerEx.Message), innerEx); requestState.HandleError(default(TResponse), new WebServiceException(errorResponse.StatusDescription, innerEx) { StatusCode = (int)errorResponse.StatusCode, }); } return; } var authEx = exception as AuthenticationException; if (authEx != null) { var customEx = WebRequestUtils.CreateCustomException(requestState.Url, authEx); Log.Debug(string.Format("AuthenticationException: {0}", customEx.Message), customEx); requestState.HandleError(default(TResponse), authEx); } Log.Debug(string.Format("Exception Reading Response Error: {0}", exception.Message), exception); requestState.HandleError(default(TResponse), exception); _webRequest = null; }
/// <summary> /// Performs an asynchronous http request that can be cancelled. /// </summary> /// <param name="request">The options to consider.</param> /// <param name="cancellationToken"> /// The token for cancelling the task. /// </param> /// <returns> /// The task that will eventually give the response data. /// </returns> public Task <IResponse> RequestAsync(IRequest request, CancellationToken cancellationToken) { var cache = new RequestState(request, _headers); return(cache.RequestAsync(cancellationToken)); }
public abstract object HeadContent(RequestState requestState);
public PostNewFiles(RequestState state = null) : base(state) { }
//////////////////////////////////////////////////////////////// Hashtable outputs(RequestObject requestObject, string ip /*, string uris*/) { var hash_r = new Hashtable(); allDone = new ManualResetEvent(false); allRequests = hash.Keys.Count; //Console.WriteLine("Start update: URL=" + requestObject.URLs); DateTime t1 = DateTime.Now; string preffix = requestObject.URLs.Substring(0, requestObject.URLs.IndexOf("://") + 3); foreach (DictionaryEntry de in hash) { if (requestStates.Count < hash.Keys.Count) { RequestState requestState = new RequestState(); requestState.id = de.Key.ToString(); // Put the request into the state object so it can be passed around. requestState.url = preffix + ip + "/ajax.app?SessionId=" + sessionId + "&service=getDp&plantItemId=" + de.Key; //requestState.sLocation = uris; //requestState.ua = uAgent; //requestState.acp = Acpt; requestStates.Add(requestState); } } /* * while (allRequests>0) * { * * } */ CallHttpWebRequestASyncDataParallelAndWaitOnAll(requestStates); foreach (RequestState resultrequestState in requestStates) { try { if (resultrequestState.responseData == null) { continue; } /* * Regex r = new Regex(@"plantItemId"":""(\d+)"",""value"":""([^""]+)", RegexOptions.Singleline); * // "id=""dp([^""]+)"">\s*([^""]+)\<\/div\>" * foreach (Match m in r.Matches(resultrequestState.responseData)) * { * hash_r.Add(m.Groups[1].Value, m.Groups[2].Value); * } */ foreach (var r in resultrequestState.hash.Keys) { if (r.ToString() == "476") { Console.WriteLine(resultrequestState.hash[r].ToString().Trim()); } if (!hash_r.ContainsKey(r)) { hash_r.Add(r, resultrequestState.hash[r]); } } if (resultrequestState.sessinNeedUpdate) { sessionId = posting(requestObject.URLs, googies, uAgent, Acpt, log, pass); resultrequestState.sessinNeedUpdate = false; } } catch (Exception ex) { throw ex; } } //Console.WriteLine("End update: URL=" + requestObject.URLs + "time=" + (DateTime.Now - t1)); return(hash_r); }
private void OnGetResponse(RequestState state) { state.TaskCompletionSource.TrySetResult(new DelegatingStream(state.Response.GetResponseStream(), state)); }
private async Task <PNResult <PNPublishResult> > Fire(string channel, object message, bool storeInHistory, int ttl, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam) { PNResult <PNPublishResult> ret = new PNResult <PNPublishResult>(); if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null) { PNStatus errStatus = new PNStatus { Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message")) }; ret.Status = errStatus; return(ret); } if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0) { PNStatus errStatus = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key")) }; ret.Status = errStatus; return(ret); } Dictionary <string, string> urlParam = new Dictionary <string, string>(); urlParam.Add("norep", "true"); string requestMethodName = (this.httpPost) ? "POST" : "GET"; IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildPublishRequest(requestMethodName, "", channel, message, storeInHistory, ttl, metaData, urlParam, externalQueryParam); RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>(); requestState.Channels = new[] { channel }; requestState.ResponseType = PNOperationType.PNFireOperation; requestState.Reconnect = false; requestState.EndPointOperation = this; Tuple <string, PNStatus> JsonAndStatusTuple; if (this.httpPost) { requestState.UsePostMethod = true; Dictionary <string, object> messageEnvelope = new Dictionary <string, object>(); messageEnvelope.Add("message", message); string postMessage = jsonLibrary.SerializeToJsonString(messageEnvelope); JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false, postMessage).ConfigureAwait(false); } else { JsonAndStatusTuple = await UrlProcessRequest(request, requestState, false).ConfigureAwait(false); } ret.Status = JsonAndStatusTuple.Item2; string json = JsonAndStatusTuple.Item1; if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse <PNPublishResult>(requestState, json); if (result != null && result.Count >= 3) { int publishStatus; Int32.TryParse(result[0].ToString(), out publishStatus); if (publishStatus == 1) { List <object> resultList = ProcessJsonResponse(requestState, json); if (resultList != null && resultList.Count > 0) { ResponseBuilder responseBuilder = new ResponseBuilder(config, jsonLibrary, pubnubLog); PNPublishResult responseResult = responseBuilder.JsonToObject <PNPublishResult>(resultList, true); if (responseResult != null) { ret.Result = responseResult; } } } } } return(ret); }
private void Fire(string channel, object message, bool storeInHistory, int ttl, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam, PNCallback <PNPublishResult> callback) { if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message")) }; callback.OnResponse(null, status); return; } if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key")) }; callback.OnResponse(null, status); return; } if (callback == null) { return; } Dictionary <string, string> urlParam = new Dictionary <string, string>(); urlParam.Add("norep", "true"); string requestMethodName = (this.httpPost) ? "POST" : "GET"; IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildPublishRequest(requestMethodName, "", channel, message, storeInHistory, ttl, metaData, urlParam, externalQueryParam); RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>(); requestState.Channels = new [] { channel }; requestState.ResponseType = PNOperationType.PNFireOperation; requestState.PubnubCallback = callback; requestState.Reconnect = false; requestState.EndPointOperation = this; string json = ""; if (this.httpPost) { requestState.UsePostMethod = true; Dictionary <string, object> messageEnvelope = new Dictionary <string, object>(); messageEnvelope.Add("message", message); string postMessage = jsonLibrary.SerializeToJsonString(messageEnvelope); UrlProcessRequest(request, requestState, false, postMessage).ContinueWith(r => { json = r.Result.Item1; }, TaskContinuationOptions.ExecuteSynchronously).Wait(); } else { UrlProcessRequest(request, requestState, false).ContinueWith(r => { json = r.Result.Item1; }, TaskContinuationOptions.ExecuteSynchronously).Wait(); } if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse <PNPublishResult>(requestState, json); if (result != null && result.Count >= 3) { int publishStatus; Int32.TryParse(result[0].ToString(), out publishStatus); if (publishStatus == 1) { ProcessResponseCallbacks(result, requestState); } else { PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString()); PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNFireOperation, category, requestState, 400, new PNException(json)); if (requestState.PubnubCallback != null) { requestState.PubnubCallback.OnResponse(default(PNPublishResult), status); } } } else { ProcessResponseCallbacks(result, requestState); } } }
public override void OnBackGroundExcute() { if (string.IsNullOrEmpty(m_url)) { base.SetFailded(); return; } m_resquestData = new RequestState(); string urlFormat = m_url.Replace(" ", "%20"); WebRequest requestPtr = null; if (urlFormat.StartsWith("ftp")) { FtpWebRequest ftprequestPtr = FtpWebRequest.Create(urlFormat) as FtpWebRequest; ftprequestPtr.Timeout = 4000; ftprequestPtr.ReadWriteTimeout = 80000; ftprequestPtr.KeepAlive = false; requestPtr = ftprequestPtr; } else { HttpWebRequest httprequestPtr = HttpWebRequest.Create(urlFormat) as HttpWebRequest; httprequestPtr.Timeout = 4000; httprequestPtr.ReadWriteTimeout = 80000; httprequestPtr.KeepAlive = false; requestPtr = httprequestPtr; } Debug.LogError(urlFormat); m_resquestData.request = requestPtr; try { m_resquestData.response = m_resquestData.request.GetResponse(); m_resquestData.streamResponse = m_resquestData.response.GetResponseStream(); int lenResult = m_resquestData.streamResponse.Read(m_resquestData.BufferRead, 0, BUFFER_SIZE); while (0 < lenResult) { m_resquestData.readLength += lenResult; m_resquestData.memStream.Write(m_resquestData.BufferRead, 0, lenResult); lenResult = m_resquestData.streamResponse.Read(m_resquestData.BufferRead, 0, BUFFER_SIZE); } if (0 < m_resquestData.readLength) { m_resquestData.memStream.Seek(0, SeekOrigin.Begin); } } catch (WebException wex) { SetFailded(); //LogHelp.LogAuto(wex.Message.ToString() + wex.Status.ToString()); } catch { SetFailded(); } finally { if (null != m_resquestData.streamResponse) { m_resquestData.streamResponse.Close(); m_resquestData.streamResponse = null; } if (null != m_resquestData.response) { m_resquestData.response.Close(); m_resquestData.response = null; } if (null != m_resquestData.request) { m_resquestData.request.Abort(); m_resquestData.request = null; } } }
void getRequestStreamCallback(IAsyncResult result) { AsyncResult asyncResult; if (result is AsyncResult) { asyncResult = result as AsyncResult; } else { asyncResult = result.AsyncState as AsyncResult; } asyncResult.RequestState.GetRequestStreamCallbackCalled = true; try { RequestState state = asyncResult.RequestState; if (asyncResult != null && asyncResult.RequestState != null && asyncResult.RequestState.RequestData != null && asyncResult.RequestState.RequestData.Length > 0 && asyncResult.RequestState.WebRequest.Method == "POST") { Stream requestStream; if (asyncResult.CompletedSynchronously) { requestStream = state.WebRequest.GetRequestStream(); } else { requestStream = state.WebRequest.EndGetRequestStream(result); } using (requestStream) { byte[] requestData = asyncResult.RequestState.RequestData; requestStream.Write(requestData, 0, requestData.Length); } } if (asyncResult.CompletedSynchronously) { this.getResponseCallback(asyncResult); } else { IAsyncResult httpResult = state.WebRequest.BeginGetResponse(new AsyncCallback(this.getResponseCallback), asyncResult); if (httpResult.CompletedSynchronously) { if (!asyncResult.RequestState.GetResponseCallbackCalled) { getResponseCallback(httpResult); } asyncResult.SetCompletedSynchronously(true); } } } catch (Exception e) { asyncResult.RequestState.WebRequest.Abort(); asyncResult.Exception = e; asyncResult.SignalWaitHandle(); if (asyncResult.Callback != null) { asyncResult.Callback(asyncResult); } } }
public void Send() { if (sent) { throw new InvalidOperationException("Request has already completed."); } sent = true; isDone = false; state = RequestState.Waiting; #if USE_GZIP if (acceptGzip) { headers.Set("Accept-Encoding", "gzip"); } #endif if (timeout > 0) { SimpleWWW.Instance.StartCoroutine(Timeout()); } ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object t) { try { var retry = 0; while (++retry < maximumRedirects) { if (useCache) { string etag = ""; if (etags.TryGetValue(uri.AbsoluteUri, out etag)) { headers.Set("If-None-Match", etag); } } var hostHeader = uri.Host; if (uri.Port != 80 && uri.Port != 443) { hostHeader += ":" + uri.Port.ToString(); } headers.Set("Host", hostHeader); #if USE_COOKIES if (enableCookies && uri != null) { try { var c = cookies.GetCookieHeader(uri); if (c != null && c.Length > 0) { headers.Set("Cookie", c); } } catch (NullReferenceException) { //Some cookies make the .NET cookie class barf. MEGH again. } catch (IndexOutOfRangeException) { //Another weird exception that comes through from the cookie class. } } #endif ActiveConnection connection = null; while (true) { try { //pull a connection from the pool (a new one is created if needed) connection = GetClient(uri.Host, uri.Port, uri.Scheme.ToLower() == "https"); } catch (Exception e) { Debug.Log(e); exception = e; response = null; break; } try { WriteToStream(connection.stream); } catch (IOException e) { Debug.Log(e); exception = new IOException("Server closed the connection:" + e.ToString()); response = null; break; } response = new Response(this); state = RequestState.Reading; try { response.ReadFromStream(connection.stream); } catch (IOException e) { Debug.Log(e); exception = new IOException("Server closed the connection:" + e.ToString()); response = null; break; } catch (HTTPException) { continue; } break; } if (response != null) { #if USE_COOKIES if (enableCookies) { foreach (var i in response.headers.GetAll("Set-Cookie")) { try { cookies.SetCookies(uri, i); } catch (System.Net.CookieException) { //Some cookies make the .NET cookie class barf. MEGH. } } } #endif switch (response.status) { case 101: upgradedConnection = connection; retry = maximumRedirects; break; case 304: retry = maximumRedirects; break; case 307: case 302: case 301: uri = new Uri(response.headers.Get("Location")); if (OnRedirect != null) { OnRedirect(uri); retry = maximumRedirects; } break; default: retry = maximumRedirects; break; } //close the connection back if not upgraded. if (upgradedConnection == null) { lock (connectionPool) { var close = response.headers.Get("Connection").ToLower() == "close"; if (!close) { connectionPool.Add(connection); } else { connection.stream.Close(); } } } } } if (useCache && response != null) { string etag = response.headers.Get("etag"); if (etag.Length > 0) { etags [uri.AbsoluteUri] = etag; SaveEtags(); } } } catch (Exception e) { Debug.Log(e); exception = e; response = null; } state = RequestState.Done; isDone = true; })); }
void getResponseCallback(IAsyncResult result) { AsyncResult asyncResult; if (result is AsyncResult) { asyncResult = result as AsyncResult; } else { asyncResult = result.AsyncState as AsyncResult; } asyncResult.RequestState.GetResponseCallbackCalled = true; bool shouldRetry = false; try { RequestState state = asyncResult.RequestState; HttpWebResponse httpResponse = null; try { if (asyncResult.CompletedSynchronously) { httpResponse = state.WebRequest.GetResponse() as HttpWebResponse; } else { httpResponse = state.WebRequest.EndGetResponse(result) as HttpWebResponse; } asyncResult.ResponseReceived = DateTime.UtcNow; this.logger.InfoFormat("Received response for {0} with status code {1} in {2} ms.", asyncResult.RequestName, httpResponse.StatusCode, (asyncResult.ResponseReceived - asyncResult.RequestSent).TotalMilliseconds); using (httpResponse) { var unmarshaller = asyncResult.Unmarshaller; var context = unmarshaller.CreateContext(httpResponse, config.LogResponse); if (config.LogResponse) { this.logger.InfoFormat("Received response: [{0}]", context.ResponseBody); } asyncResult.FinalResponse = unmarshaller.Unmarshall(context); } } catch (WebException we) { shouldRetry = handleHttpWebErrorResponse(asyncResult, we); } catch (IOException ioe) { shouldRetry = handleIOException(asyncResult, httpResponse, ioe); } if (shouldRetry) { asyncResult.RequestState.WebRequest.Abort(); asyncResult.RetriesAttempt++; InvokeConfiguredRequest(asyncResult); } } catch (Exception e) { asyncResult.RequestState.WebRequest.Abort(); asyncResult.Exception = e; shouldRetry = false; logger.Error(string.Format("Error configuring web request {0} to {1}.", asyncResult.RequestName, asyncResult.Request.Endpoint.ToString()), e); } finally { if (!shouldRetry) { asyncResult.SignalWaitHandle(); if (asyncResult.Callback != null) { asyncResult.Callback(asyncResult); } } } }
private async void ReadCallBack <T>(Task <int> task, RequestState <T> requestState) {
public abstract void OnCmsEnd(RequestState requestState);
public async Task <bool> Create(RequestState RequestState) { return(RequestState.IsValidated); }
public abstract void OnCmsStart(RequestState requestState);
private void Signal(string channel, object message, Dictionary <string, object> metaData, Dictionary <string, object> externalQueryParam, PNCallback <PNPublishResult> callback) { if (string.IsNullOrEmpty(channel) || string.IsNullOrEmpty(channel.Trim()) || message == null) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Missing Channel or Message", new ArgumentException("Missing Channel or Message")) }; callback.OnResponse(null, status); return; } if (string.IsNullOrEmpty(config.PublishKey) || string.IsNullOrEmpty(config.PublishKey.Trim()) || config.PublishKey.Length <= 0) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid publish key", new ArgumentException("Invalid publish key")) }; callback.OnResponse(null, status); return; } if (string.IsNullOrEmpty(config.SubscribeKey) || string.IsNullOrEmpty(config.SubscribeKey.Trim()) || config.SubscribeKey.Length <= 0) { PNStatus status = new PNStatus { Error = true, ErrorData = new PNErrorData("Invalid subscribe key", new ArgumentException("Invalid subscribe key")) }; callback.OnResponse(null, status); return; } IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildSignalRequest("GET", "", channel, message, metaData, externalQueryParam); RequestState <PNPublishResult> requestState = new RequestState <PNPublishResult>(); requestState.Channels = new[] { channel }; requestState.ResponseType = PNOperationType.PNSignalOperation; requestState.PubnubCallback = callback; requestState.Reconnect = false; requestState.EndPointOperation = this; UrlProcessRequest(request, requestState, false).ContinueWith(r => { string json = r.Result.Item1; if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse(requestState, json); if (result != null && result.Count >= 3) { int signalStatus; Int32.TryParse(result[0].ToString(), out signalStatus); if (signalStatus == 1) { ProcessResponseCallbacks(result, requestState); } else { PNStatusCategory category = PNStatusCategoryHelper.GetPNStatusCategory(400, result[1].ToString()); PNStatus status = new StatusBuilder(config, jsonLibrary).CreateStatusResponse <PNPublishResult>(PNOperationType.PNSignalOperation, category, requestState, 400, new PNException(json)); if (requestState.PubnubCallback != null) { requestState.PubnubCallback.OnResponse(default, status);
protected void OnRequestCallbackTimeout(object source, ElapsedEventArgs args) { try { lock (this) { // Take care of the possibility that this thread started but was paused just outside the lock before // the final request came in (assuming that such a thing is possible) if (m_requestState == RequestState.Completed) { return; } m_requestState = RequestState.Aborted; } // Calculate which uuids were not found. This is an expensive way of doing it, but this is a failure // case anyway. List <UUID> uuids = m_uuids.Keys.ToList(); foreach (UUID uuid in m_foundAssetUuids) { uuids.Remove(uuid); } foreach (UUID uuid in m_notFoundAssetUuids) { uuids.Remove(uuid); } MainConsole.Instance.ErrorFormat( "[Archiver]: Asset service failed to return information about {0} requested assets", uuids.Count); int i = 0; foreach (UUID uuid in uuids) { MainConsole.Instance.ErrorFormat("[Archiver]: No information about asset {0} received", uuid); if (++i >= MAX_UUID_DISPLAY_ON_TIMEOUT) { break; } } if (uuids.Count > MAX_UUID_DISPLAY_ON_TIMEOUT) { MainConsole.Instance.ErrorFormat( "[Archiver]: (... {0} more not shown)", uuids.Count - MAX_UUID_DISPLAY_ON_TIMEOUT); } MainConsole.Instance.Error("[Archiver]: OAR save aborted."); } catch (Exception e) { MainConsole.Instance.ErrorFormat("[Archiver]: Timeout handler exception {0}", e); } finally { m_assetsArchiver.ForceClose(); } }
/// <summary> /// Called back by the asset cache when it has the asset /// </summary> /// <param name="assetID"></param> /// <param name="asset"></param> public void AssetRequestCallback(string id, object sender, AssetBase asset) { Culture.SetCurrentCulture(); try { lock (this) { //m_log.DebugFormat("[ARCHIVER]: Received callback for asset {0}", id); m_requestCallbackTimer.Stop(); if ((m_requestState == RequestState.Aborted) || (m_requestState == RequestState.Completed)) { m_log.WarnFormat( "[ARCHIVER]: Received information about asset {0} while in state {1}. Ignoring.", id, m_requestState); return; } if (asset != null) { if (m_options.ContainsKey("verbose")) { m_log.InfoFormat("[ARCHIVER]: Writing asset {0}", id); } m_foundAssetUuids.Add(asset.FullID); m_assetsArchiver.WriteAsset(PostProcess(asset)); } else { if (m_options.ContainsKey("verbose")) { m_log.InfoFormat("[ARCHIVER]: Recording asset {0} as not found", id); } m_notFoundAssetUuids.Add(new UUID(id)); } if (m_foundAssetUuids.Count + m_notFoundAssetUuids.Count >= m_repliesRequired) { m_requestState = RequestState.Completed; m_log.DebugFormat( "[ARCHIVER]: Successfully added {0} assets ({1} assets not found but these may be expected invalid references)", m_foundAssetUuids.Count, m_notFoundAssetUuids.Count); // We want to stop using the asset cache thread asap // as we now need to do the work of producing the rest of the archive Util.RunThreadNoTimeout(PerformAssetsRequestCallback, "AssetsRequestCallback", false); } else { m_requestCallbackTimer.Start(); } } } catch (Exception e) { m_log.ErrorFormat("[ARCHIVER]: AssetRequestCallback failed with {0}", e); } }
private void ProcessRemoveChannelMembersOperationRequest(string spaceId, List <string> removeMemberList, PNPageObject page, int limit, bool includeCount, string includeOptions, List <string> sort, Dictionary <string, object> externalQueryParam, PNCallback <PNChannelMembersResult> callback) { PNPageObject internalPage; if (page == null) { internalPage = new PNPageObject(); } else { internalPage = page; } RequestState <PNChannelMembersResult> requestState = new RequestState <PNChannelMembersResult>(); requestState.ResponseType = PNOperationType.PNRemoveChannelMembersOperation; requestState.PubnubCallback = callback; requestState.Reconnect = false; requestState.EndPointOperation = this; requestState.UsePatchMethod = true; Dictionary <string, object> messageEnvelope = new Dictionary <string, object>(); if (removeMemberList != null) { List <Dictionary <string, Dictionary <string, string> > > removeMemberFormatList = new List <Dictionary <string, Dictionary <string, string> > >(); for (int index = 0; index < removeMemberList.Count; index++) { Dictionary <string, Dictionary <string, string> > currentMemberFormat = new Dictionary <string, Dictionary <string, string> >(); if (!string.IsNullOrEmpty(removeMemberList[index])) { currentMemberFormat.Add("uuid", new Dictionary <string, string> { { "id", removeMemberList[index] } }); removeMemberFormatList.Add(currentMemberFormat); } } if (removeMemberFormatList.Count > 0) { messageEnvelope.Add("delete", removeMemberFormatList); } } string patchMessage = jsonLibrary.SerializeToJsonString(messageEnvelope); IUrlRequestBuilder urlBuilder = new UrlRequestBuilder(config, jsonLibrary, unit, pubnubLog, pubnubTelemetryMgr, (PubnubInstance != null) ? PubnubInstance.InstanceId : ""); Uri request = urlBuilder.BuildMemberAddUpdateRemoveChannelRequest("PATCH", patchMessage, spaceId, internalPage.Next, internalPage.Prev, limit, includeCount, includeOptions, sort, externalQueryParam); UrlProcessRequest(request, requestState, false, patchMessage).ContinueWith(r => { string json = r.Result.Item1; if (!string.IsNullOrEmpty(json)) { List <object> result = ProcessJsonResponse(requestState, json); ProcessResponseCallbacks(result, requestState); } else { if (r.Result.Item2 != null) { callback.OnResponse(null, r.Result.Item2); } } }, TaskContinuationOptions.ExecuteSynchronously).Wait(); }
/// <summary> /// Sets the requested state for a package that the TestBA will return to the engine during plan. /// </summary> /// <param name="packageId">Package identity.</param> /// <param name="state">State to request.</param> protected void SetPackageRequestedState(string packageId, RequestState state) { this.SetPackageState(packageId, "Requested", state.ToString()); }
public abstract void OnMainStart(RequestState requestState);
public DelegatingStream(Stream inner, RequestState state) { this.inner = inner; this.state = state; }
public abstract void OnMainEnd(RequestState requestState);