public override async Task <T> SendRequest <T>(V3Message v3Msg,
IDictionary requestHeaders,
IDictionary httpHeaders,
ResponseThreadConfigurator threadConfigurator)
{
return(await SendHttpRequest <T>(v3Msg, requestHeaders, httpHeaders, threadConfigurator));
}
internal abstract Task <T> Invoke <T>(string className,
string methodName,
object[] args,
IDictionary requestHeaders,
IDictionary messageHeaders,
IDictionary httpHeaders,
ResponseThreadConfigurator threadConfigurator);
internal override async Task <T> Invoke <T>(string className,
string methodName,
object[] args,
IDictionary requestHeaders,
IDictionary messageHeaders,
IDictionary httpHeaders,
ResponseThreadConfigurator threadConfigurator)
{
return(await SendRequest <T>(CreateMessageForInvocation(className, methodName, args, messageHeaders),
requestHeaders,
httpHeaders,
threadConfigurator));
}
public static void InvokeAsync <T>(string className, string methodName, object[] args, bool enableUnderFlowInspection, AsyncCallback <T> callback)
{
var responder = new Responder <T>(response =>
{
if (callback != null)
{
callback.ResponseHandler.Invoke(response);
}
}, fault =>
{
var backendlessFault = new BackendlessFault(fault);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
else
{
throw new BackendlessException(backendlessFault);
}
});
try
{
ResponseThreadConfigurator responseConfig = null;
if (enableUnderFlowInspection)
{
responseConfig = new ResponseThreadConfigurator(SetupUnderFlowListener);
}
client.Invoke <T>(className, methodName, args, null, HeadersManager.GetInstance().Headers, responder, responseConfig);
}
catch (System.Exception ex)
{
var backendlessFault = new BackendlessFault(ex.Message);
if (callback != null)
{
callback.ErrorHandler.Invoke(backendlessFault);
}
throw new BackendlessException(backendlessFault);
}
}
public static T InvokeSync <T>(string className, string methodName, object[] args, bool enableUnderFlowInspection)
{
T result = default(T);
BackendlessFault backendlessFault = null;
AutoResetEvent waiter = new AutoResetEvent(false);
var responder = new Responder <T>(r =>
{
result = r;
waiter.Set();
}, f =>
{
backendlessFault = new BackendlessFault(f);
waiter.Set();
});
try
{
ResponseThreadConfigurator responseConfig = null;
if (enableUnderFlowInspection)
{
responseConfig = new ResponseThreadConfigurator(SetupUnderFlowListener);
}
client.Invoke <T>(className, methodName, args, null, HeadersManager.GetInstance().Headers, responder, responseConfig);
waiter.WaitOne(System.Threading.Timeout.Infinite);
}
catch (System.Exception ex)
{
throw new BackendlessException(ex.Message);
}
if (backendlessFault != null)
{
throw new BackendlessException(backendlessFault);
}
return(result);
}
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);
}
public abstract Task <T> SendRequest <T>(V3Message v3Msg,
IDictionary requestHeaders,
IDictionary httpHeaders,
ResponseThreadConfigurator threadConfigurator);
private async Task <T> SendHttpRequest <T>(V3Message v3Msg, IDictionary requestHeaders, IDictionary httpHeaders,
ResponseThreadConfigurator threadConfigurator)
{
HttpWebRequest webReq;
try
{
webReq = GetWebRequest();
}
catch (Exception e)
{
throw new WebORBException(GetFault(e));
}
if (httpHeaders != null)
{
foreach (DictionaryEntry header in httpHeaders)
{
webReq.Headers[header.Key.ToString()] = header.Value.ToString();
}
}
webReq.CookieContainer = Cookies;
byte[] requestBytes = CreateRequest(v3Msg, requestHeaders);
// 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.
Stream postStream = await webReq.GetRequestStreamAsync();
try
{
// End the operation.
postStream.Write(requestBytes, 0, requestBytes.Length);
postStream.Flush();
postStream.Close();
HttpWebResponse response = (HttpWebResponse)await webReq.GetResponseAsync();
threadConfigurator?.Invoke();
if (Cookies != null)
{
foreach (Cookie cookie in response.Cookies)
{
Cookies.Add(new Uri(GatewayUrl), cookie);
}
}
var streamResponse = response.GetResponseStream();
var parser = new RequestParser();
var responseObject = parser.readMessage(streamResponse);
var responseData = (object[])responseObject.getRequestBodyData();
var v3 = (V3Message)((IAdaptingType)responseData[0]).defaultAdapt();
if (v3.isError)
{
var errorMessage = (ErrMessage)v3;
var fault = new Fault(errorMessage.faultString, errorMessage.faultDetail, errorMessage.faultCode);
throw new WebORBException(fault);
}
var body =
(IAdaptingType)((AnonymousObject)((NamedObject)responseData[0]).TypedObject).Properties["body"];
var result = (T)body.adapt(typeof(T));
return(result);
}
catch (Exception exception)
{
if (exception is WebORBException)
{
throw exception;
}
throw new WebORBException(GetFault(exception));
}
}
public async Task <T> Invoke <T>(String className, String methodName, Object[] args, IDictionary httpRequestHeaders, IDictionary messageHeaders, ResponseThreadConfigurator responseThreadConfigurator)
{
return(await _engine.Invoke <T>(className, methodName, args, null, messageHeaders, httpRequestHeaders, responseThreadConfigurator));
}
