Search in sources :

Example 1 with IncorrectProcessorStateException

use of com.axway.ats.log.autodb.exceptions.IncorrectProcessorStateException in project ats-framework by Axway.

the class AbstractLoggingEvent method checkIfCanBeProcessed.

/**
 * Check if this event can be processed if the processor
 * is in the given state
 *
 * @param state the current appender state
 * @throws IncorrectProcessorStateException if the state is incorrect
 * @throws IncorrectScenarioTypeException if the scenario type is incorrect
 */
public void checkIfCanBeProcessed(EventProcessorState state) throws IncorrectProcessorStateException, IncorrectScenarioTypeException {
    LifeCycleState expectedState = getExpectedLifeCycleState(state.getLifeCycleState());
    LifeCycleState actualState = state.getLifeCycleState();
    if ((expectedState != null)) {
        if (expectedState == LifeCycleState.ATLEAST_RUN_STARTED) {
            if (actualState == LifeCycleState.INITIALIZED) {
                throw new IncorrectProcessorStateException("Cannot execute event " + this.getClass().getSimpleName() + " at this time as run is not yet started", expectedState, actualState);
            }
        } else if (expectedState == LifeCycleState.ATLEAST_TESTCASE_STARTED) {
            if (actualState != LifeCycleState.ATLEAST_TESTCASE_STARTED && actualState != LifeCycleState.TEST_CASE_STARTED) {
                throw new IncorrectProcessorStateException("Cannot execute event " + this.getClass().getSimpleName() + " at this time as testcase is not yet started", expectedState, actualState);
            }
        } else if (expectedState == LifeCycleState.ATLEAST_SUITE_STARTED) {
            if (actualState == LifeCycleState.INITIALIZED || actualState == LifeCycleState.ATLEAST_RUN_STARTED || actualState == LifeCycleState.RUN_STARTED) {
                throw new IncorrectProcessorStateException("Cannot execute event " + this.getClass().getSimpleName() + " at this time as suite is not yet started", expectedState, actualState);
            }
        } else // strict expectations about the state
        if (expectedState != actualState) {
            throw new IncorrectProcessorStateException("Cannot execute event " + this.getClass().getSimpleName() + " at this time", expectedState, actualState);
        }
    }
}
Also used : IncorrectProcessorStateException(com.axway.ats.log.autodb.exceptions.IncorrectProcessorStateException) LifeCycleState(com.axway.ats.log.autodb.logqueue.LifeCycleState)

Example 2 with IncorrectProcessorStateException

use of com.axway.ats.log.autodb.exceptions.IncorrectProcessorStateException in project ats-framework by Axway.

the class DbEventRequestProcessor method processEventRequest.

public void processEventRequest(LogEventRequest eventRequest) throws LoggingException {
    if (testcaseToDelete > 0) {
        /* Pause for a moment processing the current event.
             * This is (delete testcase)event is not coming from the FIFO queue, as we want to process it as
             * soon as possible, so any events related to this testcase are directly skipped.
             */
        deleteRequestedTestcase();
    // now resume the processing of the current event that came from the queue
    }
    if (isBatchMode && eventRequest == null) {
        // timeout waiting for next event - flush the current cache
        dbAccess.flushCache();
        return;
    }
    LogEvent event = eventRequest.getEvent();
    if (event instanceof AbstractLoggingEvent) {
        AbstractLoggingEvent dbAppenderEvent = (AbstractLoggingEvent) event;
        if (dbAppenderEvent instanceof UpdateSuiteEvent) {
            try {
                dbAppenderEvent.checkIfCanBeProcessed(eventProcessorState);
            } catch (IncorrectProcessorStateException e) {
                /* Suite not started yet, 
                     * so save the current event as pending 
                     * and fired it right after StartSuiteEvent is received
                    */
                pendingUpdateSuiteEvent = (UpdateSuiteEvent) dbAppenderEvent;
                return;
            }
        } else if (dbAppenderEvent instanceof UpdateRunEvent) {
            try {
                /* Run not started yet.
                     * We will fire the event after StartRunEvent is received
                    */
                userProvidedUpdateRunEvent = (UpdateRunEvent) dbAppenderEvent;
                dbAppenderEvent.checkIfCanBeProcessed(eventProcessorState);
            } catch (IncorrectProcessorStateException e) {
                /*
                     * If we get an exception, do no process the event any further.
                     * We will fire it after StartRunEvent is received.
                     * */
                return;
            }
        } else if (dbAppenderEvent instanceof AddTestcaseMetainfoEvent) {
            try {
                dbAppenderEvent.checkIfCanBeProcessed(eventProcessorState);
            } catch (Exception e) {
                AddTestcaseMetainfoEvent atmie = ((AddTestcaseMetainfoEvent) dbAppenderEvent);
                boolean throwException = false;
                if (atmie.getTestcaseId() == -1) {
                    if (eventProcessorState.getTestCaseId() == -1 && eventProcessorState.getLastExecutedTestCaseId() == -1) {
                        // No testcase was either running or previously finished.
                        // ATS needs to throw an Exception
                        throwException = true;
                    }
                } else {
                    // Testcase ID was specified with the event, but still an error occurred. ATS needs to throw an Exception
                    throwException = true;
                }
                if (throwException) {
                    String errorMessage = constructEventProcessingErrorMessage(dbAppenderEvent);
                    log.error(errorMessage);
                    throw e;
                }
            }
        } else {
            // first check if we can process the event at all
            try {
                dbAppenderEvent.checkIfCanBeProcessed(eventProcessorState);
            } catch (LoggingException e) {
                String errorMessage = constructEventProcessingErrorMessage(dbAppenderEvent);
                log.error(errorMessage);
                throw e;
            }
        }
        if (isBatchMode && !(event instanceof CacheableEvent) && eventProcessorState.getLifeCycleState() == LifeCycleState.TEST_CASE_STARTED) {
            // this event can not be cached - flush the current cache
            dbAccess.flushCache();
        }
        switch(dbAppenderEvent.getEventType()) {
            case START_RUN:
                startRun((StartRunEvent) event, eventRequest.getTimestamp());
                if (userProvidedUpdateRunEvent != null) {
                    constructUpdateRunEvent();
                    updateRun(actualUpdateRunEvent);
                }
                break;
            case END_RUN:
                endRun(eventRequest.getTimestamp());
                break;
            case UPDATE_RUN:
                /*
                     * By using data from the latest UpdateRunEvent and the current run info,
                     * construct a pending UpdateRunEvent
                     * */
                constructUpdateRunEvent();
                updateRun(actualUpdateRunEvent);
                break;
            case START_AFTER_SUITE:
                afterSuiteMode = true;
                break;
            case END_AFTER_SUITE:
                afterSuiteMode = false;
                break;
            case ADD_RUN_METAINFO:
                addRunMetainfo((AddRunMetainfoEvent) event);
                break;
            case START_SUITE:
                startSuite((StartSuiteEvent) event, eventRequest.getTimestamp());
                if (pendingUpdateSuiteEvent != null) {
                    updateSuite(pendingUpdateSuiteEvent);
                    pendingUpdateSuiteEvent = null;
                }
                break;
            case END_SUITE:
                endSuite(eventRequest.getTimestamp());
                break;
            case UPDATE_SUITE:
                updateSuite((UpdateSuiteEvent) event);
                break;
            case START_AFTER_CLASS:
                afterClassMode = true;
                break;
            case END_AFTER_CLASS:
                afterClassMode = false;
                break;
            case CLEAR_SCENARIO_METAINFO:
                clearScenarioMetainfo();
                break;
            case ADD_SCENARIO_METAINFO:
                addScenarioMetainfo((AddScenarioMetainfoEvent) event);
                break;
            case UPDATE_TEST_CASE:
                updateTestcase((UpdateTestcaseEvent) event, eventRequest.getTimestamp());
                break;
            case END_TEST_CASE:
                endTestCase((EndTestCaseEvent) event, eventRequest.getTimestamp());
                break;
            case START_TEST_CASE:
                startTestCase((StartTestCaseEvent) event, eventRequest.getTimestamp());
                break;
            case JOIN_TEST_CASE:
                joinTestCase((JoinTestCaseEvent) event);
                break;
            case LEAVE_TEST_CASE:
                leaveTestCase();
                break;
            case ADD_TESTCASE_METAINFO:
                addTestcaseMetainfo((AddTestcaseMetainfoEvent) event);
                break;
            case START_AFTER_METHOD:
                afterMethodMode = true;
                break;
            case END_AFTER_METHOD:
                afterMethodMode = false;
                break;
            case REMEMBER_LOADQUEUE_STATE:
                rememberLoadQueueState((RememberLoadQueueStateEvent) event);
                break;
            case CLEANUP_LOADQUEUE_STATE:
                cleanupLoadQueueState((CleanupLoadQueueStateEvent) event);
                break;
            case END_LOADQUEUE:
                endLoadQueue((EndLoadQueueEvent) event, eventRequest.getTimestamp());
                break;
            case REGISTER_THREAD_WITH_LOADQUEUE:
                registerThreadWithLoadQueue((RegisterThreadWithLoadQueueEvent) event);
                break;
            case START_CHECKPOINT:
                startCheckpoint((StartCheckpointEvent) event);
                break;
            case END_CHECKPOINT:
                endCheckpoint((EndCheckpointEvent) event);
                break;
            case INSERT_CHECKPOINT:
                insertCheckpoint((InsertCheckpointEvent) event);
                break;
            case INSERT_SYSTEM_STAT:
                insertSystemStatistics((InsertSystemStatisticEvent) event);
                break;
            case INSERT_USER_ACTIVITY_STAT:
                insertUserActivityStatistics((InsertUserActivityStatisticEvent) event);
                break;
            case INSERT_MESSAGE:
                InsertMessageEvent insertMessageEvent = (InsertMessageEvent) event;
                insertMessage(eventRequest, insertMessageEvent.isEscapeHtml(), insertMessageEvent.isRunMessage());
                break;
            default:
                throw new LoggingException("Unsupported logging event of type: " + dbAppenderEvent.getEventType());
        }
    } else {
        insertMessage(eventRequest, false, false);
    }
}
Also used : AddTestcaseMetainfoEvent(com.axway.ats.log.autodb.events.AddTestcaseMetainfoEvent) AbstractLoggingEvent(com.axway.ats.log.autodb.model.AbstractLoggingEvent) IncorrectProcessorStateException(com.axway.ats.log.autodb.exceptions.IncorrectProcessorStateException) UpdateRunEvent(com.axway.ats.log.autodb.events.UpdateRunEvent) LoggingException(com.axway.ats.log.autodb.exceptions.LoggingException) LogEvent(org.apache.logging.log4j.core.LogEvent) InsertMessageEvent(com.axway.ats.log.autodb.events.InsertMessageEvent) UpdateSuiteEvent(com.axway.ats.log.autodb.events.UpdateSuiteEvent) CacheableEvent(com.axway.ats.log.autodb.model.CacheableEvent) LoggingException(com.axway.ats.log.autodb.exceptions.LoggingException) LoadQueueAlreadyStartedException(com.axway.ats.log.autodb.exceptions.LoadQueueAlreadyStartedException) ThreadAlreadyRegisteredWithLoadQueueException(com.axway.ats.log.autodb.exceptions.ThreadAlreadyRegisteredWithLoadQueueException) NoSuchLoadQueueException(com.axway.ats.log.autodb.exceptions.NoSuchLoadQueueException) SQLException(java.sql.SQLException) IncorrectProcessorStateException(com.axway.ats.log.autodb.exceptions.IncorrectProcessorStateException) DatabaseAccessException(com.axway.ats.log.autodb.exceptions.DatabaseAccessException) UnknownHostException(java.net.UnknownHostException)

Aggregations

IncorrectProcessorStateException (com.axway.ats.log.autodb.exceptions.IncorrectProcessorStateException)2 AddTestcaseMetainfoEvent (com.axway.ats.log.autodb.events.AddTestcaseMetainfoEvent)1 InsertMessageEvent (com.axway.ats.log.autodb.events.InsertMessageEvent)1 UpdateRunEvent (com.axway.ats.log.autodb.events.UpdateRunEvent)1 UpdateSuiteEvent (com.axway.ats.log.autodb.events.UpdateSuiteEvent)1 DatabaseAccessException (com.axway.ats.log.autodb.exceptions.DatabaseAccessException)1 LoadQueueAlreadyStartedException (com.axway.ats.log.autodb.exceptions.LoadQueueAlreadyStartedException)1 LoggingException (com.axway.ats.log.autodb.exceptions.LoggingException)1 NoSuchLoadQueueException (com.axway.ats.log.autodb.exceptions.NoSuchLoadQueueException)1 ThreadAlreadyRegisteredWithLoadQueueException (com.axway.ats.log.autodb.exceptions.ThreadAlreadyRegisteredWithLoadQueueException)1 LifeCycleState (com.axway.ats.log.autodb.logqueue.LifeCycleState)1 AbstractLoggingEvent (com.axway.ats.log.autodb.model.AbstractLoggingEvent)1 CacheableEvent (com.axway.ats.log.autodb.model.CacheableEvent)1 UnknownHostException (java.net.UnknownHostException)1 SQLException (java.sql.SQLException)1 LogEvent (org.apache.logging.log4j.core.LogEvent)1