private void ThreadWorker()
{
Thread.CurrentThread.Name = "ConcurrentRequestWebService-" + GetHashCode();
var pendingRequests = new Queue<PrivateRequestData>();
var pendingResponses = new Queue<IAsyncResult>();
while (IsRunning)
{
lock (ApiLockSync)
{
if (_queuedRequest.Count == 0 && _pendingProcessing.Count == 0 && pendingRequests.Count == 0 && pendingResponses.Count == 0)
{
Monitor.Wait(ApiLockSync);
if (!IsRunning)
break;
}
while (_queuedRequest.Count > 0)
{
pendingRequests.Enqueue(_queuedRequest.Dequeue());
}
while (_pendingProcessing.Count > 0)
{
pendingResponses.Enqueue(_pendingProcessing.Dequeue());
}
}
var pendingCompletion = new Queue<PendingCompletion>();
for (var i = 0; (i < pendingRequests.Count) && (i < MaximumConcurrentRequests); i++)
{
var currentData = pendingRequests.Dequeue();
if (!Utils.HasInternetConnectivity)
{
var result = new WebServiceEventArgs(WebApiServerStatus.NoConnection, new NotSupportedException("No internet connection"), String.Empty, currentData.UserState);
Responser(currentData, result);
}
else
{
if (currentData.RequestType == RequestType.Get)
CreateGetRequestWithState(currentData, ProcessorCallback);
else if (currentData.RequestType == RequestType.Post)
CreatePostRequestWithState(currentData, ProcessorCallbackPost);
}
Thread.Sleep(1);
}
for (var i = 0; (i < pendingResponses.Count) && (i < MaximumConcurrentRequests); i++)
{
var pendingResponse = pendingResponses.Dequeue();
var pending = ProcessCompletion(pendingResponse);
pendingCompletion.Enqueue(pending);
Thread.Sleep(1);
}
for (var i = 0; i < pendingCompletion.Count; i++)
{
var almostDone = pendingCompletion.Dequeue();
PrivateCompletionProcessor(almostDone);
Thread.Sleep(1);
}
}
}
private void OnOperationCompleted(Guid guid, WebServiceEventArgs args)
{
var result = new ApiResult(args.UserState, args.Exception, args.ResponseStatus, args.ResponseString);
ApiCallCompleted(guid, result);
}
private void PrivateCompletionProcessor(PendingCompletion completion)
{
if (completion.Error != null)
{
WebServiceEventArgs response;
if (completion.Error is WebException)
{
response = GenerateFromException(completion.Error as WebException, HasInternetConnectivity, completion.RequestData.UserState);
}
else
{
response = new WebServiceEventArgs(WebApiServerStatus.Error, completion.Error, String.Empty, completion.RequestData.UserState);
}
Responser(completion.RequestData, response);
}
else // Read data from stream and continue
{
WebServiceEventArgs finalResponse;
using (var stream = completion.Result)
{
using (var streamReader = new StreamReader(stream))
{
while (!streamReader.EndOfStream)
{
StringBuilder.Append(streamReader.ReadLine());
}
var stringResult = StringBuilder.ToString();
finalResponse = new WebServiceEventArgs(WebApiServerStatus.Success, null, stringResult, completion.RequestData.UserState);
}
}
completion.Response.Close();
StringBuilder.Flush();
Responser(completion.RequestData, finalResponse);
}
}
protected override void Responser(PrivateRequestData requestData, WebServiceEventArgs completer)
{
var myRequestData = (DoubleQueueRequestData)requestData;
switch (myRequestData.CurrentWorker)
{
case CurrentlyUsedWorker.Primary:
_primaryWorker.SignalOperationDone();
break;
case CurrentlyUsedWorker.Secondary:
_secondaryWorker.SignalOperationDone();
break;
default:
throw new ArgumentOutOfRangeException();
}
base.Responser(myRequestData, completer);
}
private void StartPostRequestStreamCallback(IAsyncResult ar)
{
var userState = (PrivateWebUserState)ar.AsyncState;
Stream writableStream = null;
try
{
writableStream = userState.Request.EndGetRequestStream(ar);
using (var memoryStream = new MemoryStream())
{
var writableString = userState.Data.Parameters;
if (userState.Request.ContentType == PostContentType)
{
writableString = writableString.TrimStart('?');
}
// write tu buffer and reset position
var getBytes = Encoding.UTF8.GetBytes(writableString);
memoryStream.Write(getBytes, 0, getBytes.Length);
memoryStream.Position = 0;
// read from buffer stream
var buffer = new byte[getBytes.Length];
memoryStream.Read(buffer, 0, buffer.Length);
// write to stream
writableStream.Write(buffer, 0, buffer.Length);
}
}
catch (Exception e)
{
WebServiceEventArgs result;
if (e is WebException)
result = GenerateFromException(e as WebException, HasInternetConnectivity, userState.Data.UserState);
else
result = new WebServiceEventArgs(WebApiServerStatus.InvalidStream, e, String.Empty, userState.Data.UserState);
Responser(userState.Data, result);
return;
}
finally
{
if (writableStream != null)
{
writableStream.Close();
writableStream.Dispose();
// If all done good, get the response from the server
userState.Request.BeginGetResponse(GetResponseProcessorCallback, userState);
}
}
}
private void GetResponseProcessorCallback(IAsyncResult ar)
{
var webState = (PrivateWebUserState)ar.AsyncState;
HttpWebResponse response = null;
var result = WebServiceEventArgs.CreateDefault(webState.Data.UserState);
try
{
response = (HttpWebResponse)webState.Request.EndGetResponse(ar);
using (var returnStream = response.GetResponseStream())
using (var reader = new StreamReader(returnStream))
{
var builder = new StringBuilder();
while (!reader.EndOfStream)
builder.Append(reader.ReadLine());
var resultString = builder.ToString();
result = new WebServiceEventArgs(WebApiServerStatus.Success, null, resultString, webState.Data.UserState);
}
}
catch (Exception e)
{
if (e is WebException)
result = GenerateFromException(e as WebException, HasInternetConnectivity, webState.Data.UserState);
else
result = new WebServiceEventArgs(WebApiServerStatus.InvalidStream, e, String.Empty, webState.Data.UserState);
}
finally
{
if (response != null)
response.Close();
Responser(webState.Data, result);
}
}
protected static WebServiceEventArgs GenerateFromException(WebException e, bool hasInternet, object userState)
{
WebServiceEventArgs result;
var webEx = e;
Debug.WriteLine("WebException status {0}", webEx.Status);
switch (e.Status)
{
case WebExceptionStatus.RequestCanceled:
Debug.WriteLine("Cancelled!");
result = new WebServiceEventArgs(WebApiServerStatus.Cancelled, e, String.Empty, userState);
break;
case WebExceptionStatus.ConnectFailure:
Debug.WriteLine("Invalid Web Address");
result = new WebServiceEventArgs(WebApiServerStatus.Error, e, String.Empty, userState);
break;
default:
Debug.WriteLine("Some crappy error");
result = !hasInternet ?
new WebServiceEventArgs(WebApiServerStatus.NoConnection, e, String.Empty, userState) :
new WebServiceEventArgs(WebApiServerStatus.Unknown, e, String.Empty, userState);
break;
}
if (e.Message.Contains("NotFound") && hasInternet)
{
result = new WebServiceEventArgs(WebApiServerStatus.InvalidUrl, e, String.Empty, userState);
}
return result;
}
/// <summary>
/// Call the response callback from WebServiceEventArgs
/// </summary>
/// <param name="requestData"></param>
/// <param name="completer"></param>
protected virtual void Responser(PrivateRequestData requestData, WebServiceEventArgs completer)
{
if (completer == null)
throw new ArgumentNullException("completer", "Response must not be null.");
if (completer.ResponseStatus == WebApiServerStatus.Unknown)
Utils.ErrorLogInstance.AddError("Responser", "Default WebServiceEventArgs found. Invalid Web state");
lock (_requestLockObject)
{
// remove from running requests
RunningRequests.Remove(requestData.ApiGuidToken);
}
if (requestData.IsHandled) return;
// Finally call the callback on the father thread
if (requestData.ReturnOnUi)
Deployment.Current.Dispatcher.BeginInvoke(() => requestData.Result(requestData.ApiGuidToken, completer));
else
requestData.Result(requestData.ApiGuidToken, completer);
requestData.Dispose();
}