def when_tcp_reconnection_happens():
"""method to test the listener service event"""
attempt_listener = ReconnectionAttemptListenerImpl()
listener = ReconnectionListenerImpl()
messaging_service = MessagingService.builder().from_properties(boot.broker_properties()) \
.with_reconnection_retry_strategy(RetryStrategy.parametrized_retry(3, 3)).build(). \
add_reconnection_attempt_listener(attempt_listener). \
add_reconnection_listener(listener)
messaging_service.connect()
# If message disconnect occurs due to any network issue, service will automatically get connects again
# Apply some logic to simulate network issue, upon message service disconnect,
# this listener will notify once it is automatically connect/disconnect
messaging_service.remove_reconnection_listener(listener)
def add_listener_when_reconnection_happens(retries: int, retry_interval: int) -> 'MessagingService':
"""method adds a reconnection listener when an reconnection happens using the reconnection strategy
Args:
retries (int): the number of retries count
retry_interval (int): the retry interval value
Returns:
the listener events
"""
events = list()
def on_reconnection(event_p):
events.append(event_p)
print("current event", events)
try:
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
message = constants.MESSAGE_TO_SEND
number_of_message_to_send = 10
messaging_service = MessagingService.builder().from_properties(boot.broker_properties()) \
.with_reconnection_retry_strategy(RetryStrategy.parametrized_retry(retries, retry_interval)) \
.add_reconnection_listener(on_reconnection).build()
messaging_service1_status_code = messaging_service.connect_async()
print("messaging service status code: ", messaging_service1_status_code)
for _ in range(number_of_message_to_send):
publish_service = messaging_service.create_direct_message_publisher_builder().build()
publish_service.publish(destination=destination_name, message=message)
session_force_failure_status = messaging_service.disconnect_force()
print("session force failure status: ", session_force_failure_status)
for _ in range(number_of_message_to_send):
publish_service = messaging_service.create_direct_message_publisher_builder().build()
publish_service.publish(destination=destination_name, message=message)
messaging_service.disconnect()
finally:
timeout = time.time() + 60 * 1
while True:
if 13 in events or time.time() > timeout:
break
return events # MessagingService got list
def add_listener_when_reconnection_happens(
retries: int, retry_interval: int) -> 'MessagingService':
"""method adds a reconnection listener when an reconnection happens using the reconnection strategy
Args:
retries (int): the number of retries count
retry_interval (int): the retry interval value
Returns:
the listener events
"""
events = list()
class SampleServiceReconnectionHandler(ReconnectionAttemptListener,
ReconnectionListener):
def __init__(self):
self.events = list()
def on_reconnecting(event):
self.events.append(event)
print(
'Got reconnection attempt event, current reconnection events {self.events}'
)
def on_reconnected(self, event):
self.events.append(event)
print(
'Got reconnected event, current reconnection events {self.events}'
)
messaging_service = MessagingService.builder().from_properties(boot.broker_properties()) \
.with_reconnection_retry_strategy(RetryStrategy.parametrized_retry(retries, retry_interval)) \
.build()
event_handler = SampleServiceReconnectionHandler()
try:
messaging_service.add_reconnection_listener(event_handler)
messaging_service.connect()
# wait for reconnection here
# for now ommitting this code as it requires external connection administration
finally:
messaging_service.disconnect()
return event_handler.events # MessagingService got list
def connect_parametrized_retry(retries, retry_interval):
"""
creates a new instance of message service, that is used to configure
direct message instances from config
Returns: new connection for Direct messaging
Raises:
PubSubPlusClientError
"""
try:
message_service = MessagingService.builder() \
.from_properties(boot.broker_properties()) \
.with_reconnection_retry_strategy(RetryStrategy.parametrized_retry(retries, retry_interval)) \
.build(SamplerUtil.get_new_application_id())
return message_service.connect()
except PubSubPlusClientError as exception:
print(f'Exception: {exception}')
raise exception
finally:
message_service.disconnect()
print("\non_service_interrupted")
print(f"Error cause: {e.get_cause()}")
print(f"Message: {e.get_message()}")
# Broker Config. Note: Could pass other properties Look into
broker_props = {
"solace.messaging.transport.host": os.environ.get('SOLACE_HOST') or "localhost",
"solace.messaging.service.vpn-name": os.environ.get('SOLACE_VPN') or "default",
"solace.messaging.authentication.scheme.basic.username": os.environ.get('SOLACE_USERNAME') or "default",
"solace.messaging.authentication.scheme.basic.password": os.environ.get('SOLACE_PASSWORD') or "default"
}
# Build A messaging service with a reconnection strategy of 20 retries over an interval of 3 seconds
# Note: The reconnections strategy could also be configured using the broker properties object
messaging_service = MessagingService.builder().from_properties(broker_props)\
.with_reconnection_retry_strategy(RetryStrategy.parametrized_retry(20,3))\
.build()
# Blocking connect thread
messaging_service.connect()
print(f'Messaging Service connected? {messaging_service.is_connected}')
# Event Handling for the messaging service
service_handler = ServiceEventHandler()
messaging_service.add_reconnection_listener(service_handler)
messaging_service.add_reconnection_attempt_listener(service_handler)
messaging_service.add_service_interruption_listener(service_handler)
# Queue name.
# NOTE: This assumes that a persistent queue already exists on the broker with the right topic subscription
queue_name = "sample-queue"