The RequestState class passes data across async calls.
	/// <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;
	}
Ejemplo n.º 2
0
 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;
        }
Ejemplo n.º 4
0
        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;
        }
Ejemplo n.º 5
0
        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();
            }
        }
Ejemplo n.º 7
0
 public ActionStatusEventArgs(RequestState state, string msg)
 {
     State = state;
     Message = msg;
     Time = DateTime.Now;
     IsDetail = false;
 }
Ejemplo n.º 8
0
 public ActionStatusEventArgs(RequestState state, string msg, bool detailStatus)
 {
     State = state;
     Message = msg;
     Time = DateTime.Now;
     IsDetail = detailStatus;
 }
Ejemplo n.º 9
0
  //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);
            }
        }
Ejemplo n.º 11
0
        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
                });
            }
        }
Ejemplo n.º 12
0
 /// <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;
            }
        }
Ejemplo n.º 16
0
        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);
        }
Ejemplo n.º 17
0
        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
        }
Ejemplo n.º 18
0
        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);
        }
Ejemplo n.º 19
0
        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;
            }
        }
Ejemplo n.º 21
0
 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;
            }
        }
Ejemplo n.º 24
0
 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";
     }
 }
Ejemplo n.º 25
0
 /// <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);
 }
Ejemplo n.º 26
0
        /// <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);
        }
Ejemplo n.º 27
0
        /// <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;
        }
Ejemplo n.º 28
0
        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;
        }
Ejemplo n.º 29
0
	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);
	}
Ejemplo n.º 30
0
        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);
            }
        }
Ejemplo n.º 31
0
        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);
        }
Ejemplo n.º 32
0
        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);
            }
        }
Ejemplo n.º 33
0
        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);
            }
        }
Ejemplo n.º 34
0
 protected ReqResult(RequestState state)
 {
     State = state;
 }
Ejemplo n.º 35
0
        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);
                }
            }
        }
Ejemplo n.º 36
0
        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);
        }
Ejemplo n.º 37
0
        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;
        }
Ejemplo n.º 38
0
        /// <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));
        }
Ejemplo n.º 39
0
 public abstract object HeadContent(RequestState requestState);
Ejemplo n.º 40
0
 public PostNewFiles(RequestState state = null) : base(state)
 {
 }
Ejemplo n.º 41
0
        ////////////////////////////////////////////////////////////////
        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));
 }
Ejemplo n.º 43
0
        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);
        }
Ejemplo n.º 44
0
        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);
                }
            }
        }
Ejemplo n.º 45
0
    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;
            }
        }
    }
Ejemplo n.º 46
0
        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);
                }
            }
        }
Ejemplo n.º 47
0
        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;
            }));
        }
Ejemplo n.º 48
0
        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);
                    }
                }
            }
        }
Ejemplo n.º 49
0
 private async void ReadCallBack <T>(Task <int> task, RequestState <T> requestState)
 {
Ejemplo n.º 50
0
 public abstract void OnCmsEnd(RequestState requestState);
Ejemplo n.º 51
0
 public async Task <bool> Create(RequestState RequestState)
 {
     return(RequestState.IsValidated);
 }
Ejemplo n.º 52
0
 public abstract void OnCmsStart(RequestState requestState);
Ejemplo n.º 53
0
        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);
Ejemplo n.º 54
0
        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();
            }
        }
Ejemplo n.º 55
0
        /// <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);
            }
        }
Ejemplo n.º 56
0
        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();
        }
Ejemplo n.º 57
0
 /// <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());
 }
Ejemplo n.º 58
0
 public abstract void OnMainStart(RequestState requestState);
 public DelegatingStream(Stream inner, RequestState state)
 {
     this.inner = inner;
     this.state = state;
 }
Ejemplo n.º 60
0
 public abstract void OnMainEnd(RequestState requestState);