示例#1
0
        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.");
                        }
                    }
                }
            }
        }
示例#2
0
        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.");
                        }
                    }
                }   
            }
        }
示例#3
0
        /// <summary>
        /// Callback method that will be invoked when the asynchronous BeginTestStack method is complete
        /// </summary>
        private void EndAutoReconnect(IAsyncResult asyncResult)
        {
            AsyncTestState state          = (AsyncTestState)asyncResult.AsyncState;
            long           completionTime = (state.CallData is long)?(long)state.CallData:0;

            lock (m_lock)
            {
                m_requestCount--;

                // check if a fault is expected.
                bool faultExpected = FaultExpected(completionTime, state.TestCaseContext);

                // complete the operation.
                Variant output;

                try
                {
                    state.ChannelContext.ClientSession.EndTestStack(asyncResult, out output);
                }
                catch (Exception e)
                {
                    if (!faultExpected)
                    {
                        // allow faults for a short period of time after a black out ends.
                        for (int ii = 0; ii < m_blackouts.Count; ii++)
                        {
                            if (completionTime >= m_blackouts[ii].Start && completionTime < m_blackouts[ii].End + state.TestCaseContext.MaxTransportDelay)
                            {
                                faultExpected = true;
                                break;
                            }
                        }
                    }

                    for (int ii = 0; ii < m_blackouts.Count; ii++)
                    {
                        long period = m_blackouts[ii].Start;

                        if (m_blackouts[ii].End <= 0)
                        {
                            period = DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond - period;
                        }
                        else
                        {
                            period = m_blackouts[ii].End - period;
                        }

                        if (state.TestCaseContext.MaxRecoveryTime + state.TestCaseContext.MaxResponseDelay <= (int)period)
                        {
                            e = ServiceResultException.Create(
                                StatusCodes.BadUnexpectedError,
                                "Iteration {0} MaxRecoveryTime Exceeded {1} ms",
                                state.Iteration,
                                period);

                            faultExpected = false;
                            break;
                        }
                    }

                    // no error if a fault was expected.
                    if (faultExpected)
                    {
                        Utils.Trace("Iteration {0}; Fault Expected {1}", state.Iteration, e.Message);
                        state.ChannelContext.EventLogger.LogCompleteEvent(state.Testcase, state.Iteration);
                        return;
                    }

                    Utils.Trace("Iteration {0}; Fault Unexpected {1}", state.Iteration, e.Message);

                    // log error.
                    state.ChannelContext.EventLogger.LogErrorEvent(state.Testcase, state.Iteration, e);

                    if (m_sequenceToExecute.HaltOnError)
                    {
                        // only report first fault.
                        if (m_fault == null)
                        {
                            m_fault = ServiceResult.Create(e, StatusCodes.BadUnexpectedError, "Unexpected Fault on Iteration {0}", state.Iteration);
                        }
                    }

                    return;
                }

                // allow success for a short period of time before a black out begins.
                for (int ii = 0; ii < m_blackouts.Count; ii++)
                {
                    if ((completionTime <= m_blackouts[ii].End || m_blackouts[ii].End == 0) && completionTime >= m_blackouts[ii].Start - state.TestCaseContext.MaxTransportDelay)
                    {
                        faultExpected = false;
                        break;
                    }
                }

                try
                {
                    // check if a fault was expected.
                    if (faultExpected)
                    {
                        throw ServiceResultException.Create(
                                  StatusCodes.BadUnexpectedError,
                                  "Expecting a fault which did not occur.");
                    }

                    // check processing time.
                    long processingTimeError = ((DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond) - completionTime);

                    Utils.Trace("Iteration {0}; Delta {1}.", state.Iteration, processingTimeError);

                    if (Math.Abs(processingTimeError) > state.TestCaseContext.MaxTransportDelay * 2)
                    {
                        bool late = true;

                        if (state.TestCaseContext.StackEventType == 4)
                        {
                            if (Math.Abs(processingTimeError) > state.TestCaseContext.MaxRecoveryTime)
                            {
                                late = false;
                            }
                        }

                        if (late)
                        {
                            throw ServiceResultException.Create(
                                      StatusCodes.BadUnexpectedError,
                                      "Request did not complete in the specified time (Error = {0}ms).",
                                      processingTimeError);
                        }
                    }

                    // black out ends when the first valid request is returned.
                    for (int ii = 0; ii < m_blackouts.Count; ii++)
                    {
                        if (m_blackouts[ii].End <= 0)
                        {
                            m_blackouts[ii].End = (DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond);
                        }
                    }

                    // check output.
                    state.ChannelContext.Random.Start(
                        (int)(state.Testcase.ResponseSeed + state.Iteration),
                        (int)m_sequenceToExecute.RandomDataStepSize,
                        state.TestCaseContext);

                    Variant expectedOutput = state.ChannelContext.Random.GetVariant();

                    if (!Compare.CompareVariant(output, expectedOutput))
                    {
                        throw ServiceResultException.Create(
                                  StatusCodes.BadUnexpectedError,
                                  "Server did not return expected output\r\nActual = {0}\r\nExpected = {0}",
                                  output,
                                  expectedOutput);
                    }

                    // iteration complete.
                    state.ChannelContext.EventLogger.LogCompleteEvent(state.Testcase, state.Iteration);
                }
                catch (Exception e)
                {
                    state.ChannelContext.EventLogger.LogErrorEvent(state.Testcase, state.Iteration, e);

                    if (m_sequenceToExecute.HaltOnError)
                    {
                        // only report first fault.
                        if (m_fault == null)
                        {
                            m_fault = new ServiceResult(e);
                        }
                    }
                }
            }
        }