private void HandleException <T>(AsyncStreamSetInfo <T> asyncStreamSetInfo, Exception e)
{
String error = e.Message;
#if (!UNIVERSALW8 && !FULL_BUILD && !WINDOWS_PHONE && !PURE_CLIENT_LIB && !WINDOWS_PHONE8)
if (e is SecurityException)
{
if (WeborbClient.Uri.Scheme.ToLower().StartsWith("file"))
{
error = SECURITY_FAULT_MESSAGE;
}
}
if (UiControl != null)
{
UiControl.Dispatcher.BeginInvoke(delegate()
{
HtmlPage.Window.Alert(error);
});
}
#endif
if (asyncStreamSetInfo != null)
{
Fault fault = new Fault(error, e.StackTrace, INTERNAL_CLIENT_EXCEPTION_FAULT_CODE);
if (asyncStreamSetInfo.responder != null)
{
if (e is WebException && ((WebException)e).Status == WebExceptionStatus.RequestCanceled)
{
fault = new Fault(TIMEOUT_FAULT_MESSAGE, TIMEOUT_FAULT_MESSAGE);
}
asyncStreamSetInfo.responder.ErrorHandler(fault);
}
}
}
public void Invoke <T>(String className, String methodName, Object[] args, IDictionary httpRequestHeaders, IDictionary messageHeaders, Responder <T> responder, ResponseThreadConfigurator responseThreadConfigurator)
{
AsyncStreamSetInfo <T> asyncStreamSetInfo = new AsyncStreamSetInfo <T>();
asyncStreamSetInfo.responseThreadConfigurator = responseThreadConfigurator;
_engine.Invoke(className, methodName, args, null, messageHeaders, httpRequestHeaders, responder, asyncStreamSetInfo);
}
private void ProcessAMFResponse <T>(IAsyncResult asyncResult)
{
try
{
AsyncStreamSetInfo <T> asyncStreamSetInfo = (AsyncStreamSetInfo <T>)asyncResult.AsyncState;
if (asyncStreamSetInfo.responseThreadConfigurator != null)
{
asyncStreamSetInfo.responseThreadConfigurator();
}
HttpWebRequest request = asyncStreamSetInfo.request;
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asyncResult);
if (Cookies != null)
{
foreach (Cookie cookie in response.Cookies)
{
Cookies.Add(new Uri(GatewayUrl), cookie);
}
}
Stream streamResponse = response.GetResponseStream();
long curTime = DateTime.Now.Ticks;
long roundTrip = (curTime - asyncStreamSetInfo.messageSentTime) / TimeSpan.TicksPerMillisecond;
RequestParser parser = new RequestParser();
Request responseObject = parser.readMessage(streamResponse);
object[] responseData = (object[])responseObject.getRequestBodyData();
V3Message v3 = (V3Message)((IAdaptingType)responseData[0]).defaultAdapt();
if (v3.isError)
{
ErrMessage errorMessage = (ErrMessage)v3;
Fault fault = new Fault(errorMessage.faultString, errorMessage.faultDetail, errorMessage.faultCode);
if (asyncStreamSetInfo.responder != null)
{
asyncStreamSetInfo.responder.ErrorHandler(fault);
}
return;
}
IAdaptingType body = (IAdaptingType)((AnonymousObject)((NamedObject)responseData[0]).TypedObject).Properties["body"];
T result = (T)body.adapt(typeof(T));
if (asyncStreamSetInfo.responder != null)
{
asyncStreamSetInfo.responder.ResponseHandler(result);
}
// ProcessV3Message( v3, asyncStreamSetInfo.responder );
}
catch (Exception e)
{
AsyncStreamSetInfo <T> asyncStreamSetInfo = (AsyncStreamSetInfo <T>)asyncResult.AsyncState;
ProccessException(e, asyncStreamSetInfo.responder);
}
}
public override void SendRequest <T>(V3Message v3Msg,
IDictionary requestHeaders,
IDictionary httpHeaders,
Responder <T> responder,
AsyncStreamSetInfo <T> asyncStreamSetInfo)
{
ThreadPool.QueueUserWorkItem(state => SendHttpRequest(v3Msg, requestHeaders, httpHeaders, responder, asyncStreamSetInfo));
}
internal override void Invoke <T>(string className,
string methodName,
object[] args,
IDictionary requestHeaders,
IDictionary messageHeaders,
IDictionary httpHeaders,
Responder <T> responder,
AsyncStreamSetInfo <T> asyncStreamSetInfo)
{
SendRequest(CreateMessageForInvocation(className, methodName, args, messageHeaders), requestHeaders, httpHeaders, responder, asyncStreamSetInfo);
}
public abstract void SendRequest <T>(V3Message v3Msg, IDictionary requestHeaders, IDictionary httpHeaders, Responder <T> responder, AsyncStreamSetInfo <T> asyncStreamSetInfo);
internal abstract void Invoke <T>(string className, string methodName, object[] args, IDictionary requestHeaders, IDictionary messageHeaders, IDictionary httpHeaders, Responder <T> responder, AsyncStreamSetInfo <T> asyncStreamSetInfo);
internal void Invoke <T>(String className, String methodName, Object[] args, IDictionary requestHeaders, IDictionary messageHeaders, Responder <T> responder, AsyncStreamSetInfo <T> asyncStreamSetInfo)
{
_engine.Invoke(className, methodName, args, requestHeaders, messageHeaders, null, responder, asyncStreamSetInfo);
}
private void SendHttpRequest <T>(V3Message v3Msg, IDictionary requestHeaders, IDictionary httpHeaders, Responder <T> responder, AsyncStreamSetInfo <T> asyncStreamSetInfo)
{
HttpWebRequest webReq;
try
{
webReq = GetWebRequest();
}
catch (Exception e)
{
HandleException(asyncStreamSetInfo, e);
return;
}
if (httpHeaders != null)
{
foreach (DictionaryEntry header in httpHeaders)
{
webReq.Headers[header.Key.ToString()] = header.Value.ToString();
}
}
webReq.CookieContainer = Cookies;
byte[] requestBytes = CreateRequest(v3Msg, requestHeaders);
asyncStreamSetInfo.requestBytes = requestBytes;
asyncStreamSetInfo.request = webReq;
asyncStreamSetInfo.responder = responder;
// Set the ContentType property.
webReq.ContentType = "application/x-amf";
// Set the Method property to 'POST' to post data to the URI.
webReq.Method = "POST";
// Start the asynchronous operation.
try
{
webReq.BeginGetRequestStream(new AsyncCallback(SetStreamDataCallback <T>), asyncStreamSetInfo);
}
catch (Exception e1)
{
HandleException(asyncStreamSetInfo, e1);
}
}
private void SetStreamDataCallback <T>(IAsyncResult asynchronousResult)
{
AsyncStreamSetInfo <T> asyncStreamSetInfo = (AsyncStreamSetInfo <T>)asynchronousResult.AsyncState;
try
{
HttpWebRequest request = asyncStreamSetInfo.request;
// End the operation.
Stream postStream = request.EndGetRequestStream(asynchronousResult);
postStream.Write(asyncStreamSetInfo.requestBytes, 0, asyncStreamSetInfo.requestBytes.Length);
postStream.Flush();
postStream.Close();
asyncStreamSetInfo.messageSentTime = DateTime.Now.Ticks;
request.BeginGetResponse(new AsyncCallback(ProcessAMFResponse <T>), asyncStreamSetInfo);
if (Timeout > 0)
{
Timer timer = new Timer(state =>
{
if (!request.HaveResponse)
{
request.Abort();
}
});
timer.Change(Timeout, System.Threading.Timeout.Infinite);
}
// allDone.Set();
}
catch (Exception exception)
{
String error = exception.Message;
if (exception is WebException && ((WebException)exception).Status == WebExceptionStatus.RequestCanceled)
{
error = TIMEOUT_FAULT_MESSAGE;
}
#if (!UNIVERSALW8 && !FULL_BUILD && !WINDOWS_PHONE && !PURE_CLIENT_LIB && !WINDOWS_PHONE8)
if (exception is SecurityException)
{
if (WeborbClient.Uri.Scheme.ToLower().StartsWith("file"))
{
error = SECURITY_FAULT_MESSAGE;
}
}
if (UiControl != null)
{
UiControl.Dispatcher.BeginInvoke(delegate()
{
HtmlPage.Window.Alert(error);
});
}
#endif
if (asyncStreamSetInfo != null)
{
Fault fault = new Fault(error, exception.StackTrace, INTERNAL_CLIENT_EXCEPTION_FAULT_CODE);
if (asyncStreamSetInfo.responder != null)
{
asyncStreamSetInfo.responder.ErrorHandler(fault);
}
}
}
}
