def __init__(self, configuration, monitors):
CopyingManager.__init__(self, configuration, monitors)
# Approach: We will override key methods of CopyingManager, blocking them from returning until the controller
# tells it to proceed. This allows us to then do things like write new log lines while the CopyingManager is
# blocked. Coordinating the communication between the two threads is done using two condition variables.
# We changed the CopyingManager to block in three places: while it is sleeping before it starts a new loop,
# when it invokes ``_send_events`` to send a new request, and when it blocks to receive the response.
# These three states or referred to as "sleeping", "blocked_on_send", "blocked_on_receive".
#
# This cv protects all of the variables written by the CopyingManager thread.
self.__test_state_cv = threading.Condition()
# Which state the CopyingManager is currently blocked in -- "sleeping", "blocked_on_send", "blocked_on_receive"
self.__test_state = None
# The number of times the CopyingManager has blocked.
self.__test_state_changes = 0
# Whether or not the CopyingManager should stop.
self.__test_stopping = False
# Written by CopyingManager. The last AddEventsRequest request passed into ``_send_events``.
self.__captured_request = None
# Protected by __test_state_cv. The status message to return for the next call to ``_send_events``.
self.__pending_response = None
# This cv protects __advance_requests and is used mainly by the testing thread.
self.__advance_requests_cv = threading.Condition()
# This is incremented everytime the controller wants the CopyingManager to advance to the next blocking state,
# regardless of which state it is in.
self.__advance_requests = 0
self.__controller = TestableCopyingManager.TestController(self)
def __init__(self, configuration, monitors):
CopyingManager.__init__(self, configuration, monitors)
# Approach: We will override key methods of CopyingManager, blocking them from returning until the controller
# tells it to proceed. This allows us to then do things like write new log lines while the CopyingManager is
# blocked. Coordinating the communication between the two threads is done using two condition variables.
# We changed the CopyingManager to block in three places: while it is sleeping before it starts a new loop,
# when it invokes ``_send_events`` to send a new request, and when it blocks to receive the response.
# These three states or referred to as "sleeping", "blocked_on_send", "blocked_on_receive".
#
# This cv protects all of the variables written by the CopyingManager thread.
self.__test_state_cv = threading.Condition()
# Which state the CopyingManager is currently blocked in -- "sleeping", "blocked_on_send", "blocked_on_receive"
self.__test_state = None
# The number of times the CopyingManager has blocked.
self.__test_state_changes = 0
# Whether or not the CopyingManager should stop.
self.__test_stopping = False
# Written by CopyingManager. The last AddEventsRequest request passed into ``_send_events``.
self.__captured_request = None
# Protected by __test_state_cv. The status message to return for the next call to ``_send_events``.
self.__pending_response = None
# This cv protects __advance_requests and is used mainly by the testing thread.
self.__advance_requests_cv = threading.Condition()
# This is incremented everytime the controller wants the CopyingManager to advance to the next blocking state,
# regardless of which state it is in.
self.__advance_requests = 0
self.__controller = TestableCopyingManager.TestController(self)
def __init__(self, configuration, monitors):
CopyingManager.__init__(self, configuration, monitors)
# Approach: We will override key methods of CopyingManager, blocking them from returning until the controller
# tells it to proceed. This allows us to then do things like write new log lines while the CopyingManager is
# blocked. Coordinating the communication between the two threads is done using one condition variable.
# We changed the CopyingManager to block in three places: while it is sleeping before it starts a new loop,
# when it invokes `_send_events` to send a new request, and when it blocks to receive the response.
# These three states are referred to as 'sleeping', 'sending', 'responding'.
#
# The CopyingManager will have state to record where it should next block (i.e., if it should block at
# 'sleeping' when it attempts to sleep). The test controller will manipulate this state, notifying changes on
# the condition variable. The CopyingManager will block in this state (and indicate it is blocked) until the
# test controller sets a new state to block at.
#
# This cv protects all of the variables written by the CopyingManager thread.
self.__test_state_cv = threading.Condition()
# Which state the CopyingManager should block in -- "sleeping", "sending", "responding"
# We initialize it to a special value "all" so that it stops as soon the CopyingManager starts up.
self.__test_stop_state = 'all'
# If not none, a state the test must pass through before it tries to stop at `__test_stop_state`.
# If this transition is not observed by the time it does get to the stop state, an assertion is thrown.
self.__test_required_transition = None
# Whether or not the CopyingManager is stopped at __test_stop_state.
self.__test_is_stopped = False
# Written by CopyingManager. The last AddEventsRequest request passed into ``_send_events``.
self.__captured_request = None
# Protected by __test_state_cv. The status message to return for the next call to ``_send_events``.
self.__pending_response = None
self.__controller = TestableCopyingManager.TestController(self)
def __init__(self, configuration, monitors):
CopyingManager.__init__(self, configuration, monitors)
TestableCopyingManagerFlowController.__init__(self, configuration)
# do this just to tell static analyzer that this is a testable instances.
self._log_matchers = self._log_matchers # type: List[TestableLogMatcher]
