public static void Until(Func<CancellationToken, Task<bool>> taskFactory, TimeSpan sleepDuration, TimeSpan timeOut, string exceptionMessage = "", params object[] items)
{
ExceptionState lastExceptionState = new ExceptionState();
using (CancellationTokenSource tokenSource = new CancellationTokenSource(timeOut))
using (Task task = UntilAsync(taskFactory, tokenSource.Token, lastExceptionState, sleepDuration, timeOut, exceptionMessage, items))
{
if (task.Wait(timeOut))
{
return;
}
tokenSource.Cancel();
task.Wait(timeOut);
}
string lastMessage = "None found";
if (lastExceptionState.LastException != null)
{
lastMessage = lastExceptionState.LastException.Message;
}
throw new TimeoutException(string.Format("{0} Timed out after {1} seconds. Last exception: {2}", String.Format(exceptionMessage, items), timeOut.TotalSeconds, lastMessage), lastExceptionState.LastException);
}
public Category(string name, string displayName, string shortDisplayName, ExceptionState state)
{
Name = name;
DisplayName = displayName;
ShortDisplayName = shortDisplayName;
State = state;
}
public ToolboxException(ExceptionState state, params object[] arguments)
{
var converter = new EnumToResouceConverter();
Arguments = arguments;
_friendlyMessage = string.Format((string)converter.Convert(state, typeof(string), null, CultureInfo.CurrentUICulture), Arguments);
}
public void UpdateExceptionInfo(Exception clrException, object type, object value, List <DynamicStackFrame> traceback)
{
lock (this) {
_exceptionState = new ExceptionState(clrException, type, value, traceback);
_setValues = _removedValues = 0;
}
}
private bool TryGetExcValue(ExceptionState exState, string strKey, out object value)
{
switch (strKey)
{
case "exc_type":
lock (this) {
if ((_removedValues & ExceptionStateFlags.Type) == 0)
{
if ((_setValues & ExceptionStateFlags.Type) != 0)
{
value = _excType;
}
else
{
value = exState.Type;
}
return(true);
}
}
break;
case "exc_value":
lock (this) {
if ((_removedValues & ExceptionStateFlags.Value) == 0)
{
if ((_setValues & ExceptionStateFlags.Value) != 0)
{
value = _excValue;
}
else
{
value = exState.Value;
}
return(true);
}
}
break;
case "exc_traceback":
lock (this) {
if ((_removedValues & ExceptionStateFlags.Traceback) == 0)
{
if ((_setValues & ExceptionStateFlags.Traceback) != 0)
{
value = _excTraceback;
}
else
{
_excTraceback = CreateTraceBack(exState);
_setValues |= ExceptionStateFlags.Traceback;
value = _excTraceback;
}
return(true);
}
}
break;
}
value = null;
return(false);
}
public void UpdateExceptionInfo(object type, object value, object traceback)
{
lock (this) {
_exceptionState = new ExceptionState(null, type, value, null);
_excTraceback = traceback;
_setValues = ExceptionStateFlags.Traceback;
_removedValues = 0;
}
}
public void ExceptionHandled()
{
lock (this) {
_setValues = ExceptionStateFlags.Traceback | ExceptionStateFlags.Type | ExceptionStateFlags.Value;
_removedValues = 0;
_exceptionState = null;
_excTraceback = _excType = _excValue = null;
}
}
/// <summary>
/// Creates a new ImportException
/// </summary>
/// <param name="msg">exception message</param>
/// <param name="fatal">true if the exception is fatal</param>
public ImportException(string msg, bool fatal = false)
: base(msg)
{
// Create exception state
this.state = new ExceptionState(fatal);
// Add serialization method
this.SerializeObjectState +=
(ex, args) => args.AddSerializedState(state);
}
public override void Clear(ref DictionaryStorage storage)
{
lock (this) {
_exceptionState = null;
_setValues = 0;
_removedValues = 0;
_excTraceback = _excType = _excValue = null;
base.Clear(ref storage);
}
}
static void AppendFlags(StringBuilder sb, ExceptionState state, ExceptionState flag, string flagName, bool expValue = true)
{
if (((state & flag) != 0) != expValue)
{
return;
}
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append(flagName);
}
/// <summary>
/// Intercepts the specified invocation.
/// </summary>
/// <param name="invocation">The invocation.</param>
public virtual void Intercept(IInvocation invocation)
{
if (Condition != null && !Condition(invocation))
{
invocation.Proceed();
return;
}
try
{
if (Before != null)
{
Before(invocation);
}
Action <IInvocation> proceed = Proceed ?? (call => call.Proceed());
proceed(invocation);
if (After != null)
{
After(invocation);
}
}
catch (Exception error)
{
Func <IInvocation, Exception, ExceptionState> errorHandler = OnError
?? ((thisCall, thisBug) => new ExceptionState(thisBug, false));
ExceptionState state = errorHandler(invocation, error);
if (state.IsHandled)
{
return;
}
if (!ReferenceEquals(error, state.Exception) && state.Exception != null)
{
throw state.Exception;
}
throw;
}
finally
{
if (Finally != null)
{
Finally(invocation);
}
}
}
public override bool TryGetValue(object key, out object value)
{
ExceptionState exState = _exceptionState;
// check the strKey only if we have some exception info set
if (exState != null || _setValues != 0)
{
if (key is string strKey && TryGetExcValue(exState, strKey, out value))
{
return(true);
}
}
return(base.TryGetValue(key, out value));
}
private void UpdateExceptionState()
{
if (exceptionList.Count > 0)
{
foreach (ExceptionState exceptionState in exceptionList)
{
//Debug.Log("exceptionState " + exceptionState.name + " - " + exceptionState.state);
SetBool(exceptionState.name, exceptionState.state);
}
}
while (exceptionOnceQueue.Count > 0)
{
ExceptionState exceptionState = exceptionOnceQueue.Dequeue();
SetBool(exceptionState.name, exceptionState.state);
}
}
internal void EndExceptionBlock()
{
_ilg.EndExceptionBlock();
ExceptionState state = _exceptionState.Pop();
if (state == ExceptionState.Catch)
{
AdvanceOffsetWithLabel(OpCodes.Leave);
}
else if (state == ExceptionState.Finally || state == ExceptionState.Fault)
{
AdvanceOffset(OpCodes.Endfinally);
}
AssertOffsetMatches();
}
internal void BeginFinallyBlock()
{
_ilg.BeginFinallyBlock();
ExceptionState state = _exceptionState.Pop();
if (state != ExceptionState.Try)
{
// leave for any preceeding catch clause
AdvanceOffsetWithLabel(OpCodes.Leave);
}
// leave for try clause
AdvanceOffsetWithLabel(OpCodes.Leave);
_exceptionState.Push(ExceptionState.Finally);
AssertOffsetMatches();
}
internal static StreamChatException FromResponse(RestResponse response)
{
ExceptionState state = null;
if (!string.IsNullOrWhiteSpace(response.Content))
{
state = JsonConvert.DeserializeObject <ExceptionState>(response.Content);
state.HttpStatusCode = (int)response.StatusCode;
}
if (state == null)
{
state = new ExceptionState()
{
Code = null, Message = response.ErrorMessage, HttpStatusCode = (int)response.StatusCode
};
}
throw new StreamChatException(state);
}
internal void BeginCatchBlock(Type exceptionType)
{
_ilg.BeginCatchBlock(exceptionType);
ExceptionState state = _exceptionState.Pop();
if (state == ExceptionState.Filter)
{
AdvanceOffset(OpCodes.Endfilter);
}
else
{
AdvanceOffsetWithLabel(OpCodes.Leave);
}
_exceptionState.Push(ExceptionState.Catch);
AssertOffsetMatches();
}
public override bool Remove(ref DictionaryStorage storage, object key)
{
// check the strKey only if we have some exception info set
ExceptionState exState = _exceptionState;
if (exState != null || _setValues != 0)
{
string strKey = key as string;
if (strKey != null)
{
switch (strKey)
{
case "exc_type":
lock (this) {
_excType = null;
_setValues &= ~ExceptionStateFlags.Type;
_removedValues |= ExceptionStateFlags.Type;
}
break;
case "exc_value":
lock (this) {
_excValue = null;
_setValues &= ~ExceptionStateFlags.Value;
_removedValues |= ExceptionStateFlags.Value;
}
break;
case "exc_traceback":
lock (this) {
_excTraceback = null;
_setValues &= ~ExceptionStateFlags.Traceback;
_removedValues |= ExceptionStateFlags.Traceback;
}
break;
}
}
}
return(base.Remove(ref storage, key));
}
internal static StreamException FromResponse(RestResponse response)
{
//If we get an error response from getstream.io with the following structure then use it to populate the exception details,
//otherwise fill in the properties from the response, the most likely case being when we get a timeout.
//{"code": 6, "detail": "The following feeds are not configured: 'secret'", "duration": "4ms", "exception": "FeedConfigException", "status_code": 400}
ExceptionState state = null;
if (!string.IsNullOrWhiteSpace(response.Content))
{
state = JsonConvert.DeserializeObject <ExceptionState>(response.Content);
}
if (state == null)
{
state = new ExceptionState()
{
Code = null, Detail = response.ErrorMessage, @Exception = response.ErrorException.ToString(), HttpStatusCode = (int)response.StatusCode
};
}
throw new StreamException(state);
}
// Token: 0x0600011E RID: 286 RVA: 0x00005460 File Offset: 0x00003660
public int SetException(EXCEPTION_INFO[] pException)
{
if (pException[0].guidType != Guids.guidLanguageCSharp)
{
return(1);
}
ExceptionState exceptionState = ExceptionState.None;
if ((pException[0].dwState & enum_EXCEPTION_STATE.EXCEPTION_STOP_FIRST_CHANCE) != 0 || (pException[0].dwState & enum_EXCEPTION_STATE.EXCEPTION_STOP_USER_FIRST_CHANCE) != 0)
{
exceptionState |= ExceptionState.StopWhenThrown;
}
if ((pException[0].dwState & enum_EXCEPTION_STATE.EXCEPTION_STOP_SECOND_CHANCE) != 0 || (pException[0].dwState & enum_EXCEPTION_STATE.EXCEPTION_STOP_USER_UNCAUGHT) != 0)
{
exceptionState |= ExceptionState.StopIfUnhandled;
}
ExceptionInfo exception = new ExceptionInfo(pException[0].bstrExceptionName, exceptionState);
this.SetException(exception);
return(0);
}
public EXCEPTION_INFO(string name, uint code, ExceptionState state) {
this.Name = name;
this.Code = code;
this.State = state;
}
public ExceptionInfo(string name, int code, ExceptionState state)
{
Name = name;
Code = code;
State = state;
}
internal StreamException(ExceptionState state)
: base(message: state.Detail)
{
}
public ToolboxException(ExceptionState state, params string[] arguments)
{
var converter = new EnumToResouceConverter();
Arguments = arguments;
_friendlyMessage = string.Format((string)converter.Convert(state, typeof(string), null, CultureInfo.CurrentUICulture), Arguments);
}
internal StreamException(ExceptionState state)
: base(message: state.Detail)
{
}
public void UpdateExceptionInfo(Exception clrException, object type, object value, List<DynamicStackFrame> traceback) {
lock (this) {
_exceptionState = new ExceptionState(clrException, type, value, traceback);
_setValues = _removedValues = 0;
}
}
// Token: 0x0600012F RID: 303 RVA: 0x00005679 File Offset: 0x00003879
public ExceptionInfo(string name, ExceptionState state)
{
this.Name = name;
this.State = state;
}
public void UpdateExceptionInfo(object type, object value, object traceback) {
lock (this) {
_exceptionState = new ExceptionState(null, type, value, null);
_excTraceback = traceback;
_setValues = ExceptionStateFlags.Traceback;
_removedValues = 0;
}
}
private bool TryGetExcValue(ExceptionState exState, string strKey, out object value) {
switch (strKey) {
case "exc_type":
lock (this) {
if ((_removedValues & ExceptionStateFlags.Type) == 0) {
if ((_setValues & ExceptionStateFlags.Type) != 0) {
value = _excType;
} else {
value = exState.Type;
}
return true;
}
}
break;
case "exc_value":
lock (this) {
if ((_removedValues & ExceptionStateFlags.Value) == 0) {
if ((_setValues & ExceptionStateFlags.Value) != 0) {
value = _excValue;
} else {
value = exState.Value;
}
return true;
}
}
break;
case "exc_traceback":
lock (this) {
if ((_removedValues & ExceptionStateFlags.Traceback) == 0) {
if ((_setValues & ExceptionStateFlags.Traceback) != 0) {
value = _excTraceback;
} else {
_excTraceback = CreateTraceBack(exState);
_setValues |= ExceptionStateFlags.Traceback;
value = _excTraceback;
}
return true;
}
}
break;
}
value = null;
return false;
}
private static object CreateTraceBack(ExceptionState list)
{
return(PythonOps.CreateTraceBack(list.ClrException, list.Traceback, null, list.FrameCount));
}
private static object CreateTraceBack(ExceptionState list) {
return PythonOps.CreateTraceBack(list.ClrException, list.Traceback, list.FrameCount);
}
public void ExceptionHandled() {
lock (this) {
_setValues = ExceptionStateFlags.Traceback | ExceptionStateFlags.Type | ExceptionStateFlags.Value;
_removedValues = 0;
_exceptionState = null;
_excTraceback = _excType = _excValue = null;
}
}
public EXCEPTION_INFO(string name, uint code, ExceptionState state) {
Name = name;
Code = code;
State = state;
}
public static async Task UntilAsync(Func<CancellationToken, Task<bool>> taskFactory, CancellationToken token, TimeSpan sleepDuration, TimeSpan timeOut, string exceptionMessage = null, params object[] items)
{
ExceptionState state = new ExceptionState();
await UntilAsync(taskFactory, token, state, sleepDuration, timeOut, exceptionMessage, items);
if (state.LastException != null)
{
throw new TimeoutException(string.Format("{0} Timed out after {1} seconds. Last exception: {2}", String.Format(exceptionMessage, items), timeOut.TotalSeconds, state.LastException.Message), state.LastException);
}
}
internal StreamChatException(ExceptionState state)
: base(message: state.Message)
{
this.Code = state.Code;
}
public override void Clear(ref DictionaryStorage storage) {
lock (this) {
_exceptionState = null;
_setValues = 0;
_removedValues = 0;
_excTraceback = _excType = _excValue = null;
base.Clear(ref storage);
}
}
private static async Task UntilAsync(Func<CancellationToken, Task<bool>> taskFactory, CancellationToken token, ExceptionState lastExceptionState, TimeSpan sleepDuration, TimeSpan timeOut, string exceptionMessage, params object[] items)
{
while (!token.IsCancellationRequested)
{
try
{
using (Task<bool> task = taskFactory(token))
{
bool result = await task;
if (result)
{
return;
}
}
}
catch (Exception e)
{
lastExceptionState.LastException = e;
}
if (sleepDuration != TimeSpan.Zero)
{
await Task.Delay(sleepDuration, token);
}
}
}
internal StreamChatException(ExceptionState state)
: base(message: state.Message)
{
}