public static byte[] SerializeRuleToBuffer(FaultRule rule) { BinaryFormatter formatter = new BinaryFormatter(); using (MemoryStream stream = new MemoryStream()) { formatter.Serialize(stream, rule); return(stream.GetBuffer()); } }
public static FaultRule[] Load() { // Using FaultScope FaultScope currentFaultScope = FaultScope.Current; // save in case it changes on another thread if (currentFaultScope != null) { return(currentFaultScope.FaultRules); } // Using FaultSession / serialization file if (string.IsNullOrEmpty(serializationFileName)) { return(null); } lock (initializeLock) { if (fileReadWriteMutex == null) { fileReadWriteMutex = new Mutex(false, Path.GetFileName(serializationFileName)); currentRules = Serializer.DeserializeRules(serializationFileName, fileReadWriteMutex); return(currentRules); } } FaultRule[] swapBuffer; lock (accessCurrentRuleLock) { swapBuffer = new FaultRule[currentRules.Length]; currentRules.CopyTo(swapBuffer, 0); } FaultRule[] loadedRules = Serializer.DeserializeRules(serializationFileName, fileReadWriteMutex); MergeRuleArray(swapBuffer, loadedRules); lock (accessCurrentRuleLock) { currentRules = swapBuffer; } return(currentRules); }
public static FaultRule[] Load() { string serializationFileName = Environment.GetEnvironmentVariable(EnvironmentVariable.RuleRepository); if (serializationFileName == null) { throw new FaultInjectionException(string.Format(CultureInfo.CurrentCulture, ApiErrorMessages.UnableToFindEnvironmentVariable, EnvironmentVariable.RuleRepository)); } lock (initializeLock) { if (fileReadWriteMutex == null) { fileReadWriteMutex = new Mutex(false, Path.GetFileName(serializationFileName)); currentRules = Serializer.DeserializeRules(serializationFileName, fileReadWriteMutex); return(currentRules); } } FaultRule[] swapBuffer; lock (accessCurrentRuleLock) { swapBuffer = new FaultRule[currentRules.Length]; currentRules.CopyTo(swapBuffer, 0); } FaultRule[] loadedRules = Serializer.DeserializeRules(serializationFileName, fileReadWriteMutex); MergeRuleArray(swapBuffer, loadedRules); lock (accessCurrentRuleLock) { currentRules = swapBuffer; } return(currentRules); }
/// <summary> /// Copies the number of times the FaultRule has been called from another fault rule. /// This is used when this is a new fault rule that has just been deserialized and it /// is replacing an old fault rule. /// </summary> /// <param name="f">the old FaultRule that internal data should be copied from</param> internal void CopyNumTimesCalled(FaultRule f) { numTimesCalled = f.numTimesCalled; }
/// <summary> /// Injected into the prologue of the target method. /// </summary> /// <param name="exceptionValue">Exception thrown by fault</param> /// <param name="returnValue">Value to return from fault</param> /// <returns></returns> /// <remarks> /// Trap creates a RuntimeContext for the current call and evaluates /// the fault condition's Trigger method. If it evaluates to true /// the fault's Retrieve method is called. /// </remarks> public static bool Trap(out Exception exceptionValue, out Object returnValue) { StackTrace stackTrace = new StackTrace(1); CallStack callStack = new CallStack(stackTrace); //stackFrame does not include Trap() StackFrame stackFrame = stackTrace.GetFrame(0); String currentFunction = callStack[0]; exceptionValue = null; returnValue = null; FaultRule[] newRules; if (GetNewRulesAndPrepareContext(out newRules, currentFunction) == false) { return(false); } RuntimeContext currentContext = null; FaultRule rule = null; try { //Get Fault Rule and Update current RuntimeContext int len = contexts.Length; for (int i = 0; i < len; ++i) { if (newRules[i].FormalSignature != null && currentFunction.Equals(newRules[i].FormalSignature) == true) { rule = newRules[i]; currentContext = new RuntimeContext(); lock (contexts) { contexts[i].CalledTimes++; currentContext.CalledTimes = contexts[i].CalledTimes; } currentContext.CallStack = callStack; currentContext.CallStackTrace = stackTrace; break; } } //Using ICondition and IFault if (rule == null) { return(false); } bool triggered = false; try { lock (contexts) { triggered = rule.Condition.Trigger(currentContext); if (triggered == true) { rule.Fault.Retrieve(currentContext, out (exceptionValue), out returnValue); } } } catch (System.Exception e) { throw new FaultInjectionException(FaultDispatcherMessages.NoExceptionAllowedInTriggerAndRetrieve, e); } if (!triggered) { return(false); } } catch (System.Exception e) { throw new FaultInjectionException(FaultDispatcherMessages.UnknownExceptionInTrap, e); } // check return-value's type if not to throw exception if (null == exceptionValue) { if (stackFrame.GetMethod() is ConstructorInfo) { return(true); } Type returnTypeOfTrappedMethod = ((MethodInfo)stackFrame.GetMethod()).ReturnType; return(CheckReturnType(returnTypeOfTrappedMethod, returnValue, currentFunction)); } return(true); }