///<summary>
///Sends a single message synchronously, blocking until the send is complete. Does not wait for
///a response.
///<c>
///NOTE: the underlying transport may be non-blocking, in which case the blocking is simulated
///by waits instead of using blocking network operations.
///</c>
///</summary>
///<exception cref="Thrift.TException">
///if a network or protocol error occurs while serializing or sending the request
///</exception>
public static void SendSynchronousOneWayMessage(this IRequestChannel channel, IByteBuffer request)
{
TException exceptionHolder = null;
request.Retain();
using (ManualResetEventSlim latch = new ManualResetEventSlim(false))
{
channel.SendAsynchronousRequest(request, true, new RequestListener(
onRequestSent: reqs =>
{
reqs?.Release();
latch.Set();
},
//onResponseReceive: response =>
//{
// communicatingComplete?.Invoke();
// latch.Set();
//},
onChannelError: e =>
{
exceptionHolder = e;
latch.Set();
}));
if (!latch.Wait(TimeSpan.FromMinutes(10)))
{
throw new TException("wait for one-way request sent timeout.");
}
}
if (exceptionHolder != null)
{
throw exceptionHolder;
}
}
public override void OnError(Exception error)
{
TException e = error as TException;
if (e != null)
{
IObservable <T> next;
try
{
if (parent.errorHandler == Stubs.CatchIgnore <T> )
{
next = Observable.Empty <T>(); // for avoid iOS AOT
}
else
{
next = parent.errorHandler(e);
}
}
catch (Exception ex)
{
try { observer.OnError(ex); } finally { Dispose(); };
return;
}
exceptionSubscription.Disposable = next.Subscribe(observer);
}
else
{
try { observer.OnError(error); } finally { Dispose(); };
return;
}
}
/// <summary>
/// Takes a TNumber and returns its absolute value.
/// </summary>
/// <param name="interpreter">The interpreter that the method is being called from.</param>
/// <param name="value">The TNumber to get the absolute value of.</param>
/// <returns>
/// The TType resulting from the operation. An MExcpetion or null is returned when there is an error.
/// </returns>
public static TType Modulus(Interpreter interpreter, TType value)
{
TNumber number;
TException exception = AssignNumberValue(interpreter, out number, value);
if (exception != null)
{
return(exception);
}
// No errors yet, but make sure it's not a string
if (number == null)
{
return(new TException(interpreter, "Strings cannot be used in modulus operations"));
}
switch (number.TypeName)
{
case TType.T_INTEGER_TYPENAME:
return(new TInteger(System.Math.Abs(number.TIntegerValue)));
case TType.T_REAL_TYPENAME:
return(new TReal(System.Math.Abs(number.TRealValue)));
case TType.T_FRACTION_TYPENAME:
TFraction fraction = number as TFraction;
return(new TFraction(System.Math.Abs(fraction.Numerator), fraction.Denominator));
// No need to abs denominator as TFraction denominators are automatically kept positive
}
return(null);
}
/// <summary>
/// Throw an exception of the given type when called.
/// </summary>
public TException Throw <TException>() where TException : Exception, new()
{
var exception = new TException();
Do(ci =>
{
throw exception;
});
return(exception);
}
private void TryHandler(TException exception)
{
try
{
var result = this.handler(exception);
result.Subscribe(new HandlerObserver(this));
}
catch (Exception e)
{
base.OnError(e);
}
}
private void FireChannelErrorCallback(IListener listener, TException exception)
{
try
{
listener.OnChannelError(exception);
}
catch (Exception t)
{
_logger.LogWarning(default(EventId), t, "Channel error listener callback triggered an exception");
t.ThrowIfNecessary();
}
}
/// <summary>
/// Throw exception of the given type when
/// the method is called
/// </summary>
/// <typeparam name="TException"></typeparam>
/// <returns>Fluid Interface</returns>
IMethodOptions IMethodOptions.Throws <TException>()
{
if (ThrowsException)
{
throw new InvalidOperationException(
"Can set only a single exception to throw on the same method call.");
}
ThrowsException = true;
ExceptionToThrow = new TException();
return(this);
}
public bool Handle(Exception exception)
{
bool handled = false;
TException e = exception as TException;
if (e != null)
{
handled = this.handler(this.state, e);
}
return(handled);
}
public static void HandleTException(Context ctx, TException ex)
{
var errMsg = AppCommon.Inst.ErrorTranslator.GetErrMessage(ex);
if (errMsg != null)
{
Utils.Alert(ctx, errMsg.Item1, errMsg.Item2, false);
}
else
{
AppCommon.Inst.Log.Error(ex.ToString());
}
}
/// <summary>
/// Compares one TNumber with another based on a given inequality operator.
/// </summary>
/// <param name="interpreter">The interpreter that the method is being called from.</param>
/// <param name="a">The left hand operand of the comparison.</param>
/// <param name="b">The right hand operand of the comparison.</param>
/// <param name="inequality">The inequality operator to use in the comparison.</param>
/// <returns>
/// An TBoolean containing the result of the comparison. Returns a TException when there is an error.
/// </returns>
public static TType Inequality(Interpreter interpreter, TType a, TType b, string inequality)
{
// Try to get TNumber values from the TType arguments
TNumber numberA, numberB;
TException exception = AssignNumberValue(interpreter, out numberA, a);
if (exception != null)
{
return(exception);
}
exception = AssignNumberValue(interpreter, out numberB, b);
if (exception != null)
{
return(exception);
}
// No errors, but one or both of the arguments could be a TString; check them
if ((numberA == null) || (numberB == null))
{
return(new TException(interpreter, "Strings cannot be used in inequality comparisons"));
}
bool result;
switch (inequality)
{
case ">":
result = numberA.TRealValue > numberB.TRealValue;
break;
case ">=":
result = numberA.TRealValue >= numberB.TRealValue;
break;
case "<":
result = numberA.TRealValue < numberB.TRealValue;
break;
case "<=":
result = numberA.TRealValue <= numberB.TRealValue;
break;
default:
return(new TException(interpreter, "Invalid inequality operator given"));
}
return(new TBoolean(result));
}
private void TestException <TException>()
where TException : Exception, new()
{
Assert.IsNotNull(Activator.CreateInstance(typeof(TException), new object[] { "message" }));
Assert.IsNotNull(Activator.CreateInstance(typeof(TException), new object[] { "message", new Exception("inner") }));
var ex = new TException();
using (var stream = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(stream, ex);
stream.Seek(0, SeekOrigin.Begin);
formatter.Deserialize(stream);
}
}
public override void OnError(Exception error)
{
TException ex = error as TException;
if (ex != null)
{
IObservable <T> observable;
try
{
Delegate errorHandler = this.parent.errorHandler;
if (CatchObservable <T, TException> .Catch.< > f__mg$cache0 == null)
{
CatchObservable <T, TException> .Catch.< > f__mg$cache0 = new Func <TException, IObservable <T> >(Stubs.CatchIgnore <T>);
}
if (errorHandler == CatchObservable <T, TException> .Catch.< > f__mg$cache0)
{
observable = Observable.Empty <T>();
}
else
{
observable = this.parent.errorHandler(ex);
}
}
catch (Exception error2)
{
try
{
this.observer.OnError(error2);
}
finally
{
base.Dispose();
}
return;
}
this.exceptionSubscription.Disposable = observable.Subscribe(this.observer);
return;
}
try
{
this.observer.OnError(error);
}
finally
{
base.Dispose();
}
}
public static Func <T, string, TException> Combine <T, TException>(params Func <T, string, TException>[] guards)
where TException : ArgumentException
{
return((paramValue, paramName) =>
{
TException ex = null;
foreach (var guard in guards)
{
ex = guard(paramValue, paramName);
if (ex != null)
{
break;
}
}
return ex;
});
}
/// <summary>
/// Takes two TNumbers and returns the first one to the power of the other.
/// </summary>
/// <param name="interpreter">The interpreter that the method is being called from.</param>
/// <param name="a">The left hand operand of the operation.</param>
/// <param name="b">The right hand operand of the operation.</param>
/// <returns>
/// The TType resulting from the operation. An MExcpetion or null is returned when there is an error.
/// </returns>
public static TType Pow(Interpreter interpreter, TType a, TType b)
{
// Try to get TNumber values from the TType arguments
TNumber numberA, numberB;
TException exception = AssignNumberValue(interpreter, out numberA, a);
if (exception != null)
{
return(exception);
}
exception = AssignNumberValue(interpreter, out numberB, b);
if (exception != null)
{
return(exception);
}
// No errors, but one or both of the arguments could be a TString; check them
if ((numberA == null) || (numberB == null))
{
return(new TException(interpreter, "Strings cannot be used in exponentiation operations"));
}
switch (numberA.TypeName)
{
case TType.T_INTEGER_TYPENAME:
return(new TInteger(
(long)System.Math.Round(System.Math.Pow(numberA.TRealValue, numberB.TRealValue))));
case TType.T_REAL_TYPENAME:
return(new TReal(System.Math.Pow(numberA.TRealValue, numberB.TRealValue)));
case TType.T_FRACTION_TYPENAME:
TFraction fraction = numberA as TFraction;
long numerator =
(long)System.Math.Round(System.Math.Pow(fraction.Numerator, numberB.TRealValue));
long denominator =
(long)System.Math.Round(System.Math.Pow(fraction.Denominator, numberB.TRealValue));
return(new TFraction(numerator, denominator));
}
return(null);
}
public override Tuple <string, string> GetErrMessage(TException ex)
{
var se = ex as ServerError;
if (se == null)
{
return(Tuple.Create("No Internet Connectivity", "Please ensure Wifi/data network is enabled and reachable"));
}
switch (se.Err)
{
case ErrorCode.InvalidArg:
return(Tuple.Create("Invalid Input", "Please check and enter valid entries"));
case ErrorCode.UserNotFound:
return(Tuple.Create("Please Register", "User not registered. Please sign up."));
default:
return(null);
}
}
/// <summary>
/// 设置仅重试哪些类型的异常。
/// 允许多次调用（以OR方式处理）。
/// </summary>
/// <typeparam name="TException"></typeparam>
/// <returns></returns>
public Retry Filter <TException>() where TException : Exception
{
if (_filterList == null)
{
_filterList = new List <Func <Exception, bool> >();
}
_filterList.Add(
(Exception ex) => {
TException tex = ex as TException;
if (tex == null)
{
return(false);
}
return(true);
});
return(this);
}
public override void OnError(Exception error)
{
TException val = error as TException;
if (val != null)
{
UniRx.IObservable <T> observable;
try
{
observable = ((!(parent.errorHandler == new Func <TException, UniRx.IObservable <T> >(Stubs.CatchIgnore <T>))) ? parent.errorHandler(val) : Observable.Empty <T>());
}
catch (Exception error2)
{
try
{
observer.OnError(error2);
}
finally
{
Dispose();
}
return;
}
SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable();
serialDisposable.Disposable = singleAssignmentDisposable;
singleAssignmentDisposable.Disposable = observable.Subscribe(observer);
}
else
{
try
{
observer.OnError(error);
}
finally
{
Dispose();
}
}
}
protected void OnError(Exception t)
{
_invoked = int.MinValue;
TException wrappedException = WrapException(t);
if (_channelError == null)
{
_channelError = wrappedException;
}
CancelAllTimeouts();
List <Request> requests = new List <Request>();
var all = this.GetAllRequests();
requests.AddRange(all);
_readerWriterLock.EnterWriteLock();
try
{
_requestMap.Clear();
}
finally
{
_readerWriterLock.ExitWriteLock();
}
foreach (Request request in requests)
{
FireChannelErrorCallback(request.Listener, wrappedException);
}
IChannel channel = this.NettyChannel;
if (channel.Open)
{
channel.CloseAsync();
}
}
///<summary>
///Sends a single message synchronously, and blocks until the responses is received.
///</summary>
///<remarks>
///NOTE: the underlying transport may be non-blocking, in which case the blocking is simulated
///by waits instead of using blocking network operations.
///</remarks>
///<returns>The response, stored in a <see cref="IByteBuffer"/></returns>
///<exception cref="Thrift.TException">
/// if an error occurs while serializing or sending the request or while receiving or de-serializing the response
/// </exception>
public static IByteBuffer SendSynchronousTwoWayMessage(this IRequestChannel channel, IByteBuffer request)
{
request?.Retain();
IByteBuffer responseHolder = null;
TException exceptionHolder = null;
using (ManualResetEventSlim latch = new ManualResetEventSlim(false))
{
channel.SendAsynchronousRequest(request, false, new RequestListener(
onRequestSent: reqs => {
reqs?.Release();
},
onResponseReceive: response =>
{
responseHolder = response;
latch.Set();
},
onChannelError: e =>
{
exceptionHolder = e;
latch.Set();
}
));
if (!latch.Wait(TimeSpan.FromMinutes(10)))
{
throw new TException("wait for response/error timeout.");
}
}
if (exceptionHolder != null)
{
throw exceptionHolder;
}
return(responseHolder);
}
public static void TestSerializationCtor <TException>()
where TException : Exception, new()
{
var original = new TException();
var msg = "Some Message";
typeof(Exception).GetField("_message",
BindingFlags.NonPublic | BindingFlags.Instance)
.SetValue(original, msg);
using (var ms = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(ms, original);
ms.Seek(0, SeekOrigin.Begin);
var deserialized = (TException)formatter.Deserialize(ms);
deserialized.Message.Should().Be(msg);
deserialized.ShouldBeEquivalentTo(original);
}
}
public abstract Tuple <string, string> GetErrMessage(TException ex);
public void OnChannelError(TException requestException)
{
_excecption = requestException;
}
/// <summary>
/// Throw exception of the given type when the property is called
/// </summary>
/// <typeparam name="TException"></typeparam>
/// <returns>Fluid Interface</returns>
IPropertyOptions <T> IPropertyOptions <T> .Throws <TException>()
{
ThrowsException = true;
ExceptionToThrow = new TException();
return(this);
}
public void OnChannelError(TException var1)
{
_onChannelError?.Invoke(var1);
}
/// <summary>
/// Takes two TNumbers and divides one by the other.
/// </summary>
/// <param name="interpreter">The interpreter that the method is being called from.</param>
/// <param name="a">The left hand operand of the operation.</param>
/// <param name="b">The right hand operand of the operation.</param>
/// <returns>
/// The TType resulting from the operation. An MExcpetion or null is returned when there is an error.
/// </returns>
public static TType Divide(Interpreter interpreter, TType a, TType b)
{
// Try to get TNumber values from the TType arguments
TNumber numberA, numberB;
TException exception = AssignNumberValue(interpreter, out numberA, a);
if (exception != null)
{
return(exception);
}
exception = AssignNumberValue(interpreter, out numberB, b);
if (exception != null)
{
return(exception);
}
// No errors, but one or both of the arguments could be a TString; check them
if ((numberA == null) || (numberB == null))
{
return(new TException(interpreter, "Strings cannot be used in division operations"));
}
switch (numberA.TypeName)
{
case TType.T_INTEGER_TYPENAME:
{
// If the other operand is a fraction, treat this integer as a fraction (i.e. value/1)
TFraction rhsFraction = numberB as TFraction;
if (rhsFraction != null)
{
// Order of fractions matters in this case
TFraction lhsFraction = new TFraction(numberA.TIntegerValue, 1);
lhsFraction.Divide(rhsFraction.Numerator, rhsFraction.Denominator);
return(lhsFraction);
}
if (numberB.TypeName == TType.T_INTEGER_TYPENAME)
{
return(new TFraction(numberA.TIntegerValue, numberB.TIntegerValue));
}
return(new TInteger(numberA.TIntegerValue / numberB.TIntegerValue));
}
case TType.T_REAL_TYPENAME:
return(new TReal(numberA.TRealValue / numberB.TRealValue));
case TType.T_FRACTION_TYPENAME:
{
// Create a copy of the left hand fraction
TFraction fraction = numberA as TFraction;
fraction = new TFraction(fraction.Numerator, fraction.Denominator);
// Convert the right hand operand to a fraction
long numerator, denominator;
TFraction otherFraction = numberB as TFraction;
if (otherFraction != null) // If it's a fraction, simply copy the values
{
numerator = otherFraction.Numerator;
denominator = otherFraction.Denominator;
}
else
{
// Check if it's a TInteger first. It might not need to use DoubleToFraction
if (numberB is TInteger)
{
numerator = numberB.TIntegerValue;
denominator = 1;
}
else
{
Operations.Misc.DoubleToFraction(numberB.TRealValue, out numerator,
out denominator);
}
}
fraction.Divide(numerator, denominator);
return(fraction);
}
}
return(null);
}
/// <summary>
/// Throw exception of the given type when
/// the method is called
/// </summary>
/// <typeparam name="TException"></typeparam>
/// <returns>Fluid Interface</returns>
IEventOptions IEventOptions.Throws <TException>()
{
ThrowsException = true;
ExceptionToThrow = new TException();
return(this);
}
/// <summary>
/// Takes two TNumbers or two TStrings (or up to two TVariables containing TNumbers or TStrings) and
/// adds them together.
/// </summary>
/// <param name="interpreter">The interpreter that the method is being called from.</param>
/// <param name="a">The left hand operand of the operation.</param>
/// <param name="b">The right hand operand of the operation.</param>
/// <returns>
/// The TType resulting from the operation. An MExcpetion or null is returned when there is an error.
/// </returns>
public static TType Add(Interpreter interpreter, TType a, TType b)
{
// Convert arguments 'a' and 'b' into either a TNumber or a TString
TNumber numberA, numberB;
TString strA = null, strB = null;
TException exception = AssignNumberValue(interpreter, out numberA, a);
if (exception != null)
{
return(exception);
}
if (numberA == null)
{
// No errors yet, and numberA is null, so argument 'a' could be a TString or a TVariable
// containing a TString
strA = a as TString;
if (strA == null)
{
TVariable variable = a as TVariable;
if (variable != null)
{
strA = variable.Value as TString;
}
}
}
if ((numberA == null) && (strA == null)) // Nothing useful, return a TException
{
return(new TException(interpreter, "Value is not a number or string"));
}
// Same procedure for argument 'b'
exception = AssignNumberValue(interpreter, out numberB, b);
if (exception != null)
{
return(exception);
}
if (numberB == null)
{
strB = b as TString;
if (strB == null)
{
TVariable variable = b as TVariable;
if (variable != null)
{
strB = variable.Value as TString;
}
}
}
if ((numberB == null) && (strB == null))
{
return(new TException(interpreter, "Value is not a number or string"));
}
// Attempt addition if both operands are the same type, otherwise return a TException
if ((numberB == null) && (strA == null))
{
return(new TException(interpreter, "Attempted addition of a string to a number"));
}
else if ((numberA == null) && (strB == null))
{
return(new TException(interpreter, "Attempted addition of a number to a string"));
}
else if ((numberA == null) && (numberB == null))
{
return(new TString(strA.Value + strB.Value));
}
else
{
//The left hand operand decides the type of the returned value
switch (numberA.TypeName)
{
case TType.T_INTEGER_TYPENAME:
{
// If the other operand is a fraction, treat this integer as a fraction (i.e. value/1)
TFraction fraction = numberB as TFraction;
if (fraction != null)
{
// Copy the right hand fraction and add the left hand integer to it
fraction = new TFraction(fraction.Numerator, fraction.Denominator);
fraction.Add(numberA.TIntegerValue, 1);
return(fraction);
}
return(new TInteger(numberA.TIntegerValue + numberB.TIntegerValue));
}
case TType.T_REAL_TYPENAME:
return(new TReal(numberA.TRealValue + numberB.TRealValue));
case TType.T_FRACTION_TYPENAME:
{
// Create a copy of the left hand fraction
TFraction fraction = numberA as TFraction;
fraction = new TFraction(fraction.Numerator, fraction.Denominator);
// Convert the right hand operand to a fraction
long numerator, denominator;
TFraction otherFraction = numberB as TFraction;
if (otherFraction != null) // If it's a fraction, simply copy the values
{
numerator = otherFraction.Numerator;
denominator = otherFraction.Denominator;
}
else
{
// Check if it's a TInteger first. It might not need to use DoubleToFraction
if (numberB is TInteger)
{
numerator = numberB.TIntegerValue;
denominator = 1;
}
else
{
Operations.Misc.DoubleToFraction(numberB.TRealValue, out numerator,
out denominator);
}
}
fraction.Add(numerator, denominator);
return(fraction);
}
}
}
return(null);
}
