/// <summary> /// Queues an action. /// </summary> private void QueueStackAction(SessionClient session, StackAction action) { System.ServiceModel.ClientBase <ISessionChannel> channel = session.InnerChannel as System.ServiceModel.ClientBase <ISessionChannel>; if (channel != null) { IStackControl control = channel.InnerChannel.GetProperty <IStackControl>(); if (control != null) { control.QueueAction(action); } } }
/// <summary> /// Queues an action. /// </summary> private void QueueStackAction(StackAction action) { System.ServiceModel.OperationContext context = System.ServiceModel.OperationContext.Current; if (context != null) { IStackControl control = context.Channel.GetProperty <IStackControl>(); if (control != null) { control.QueueAction(action); } } }
/// <summary> /// Sets the event sink for the current channel. /// </summary> private void InterruptListener(int duration) { System.ServiceModel.OperationContext context = System.ServiceModel.OperationContext.Current; if (context != null) { IStackControl control = context.EndpointDispatcher.ChannelDispatcher.Listener.GetProperty <IStackControl>(); if (control != null) { StackAction action = new StackAction(); action.ActionType = StackActionType.CloseListeningSocket; action.Duration = duration; control.QueueAction(action); } } }
/// <summary> /// Returns the stack action to use for the current context. /// </summary> public static StackAction GetStackAction(TestCaseContext context, EndpointDescription endpointDescription) { if (!endpointDescription.EndpointUrl.StartsWith(Utils.UriSchemeOpcTcp)) { return(null); } StackAction action = new StackAction(); switch (context.StackEventType) { case 1: { action.ActionType = StackActionType.CorruptMessageChunk; break; } case 2: { action.ActionType = StackActionType.ReuseSequenceNumber; break; } case 3: { action.ActionType = StackActionType.CloseConnectionSocket; break; } case 4: { action.ActionType = StackActionType.CloseConnectionSocket; break; } default: { return(null); } } // cannot detect corrupt messages predictably if no security is used. if (endpointDescription.SecurityMode == MessageSecurityMode.None) { if (action.ActionType == StackActionType.CorruptMessageChunk) { action.ActionType = StackActionType.ReuseSequenceNumber; } } return(action); }
/// <summary> /// Sets the event sink for the current channel. /// </summary> private void InterruptListener(int duration) { System.ServiceModel.OperationContext context = System.ServiceModel.OperationContext.Current; if (context != null) { IStackControl control = context.EndpointDispatcher.ChannelDispatcher.Listener.GetProperty<IStackControl>(); if (control != null) { StackAction action = new StackAction(); action.ActionType = StackActionType.CloseListeningSocket; action.Duration = duration; control.QueueAction(action); } } }
/// <summary> /// Queues an action. /// </summary> private void QueueStackAction(StackAction action) { System.ServiceModel.OperationContext context = System.ServiceModel.OperationContext.Current; if (context != null) { IStackControl control = context.Channel.GetProperty<IStackControl>(); if (control != null) { control.QueueAction(action); } } }
private Variant ExecuteTest_AutoReconnect(TestCaseContext testCaseContext, TestCase testCase, int iteration, Variant input) { if (TestUtils.IsSetupIteration(iteration)) { SetEventSink(); return(Variant.Null); } // get the expected input. Variant expectedInput; int processingTime = 0; lock (m_random) { Utils.Trace("Iteration {0}; Server Received", iteration); // compare actual to expected input. m_random.Start( (int)(testCase.Seed + iteration), (int)m_sequenceToExecute.RandomDataStepSize, testCaseContext); expectedInput = m_random.GetVariant(); if (!Compare.CompareVariant(input, expectedInput)) { throw ServiceResultException.Create( StatusCodes.BadUnexpectedError, "Server did not receive expected input\r\nActual = {0}\r\nExpected = {0}", input, expectedInput); } // determine processing time in server. processingTime = m_random.GetInt32Range(0, testCaseContext.MaxResponseDelay); if ((iteration + 1) % testCaseContext.StackEventFrequency == 0) { if (testCaseContext.StackEventType == 4) { InterruptListener(testCaseContext.StackEventFrequency * testCaseContext.RequestInterval / 2); } StackAction action = TestUtils.GetStackAction(testCaseContext, SecureChannelContext.Current.EndpointDescription); if (action != null) { QueueStackAction(action); } } } // wait. Thread.Sleep(processingTime); // generate and return the output. lock (m_random) { m_random.Start((int)( testCase.ResponseSeed + iteration), (int)m_sequenceToExecute.RandomDataStepSize, testCaseContext); return(m_random.GetVariant()); } }
private void ExecuteTest_AutoReconnect( ChannelContext channelContext, TestCaseContext testCaseContext, TestCase testCase, int iteration) { Variant input; Variant output; // initialize test case. if (iteration == TestCases.TestSetupIteration) { m_fault = null; m_blackouts = new List <BlackoutPeriod>(); channelContext.ClientSession.OperationTimeout = 30000; RequestHeader requestHeader = new RequestHeader(); requestHeader.Timestamp = DateTime.UtcNow; requestHeader.ReturnDiagnostics = (uint)DiagnosticsMasks.All; ResponseHeader responseHeader = channelContext.ClientSession.TestStack( null, testCase.TestId, TestCases.TestSetupIteration, input, out output); return; } if (iteration == TestCases.TestCleanupIteration) { do { lock (m_lock) { if (m_requestCount == 0) { return; } } Thread.Sleep(100); }while (true); } Thread.Sleep(testCaseContext.RequestInterval); // report fault after waiting for all active threads to exit. if (m_sequenceToExecute.HaltOnError) { ServiceResult fault = null; lock (m_lock) { fault = m_fault; } if (fault != null) { do { lock (m_lock) { if (m_requestCount == 0) { throw new ServiceResultException(fault); } } Thread.Sleep(100); }while (true); } } // begin iteration. channelContext.EventLogger.LogStartEvent(testCase, iteration); lock (m_lock) { // set up header. RequestHeader requestHeader = new RequestHeader(); requestHeader.Timestamp = DateTime.UtcNow; requestHeader.ReturnDiagnostics = (uint)DiagnosticsMasks.All; // generate input data. channelContext.Random.Start( (int)(testCase.Seed + iteration), (int)m_sequenceToExecute.RandomDataStepSize, testCaseContext); input = channelContext.Random.GetVariant(); // determine processing time in server. int processingTime = channelContext.Random.GetInt32Range(0, testCaseContext.MaxResponseDelay); Utils.Trace("Iteration {0}; Processing Time {1}.", iteration, processingTime); AsyncTestState state = new AsyncTestState(channelContext, testCaseContext, testCase, iteration); state.CallData = (DateTime.UtcNow.AddMilliseconds(processingTime).Ticks / TimeSpan.TicksPerMillisecond); // set timeout to twice the processing time. if (processingTime < testCaseContext.MaxTransportDelay) { processingTime = testCaseContext.MaxTransportDelay; } channelContext.ClientSession.OperationTimeout = processingTime * 2; if ((iteration + 1) % testCaseContext.StackEventFrequency == 0) { StackAction action = TestUtils.GetStackAction(testCaseContext, channelContext.EndpointDescription); if (action != null) { BlackoutPeriod period = new BlackoutPeriod(); period.Start = (DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond); m_blackouts.Add(period); Utils.Trace("Iteration {0}; Expecting Fault {1}", iteration, action.ActionType); } } try { channelContext.ClientSession.BeginTestStack( requestHeader, testCase.TestId, iteration, input, EndAutoReconnect, state); m_requestCount++; } catch (Exception e) { // check if a fault is expected. bool faultExpected = FaultExpected((long)state.CallData, testCaseContext); if (faultExpected) { Utils.Trace("Iteration {0}; Fault Expected {1}", state.Iteration, e.Message); state.ChannelContext.EventLogger.LogCompleteEvent(testCase, iteration); return; } channelContext.EventLogger.LogErrorEvent(testCase, iteration, e); if (m_sequenceToExecute.HaltOnError) { if (m_fault == null) { m_fault = ServiceResult.Create(e, StatusCodes.BadUnexpectedError, "Could not send request."); } } } } }
/// <summary> /// Queues an action. /// </summary> private void QueueStackAction(SessionClient session, StackAction action) { System.ServiceModel.ClientBase<ISessionChannel> channel = session.InnerChannel as System.ServiceModel.ClientBase<ISessionChannel>; if (channel != null) { IStackControl control = channel.InnerChannel.GetProperty<IStackControl>(); if (control != null) { control.QueueAction(action); } } }
/// <summary> /// Returns the stack action to use for the current context. /// </summary> public static StackAction GetStackAction(TestCaseContext context, EndpointDescription endpointDescription) { if (!endpointDescription.EndpointUrl.StartsWith(Utils.UriSchemeOpcTcp)) { return null; } StackAction action = new StackAction(); switch (context.StackEventType) { case 1: { action.ActionType = StackActionType.CorruptMessageChunk; break; } case 2: { action.ActionType = StackActionType.ReuseSequenceNumber; break; } case 3: { action.ActionType = StackActionType.CloseConnectionSocket; break; } case 4: { action.ActionType = StackActionType.CloseConnectionSocket; break; } default: { return null; } } // cannot detect corrupt messages predictably if no security is used. if (endpointDescription.SecurityMode == MessageSecurityMode.None) { if (action.ActionType == StackActionType.CorruptMessageChunk) { action.ActionType = StackActionType.ReuseSequenceNumber; } } return action; }