def test_session_by_session_client_conn_str_receive_handler_with_stop(
live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=session_queue, debug=False)
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i))
sender.send(message)
messages = []
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
for message in session:
assert session_id == session.session_id
assert session_id == message.session_id
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert session.running
assert len(messages) == 5
with session:
for message in session:
assert session_id == session.session_id
assert session_id == message.session_id
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert not session.running
assert len(messages) == 6
def test_queue_by_queue_client_conn_str_receive_handler_receiveanddelete(
live_servicebus_config, standard_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=standard_queue, debug=False)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
message.enqueue_sequence_number = i
sender.send(message)
messages = []
receiver = queue_client.get_receiver(
mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in receiver:
messages.append(message)
with pytest.raises(MessageAlreadySettled):
message.complete()
assert not receiver.running
assert len(messages) == 10
time.sleep(30)
messages = []
receiver = queue_client.get_receiver(
mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in receiver:
messages.append(message)
assert len(messages) == 0
def get_message(channel, conn_string):
qc = QueueClient.from_connection_string(conn_string, channel)
with qc.get_receiver() as queue_receiver:
messages = queue_receiver.fetch_next(timeout=30)
message = str(messages[0])
json_message = json.loads(message)
return json_message
def test_qsession_by_queue_client_conn_str_receive_handler_receiveanddelete(live_servicebus_config, partitioned_session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
sender.send(message)
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert session_id == session.session_id
assert session_id == message.session_id
with pytest.raises(MessageAlreadySettled):
message.complete()
assert not session.running
assert len(messages) == 10
time.sleep(30)
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert len(messages) == 0
def test_session_by_conn_str_receive_handler_with_autolockrenew(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
session_id = str(uuid.uuid4())
queue_client = QueueClient.from_connection_string(
servicebus_namespace_connection_string,
name=servicebus_queue.name,
debug=False)
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("{}".format(i))
sender.send(message)
renewer = AutoLockRenew()
messages = []
with queue_client.get_receiver(session=session_id,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as session:
renewer.register(session, timeout=60)
print("Registered lock renew thread", session.locked_until,
datetime.now())
with pytest.raises(SessionLockExpired):
for message in session:
if not messages:
print("Starting first sleep")
time.sleep(40)
print("First sleep {}".format(session.locked_until -
datetime.now()))
assert not session.expired
with pytest.raises(TypeError):
message.expired
assert message.locked_until is None
with pytest.raises(TypeError):
message.renew_lock()
assert message.lock_token is None
message.complete()
messages.append(message)
elif len(messages) == 1:
print("Starting second sleep")
time.sleep(40)
print("Second sleep {}".format(session.locked_until -
datetime.now()))
assert session.expired
assert isinstance(session.auto_renew_error,
AutoLockRenewTimeout)
try:
message.complete()
raise AssertionError(
"Didn't raise SessionLockExpired")
except SessionLockExpired as e:
assert isinstance(e.inner_exception,
AutoLockRenewTimeout)
messages.append(message)
renewer.shutdown()
assert len(messages) == 2
def get_message_from_queue(client: QueueClient) -> Optional[ArkivuttrekkTransferInfo]:
with client.get_receiver() as receiver:
message = receiver.next()
message_str = str(message)
message.complete()
logging.info(f'Got message: {message_str}') # Todo Remove this? It will print the entire sas url
return ArkivuttrekkTransferInfo.from_string(message_str)
def test_pqueue_by_queue_client_conn_str_receive_handler_with_stop(live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i))
sender.send(message)
messages = []
receiver = queue_client.get_receiver(idle_timeout=5)
for message in receiver:
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert receiver.running
assert len(messages) == 5
with receiver:
for message in receiver:
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert not receiver.running
assert len(messages) == 6
def test_sb_client_writeonly_credentials(
self, servicebus_authorization_rule_connection_string,
servicebus_queue, **kwargs):
client = ServiceBusClient.from_connection_string(
servicebus_authorization_rule_connection_string)
with pytest.raises(AzureHttpError):
client.get_queue(servicebus_queue.name)
client = QueueClient.from_connection_string(
servicebus_authorization_rule_connection_string,
name=servicebus_queue.name,
debug=False)
with pytest.raises(ServiceBusAuthorizationError):
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
client.send([Message("test1"), Message("test2")])
with pytest.raises(TypeError):
client.send("cat")
with pytest.raises(TypeError):
client.send(1234)
with pytest.raises(TypeError):
client.send([1, 2, 3])
with pytest.raises(TypeError):
client.send([Message("test1"), "test2"])
def get_message(channel: str, conn_string: str) -> Dict[str, str]:
q = QueueClient.from_connection_string(conn_string, channel)
with q.get_receiver() as qr:
messages = qr.fetch_next(timeout=30)
message = str(messages[0])
json_message = json.loads(message)
return json_message
def test_pqueue_by_queue_client_conn_str_receive_handler_receiveanddelete(live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
message.enqueue_sequence_number = i
sender.send(message)
messages = []
receiver = queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in receiver:
messages.append(message)
with pytest.raises(MessageAlreadySettled):
message.complete()
assert not receiver.running
assert len(messages) == 10
time.sleep(30)
messages = []
receiver = queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in receiver:
messages.append(message)
assert len(messages) == 0
def wait_result(auth_uid, conn_string):
q = QueueClient.from_connection_string(conn_string, auth_uid)
with q.get_receiver() as qr:
messages = qr.fetch_next(timeout=30)
message = str(messages[0])
json_message = json.loads(message)
return json_message
def test_queue_by_queue_client_conn_str_receive_handler_with_stop(
live_servicebus_config, standard_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=standard_queue, debug=False)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i))
sender.send(message)
messages = []
receiver = queue_client.get_receiver(idle_timeout=5)
for message in receiver:
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert receiver.running
assert len(messages) == 5
with receiver:
for message in receiver:
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert not receiver.running
assert len(messages) == 6
def mock_get_status(queue_client_status: QueueClient):
with queue_client_status.get_receiver() as receiver:
for i in [1, 2]:
message = receiver.next()
message_str = str(message)
print(f'Got message {message_str}')
message.complete()
def test_qsession_by_session_client_conn_str_receive_handler_peeklock(live_servicebus_config, partitioned_session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i))
sender.send(message)
with pytest.raises(ValueError):
session = queue_client.get_receiver(idle_timeout=5)
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
count = 0
for message in session:
print_message(message)
assert message.session_id == session_id
count += 1
message.complete()
assert count == 3
def test_session_get_set_state_with_receiver(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
queue_client = QueueClient.from_connection_string(
servicebus_namespace_connection_string,
name=servicebus_queue.name,
debug=False)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i))
sender.send(message)
with queue_client.get_receiver(session=session_id,
idle_timeout=5) as session:
assert session.get_session_state() == None
session.set_session_state("first_state")
count = 0
for m in session:
assert m.properties.group_id == session_id.encode('utf-8')
count += 1
with pytest.raises(InvalidHandlerState):
session.get_session_state()
assert count == 3
def main():
parser = ArgumentParser(description="An Azure ServiceBus Queue Consumer")
parser.add_argument("queue_name", help="The queue name to consume from")
parser.add_argument("--dlq",
action="store_true",
help="Connect to the dead letter queue")
args = parser.parse_args()
queue_name = args.queue_name
if (args.dlq):
queue_name = queue_name + "/$deadletterqueue"
# print("Endpoint: {0}".format(endpoint))
# print("QueueName: {0}".format(queue_name))
# Create the QueueClient
queue_client = QueueClient.from_connection_string(endpoint, queue_name)
# Receive the message from the queue
with queue_client.get_receiver() as queue_receiver:
messages = queue_receiver.fetch_next(timeout=3)
while messages:
for message in messages:
print(message)
message.complete()
messages = queue_receiver.fetch_next(timeout=3)
def test_session_by_session_client_conn_str_receive_handler_peeklock(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i))
sender.send(message)
with pytest.raises(ValueError):
session = queue_client.get_receiver(idle_timeout=5)
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
count = 0
for message in session:
print_message(message)
assert message.session_id == session_id
count += 1
message.complete()
assert count == 3
def test_session_by_queue_client_conn_str_receive_handler_receiveanddelete(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
sender.send(message)
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert session_id == session.session_id
assert session_id == message.session_id
with pytest.raises(MessageAlreadySettled):
message.complete()
assert not session.running
assert len(messages) == 10
time.sleep(30)
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert len(messages) == 0
def notification():
if request.method == 'POST':
notification = Notification()
notification.message = request.form['message']
notification.subject = request.form['subject']
notification.status = 'Notifications submitted'
notification.submitted_date = datetime.utcnow()
try:
db.session.add(notification)
db.session.commit()
notification_id = notification.id
print('Enqueueing notification_id: {} to queue: {}'.format(
notification_id, app.config.get('SERVICE_BUS_QUEUE_NAME')))
sb_queue_client = QueueClient.from_connection_string(app.config.get('SERVICE_BUS_CONNECTION_STRING'), app.config.get('SERVICE_BUS_QUEUE_NAME'))
msg = Message(str(notification_id))
print('notification ID to send $s', str(notification_id))
sb_queue_client.send(msg)
print('notification_id: {} enqueued to queue: {}'.format(
notification_id, app.config.get('SERVICE_BUS_QUEUE_NAME')))
return redirect('/Notifications')
except :
logging.error('log unable to save notification')
else:
return render_template('notification.html')
def send_batch():
params = {
'UUID': 'df53d1d8-39bf-4fea-a741-58d472664ce2',
'OBJECT': '8ce0f19f7644ebfa4ec1cdda8803a2db',
'CHECKSUM':
'2afeec307b0573339b3292e27e7971b5b040a5d7e8f7432339cae2fcd0eb936a',
'ARCHIEVE_TYPE': 'noark5',
'NAME': 'Per Buer',
'EMAIL': '*****@*****.**',
'INVITATIONID': 2
}
message = {
'action': 'argo-submit',
'params': params,
}
shutdown = {'action': 'shutdown'}
queue_client = QueueClient.from_connection_string(
os.getenv('AZ_SB_CON_KICKER'), os.getenv('AZ_SB_QUEUE'))
with queue_client.get_sender() as sender:
message = Message(json.dumps(message).encode('utf8'))
print('Sending message: ', message)
ret = sender.send(message)
print('ret:', ret)
message = Message(json.dumps(shutdown).encode('utf8'))
print('Sending message: ', message)
ret = sender.send(message)
print('Ret:', ret)
def notification():
if request.method == 'POST':
notification = Notification()
notification.message = request.form['message']
notification.subject = request.form['subject']
notification.status = 'Notifications submitted'
notification.submitted_date = datetime.utcnow()
try:
db.session.add(notification)
db.session.commit()
queue = QueueClient.from_connection_string(
app.config.get('SERVICE_BUS_CONNECTION_STRING'),
app.config.get('SERVICE_BUS_QUEUE_NAME'))
logging.error('msg str: %s', Message(int(notification.id)))
queue.send(Message('{}'.format(notification.id)))
return redirect('/Notifications')
except:
logging.error('log unable to save notification')
else:
return render_template('notification.html')
def notification():
if request.method == 'POST':
notification = Notification()
notification.message = request.form['message']
notification.subject = request.form['subject']
notification.status = 'Notifications submitted'
notification.submitted_date = datetime.utcnow()
try:
db.session.add(notification)
db.session.commit()
print('New notification Inserted successfully with message: {} and subject: {}'.format(
request.form['message'], request.form['subject']
))
# get id of inserted notification
notification_id = notification.id
print('Enqueueing notification_id: {} to queue: {}'.format(
notification_id, app.config.get('SERVICE_BUS_QUEUE_NAME')))
# Create the QueueClient
sb_queue_client = QueueClient.from_connection_string(
app.config.get('SERVICE_BUS_CONNECTION_STRING'), app.config.get('SERVICE_BUS_QUEUE_NAME')
)
# Enqueue notification_id to the service bus queue
msg = Message(str(notification_id))
sb_queue_client.send(msg)
print('notification_id: {} enqueued to queue: {}'.format(
notification_id, app.config.get('SERVICE_BUS_QUEUE_NAME')))
'''
##################################################
## TODO: Refactor This logic into an Azure Function
## Code below will be replaced by a message queue
#################################################
attendees = Attendee.query.all()
for attendee in attendees:
subject = '{}: {}'.format(attendee.first_name, notification.subject)
send_email(attendee.email, subject, notification.message)
notification.completed_date = datetime.utcnow()
notification.status = 'Notified {} attendees'.format(len(attendees))
db.session.commit()
# TODO Call servicebus queue_client to enqueue notification ID
#################################################
## END of TODO
#################################################
'''
return redirect('/Notifications')
except :
logging.error('log unable to save notification')
else:
return render_template('notification.html')
def test_session_by_session_client_conn_str_receive_handler_with_no_session(
live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=session_queue, debug=False)
session = queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5)
with pytest.raises(NoActiveSession):
session.open()
def test_session_by_session_client_conn_str_receive_handler_with_no_session(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
session = queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5)
with pytest.raises(NoActiveSession):
session.open()
def test_sb_client_readonly_credentials(servicebus_conn_str_readonly, standard_queue):
client = ServiceBusClient.from_connection_string(servicebus_conn_str_readonly, debug=False)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
client = QueueClient.from_connection_string(servicebus_conn_str_readonly, name=standard_queue)
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
with pytest.raises(ServiceBusAuthorizationError):
client.send(Message("test"))
def get_sb_sender(conn_str, queue):
try:
queue_client = QueueClient.from_connection_string(conn_str, queue)
return queue_client.get_sender()
except Exception as exception:
logging.error(f'Could not connect to Service Bus Queue: {exception}')
logging.error(
f'Connection string: {conn_str}'
) # Todo: Potential security issue here. Filter out parts of the string?
logging.error(f'Queue: {queue}')
exit(SBERROR)
def test_sb_client_readonly_credentials(servicebus_conn_str_readonly, standard_queue):
client = ServiceBusClient.from_connection_string(servicebus_conn_str_readonly, debug=True)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
client = QueueClient.from_connection_string(servicebus_conn_str_readonly, name=standard_queue)
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
with pytest.raises(ServiceBusAuthorizationError):
client.send(Message("test"))
def test_session_by_session_client_conn_str_receive_handler_with_no_session(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
queue_client = QueueClient.from_connection_string(
servicebus_namespace_connection_string,
name=servicebus_queue.name,
debug=False)
session = queue_client.get_receiver(session=NEXT_AVAILABLE,
idle_timeout=5)
with pytest.raises(NoActiveSession):
session.open()
def enqueue(message, queue_param_name):
parser = ConfigParser()
parser.read('config.ini')
connection_string = parser.get('AZURE', 'SERVICE_BUS_CONNECTION_STRING')
queue_name = parser.get('AZURE', queue_param_name)
# Create the QueueClient
queue_client = QueueClient.from_connection_string(connection_string,
queue_name)
# Send a test message to the queue
msg = Message(message)
queue_client.send(msg)
def test_pqueue_by_queue_client_conn_str_receive_handler_with_autolockrenew(
live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=False)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("{}".format(i))
sender.send(message)
renewer = AutoLockRenew()
messages = []
with queue_client.get_receiver(idle_timeout=5,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as receiver:
for message in receiver:
if not messages:
messages.append(message)
assert not message.expired
renewer.register(message, timeout=60)
print("Registered lock renew thread", message.locked_until,
datetime.now())
time.sleep(50)
print("Finished first sleep", message.locked_until)
assert not message.expired
time.sleep(25)
print("Finished second sleep", message.locked_until,
datetime.now())
assert message.expired
try:
message.complete()
raise AssertionError("Didn't raise MessageLockExpired")
except MessageLockExpired as e:
assert isinstance(e.inner_exception, AutoLockRenewTimeout)
else:
if message.expired:
print("Remaining messages", message.locked_until,
datetime.now())
assert message.expired
with pytest.raises(MessageLockExpired):
message.complete()
else:
assert message.header.delivery_count >= 1
print("Remaining messages", message.locked_until,
datetime.now())
messages.append(message)
message.complete()
renewer.shutdown()
assert len(messages) == 11
def dequeue_loop(callback):
parser = ConfigParser()
parser.read('config.ini')
connection_string = parser.get('AZURE', 'SERVICE_BUS_CONNECTION_STRING')
queue_name = parser.get('AZURE', 'SERVICE_BUS_INPUT_QUEUE')
# Create the QueueClient
queue_client = QueueClient.from_connection_string(connection_string,
queue_name)
messages = queue_client.get_receiver()
for message in messages:
callback(message)
message.complete()
def test_session_by_session_client_conn_str_receive_handler_with_inactive_session(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
session_id = str(uuid.uuid4())
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert not session.running
assert len(messages) == 0
def test_qsession_by_session_client_conn_str_receive_handler_with_inactive_session(live_servicebus_config, partitioned_session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_session_queue,
debug=True)
session_id = str(uuid.uuid4())
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert not session.running
assert len(messages) == 0
def test_session_by_conn_str_receive_handler_with_autolockrenew(live_servicebus_config, session_queue):
session_id = str(uuid.uuid4())
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("{}".format(i))
sender.send(message)
renewer = AutoLockRenew()
messages = []
with queue_client.get_receiver(session=session_id, idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as session:
renewer.register(session, timeout=60)
print("Registered lock renew thread", session.locked_until, datetime.now())
with pytest.raises(SessionLockExpired):
for message in session:
if not messages:
print("Starting first sleep")
time.sleep(40)
print("First sleep {}".format(session.locked_until - datetime.now()))
assert not session.expired
with pytest.raises(TypeError):
message.expired
assert message.locked_until is None
with pytest.raises(TypeError):
message.renew_lock()
assert message.lock_token is None
message.complete()
messages.append(message)
elif len(messages) == 1:
print("Starting second sleep")
time.sleep(40)
print("Second sleep {}".format(session.locked_until - datetime.now()))
assert session.expired
assert isinstance(session.auto_renew_error, AutoLockRenewTimeout)
try:
message.complete()
raise AssertionError("Didn't raise SessionLockExpired")
except SessionLockExpired as e:
assert isinstance(e.inner_exception, AutoLockRenewTimeout)
messages.append(message)
renewer.shutdown()
assert len(messages) == 2
def dequeue():
parser = ConfigParser()
parser.read('config.ini')
connection_string = parser.get('AZURE', 'SERVICE_BUS_CONNECTION_STRING')
queue_name = parser.get('AZURE', 'SERVICE_BUS_INPUT_QUEUE')
# Create the QueueClient
queue_client = QueueClient.from_connection_string(connection_string,
queue_name)
# Receive the message from the queue
with queue_client.get_receiver() as queue_receiver:
messages = queue_receiver.fetch_next(timeout=3)
for message in messages:
print(message)
message.complete()
def __init__(self):
self.config = configparser.ConfigParser()
self.config.read('config.ini')
# Creates an instance of a speech config with subscription key and service region.
self.speech_config = speechsdk.SpeechConfig(
subscription=self.config['speech_text']['speech_key'],
region=self.config['speech_text']['service_region'])
# Create the QueueClient
conn_string = self.config['service_bus']['endpoint'] + ";" + \
self.config['service_bus']['accesskeyname'] + ";" + \
self.config['service_bus']['accesskey']
self.queue_client = QueueClient.from_connection_string(
conn_string, self.config['service_bus']['msg_queue'])
def extract_text():
if request.method == 'POST':
data = request.get_json()
image_data_url = data['image_url']
messID = data['messageID']
image_data = requests.get(image_data_url)
if image_data.status_code == 200:
texual_data = hcdf_form_text_extraction.ocr_extraction()
text = texual_data.text_extract(image_data)
text_new = hcdf_form_text_extraction.text_cleaning(text)
entity_mapping = hcdf_form_text_extraction.entity_extraction()
print("before extraction", entity_mapping.info)
entity_mapping.get_entites(text_new)
print("after extraction", entity_mapping.info)
gui_id = uuid.uuid1()
#blob_service_client = BlobServiceClient.from_connection_string("DefaultEndpointsProtocol=https;AccountName=imagecleaningpreprocesso;AccountKey=5nHc9CX548BdVn4qlJjRtEg16Tk3kk24k2V0hpzEuhdRJK5MNPFoA/MCI6GEAiDb6CW0OnJqWM+hVhwna9euDA==;EndpointSuffix=core.windows.net")
blob_service_client = BlobServiceClient.from_connection_string(
"DefaultEndpointsProtocol=https;AccountName=imagecleaningpreprocesso;AccountKey=vCfA3TaLSsssty9aYTvu44Jx014h+/A/hetMIz9qYgzNYGJi2TexnDI4N03vZJZg4yxL043OaduW2xDweIKxcw==;EndpointSuffix=core.windows.net"
)
blob_client = blob_service_client.get_blob_client(
container="airesponserecieverblob", blob=str(gui_id))
blob_client.upload_blob(json.dumps(entity_mapping.info))
queue_client = QueueClient.from_connection_string(
"Endpoint=sb://hwservicebusqueue.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=zO2d6Pi5aRPt3S6Cx37GbqoPoRxO2RgQreLn4A47zow=",
"airesonsequeue")
# QueueClient.from_connection_string("Endpoint=sb://hwservicebusqueue.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=BG3vfgT/3w0DL3Wa8FFLXZ6Nh5Mgrh65aRmuXigcuJc=", "airesonsequeue")
mess_body = "sample Text message" + ":" + str(gui_id)
msg = Message(mess_body)
print(msg.message)
# Message.MessageId=str(gui_id)
queue_client.send(msg)
# url='https://msairesponsereciever20191104013958.azurewebsites.net/api/AIResponse/GetPostedImages'
# send_data={"Response":json.dumps(entity_mapping.info),"MessageId":messID}
# headers = {'Content-Type': 'application/json'}
# x=requests.post(url,data=json.dumps(send_data),headers=headers)
# print("check the status code for response",x.status_code)
return "success"
# return pd.DataFrame.from_dict(entity_mapping.info,orient='index').to_html()
else:
return redirect(url_for('error_page'))
return '''
def test_pqueue_by_queue_client_conn_str_receive_handler_with_autolockrenew(live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("{}".format(i))
sender.send(message)
renewer = AutoLockRenew()
messages = []
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
for message in receiver:
if not messages:
messages.append(message)
assert not message.expired
renewer.register(message, timeout=60)
print("Registered lock renew thread", message.locked_until, datetime.now())
time.sleep(50)
print("Finished first sleep", message.locked_until)
assert not message.expired
time.sleep(25)
print("Finished second sleep", message.locked_until, datetime.now())
assert message.expired
try:
message.complete()
raise AssertionError("Didn't raise MessageLockExpired")
except MessageLockExpired as e:
assert isinstance(e.inner_exception, AutoLockRenewTimeout)
else:
if message.expired:
print("Remaining messages", message.locked_until, datetime.now())
assert message.expired
with pytest.raises(MessageLockExpired):
message.complete()
else:
assert message.header.delivery_count >= 1
print("Remaining messages", message.locked_until, datetime.now())
messages.append(message)
message.complete()
renewer.shutdown()
assert len(messages) == 11
def test_queue_by_queue_client_conn_str_receive_handler_peeklock(
live_servicebus_config, standard_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=standard_queue, debug=False)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
message.enqueue_sequence_number = i
sender.send(message)
receiver = queue_client.get_receiver(idle_timeout=5)
count = 0
for message in receiver:
print_message(message)
count += 1
message.complete()
assert count == 10
def test_sb_client_writeonly_credentials(servicebus_conn_str_writeonly, standard_queue):
client = ServiceBusClient.from_connection_string(servicebus_conn_str_writeonly)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
client = QueueClient.from_connection_string(servicebus_conn_str_writeonly, name=standard_queue, debug=True)
with pytest.raises(ServiceBusAuthorizationError):
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
client.send([Message("test1"), Message("test2")])
with pytest.raises(TypeError):
client.send("cat")
with pytest.raises(TypeError):
client.send(1234)
with pytest.raises(TypeError):
client.send([1,2,3])
with pytest.raises(TypeError):
client.send([Message("test1"), "test2"])
def test_pqueue_by_queue_client_conn_str_receive_handler_peeklock(live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
message.enqueue_sequence_number = i
sender.send(message)
receiver = queue_client.get_receiver(idle_timeout=5)
count = 0
for message in receiver:
print_message(message)
count += 1
message.complete()
assert count == 10
def test_session_get_set_state_with_receiver(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i))
sender.send(message)
with queue_client.get_receiver(session=session_id, idle_timeout=5) as session:
assert session.get_session_state() == None
session.set_session_state("first_state")
count = 0
for m in session:
assert m.properties.group_id == session_id.encode('utf-8')
count += 1
with pytest.raises(InvalidHandlerState):
session.get_session_state()
assert count == 3
def test_session_by_session_client_conn_str_receive_handler_with_stop(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i))
sender.send(message)
messages = []
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
for message in session:
assert session_id == session.session_id
assert session_id == message.session_id
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert session.running
assert len(messages) == 5
with session:
for message in session:
assert session_id == session.session_id
assert session_id == message.session_id
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert not session.running
assert len(messages) == 6
def test_example_send_receive_service_bus(live_servicebus_config, standard_queue, session_queue):
import os
import datetime
from azure.servicebus import ServiceBusClient, ServiceBusResourceNotFound
from azure.servicebus import Message
client = create_servicebus_client()
try:
# [START create_queue_client_directly]
import os
from azure.servicebus import QueueClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_client = QueueClient.from_connection_string(connection_str, name="MyQueue")
queue_properties = queue_client.get_properties()
# [END create_queue_client_directly]
except ServiceBusResourceNotFound:
pass
try:
# [START create_topic_client_directly]
import os
from azure.servicebus import TopicClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
topic_client = TopicClient.from_connection_string(connection_str, name="MyTopic")
properties = topic_client.get_properties()
# [END create_topic_client_directly]
except ServiceBusResourceNotFound:
pass
try:
# [START create_sub_client_directly]
import os
from azure.servicebus import SubscriptionClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
subscription_client = SubscriptionClient.from_connection_string(
connection_str, name="MySub", topic="MyTopic")
properties = subscription_client.get_properties()
# [END create_sub_client_directly]
except ServiceBusResourceNotFound:
pass
queue_client = client.get_queue(standard_queue)
session_client = client.get_queue(session_queue)
# [START get_sender]
with queue_client.get_sender() as queue_sender:
queue_sender.send(Message("First"))
queue_sender.send(Message("Second"))
# [END get_sender]
# [START send_message_service_bus_multiple]
from azure.servicebus import Message
message1 = Message("Hello World!")
message2 = Message("How are you?")
queue_client.send([message1, message2])
# [END send_message_service_bus_multiple]
# [START send_complex_message]
message = Message("Hello World!")
message.session_id = "MySessionID"
message.partition_key = "UsingSpecificPartition"
message.user_properties = {'data': 'custom_data'}
message.time_to_live = datetime.timedelta(seconds=30)
queue_client.send(message)
# [END send_complex_message]
# [START send_batch_message]
from azure.servicebus import BatchMessage
def batched_data():
for i in range(100):
yield "Batched Message no. {}".format(i)
message = BatchMessage(batched_data())
results = queue_client.send(message)
# [END send_batch_message]
# [START send_message_service_bus]
from azure.servicebus import Message
message = Message("Hello World!")
queue_client.send(message)
# [END send_message_service_bus]
# [START get_receiver]
with queue_client.get_receiver() as queue_receiver:
messages = queue_receiver.fetch_next(timeout=3)
# [END get_receiver]
# [START peek_messages_service_bus]
# Specify the number of messages to peek at.
pending_messages = queue_client.peek(count=5)
# [END peek_messages_service_bus]
# [START auto_lock_renew_message]
from azure.servicebus import AutoLockRenew
lock_renewal = AutoLockRenew(max_workers=4)
with queue_client.get_receiver(idle_timeout=3) as queue_receiver:
for message in queue_receiver:
# Auto renew message for 1 minute.
lock_renewal.register(message, timeout=60)
process_message(message)
message.complete()
# [END auto_lock_renew_message]
# [START auto_lock_renew_session]
from azure.servicebus import AutoLockRenew
lock_renewal = AutoLockRenew(max_workers=4)
with session_client.get_receiver(session="MySessionID", idle_timeout=3) as session:
# Auto renew session lock for 2 minutes
lock_renewal.register(session, timeout=120)
for message in session:
process_message(message)
message.complete()
# [END auto_lock_renew_session]
# [START list_sessions_service_bus]
session_ids = session_client.list_sessions()
# List sessions updated after specific time
import datetime
yesterday = datetime.datetime.today() - datetime.timedelta(days=1)
session_ids = session_client.list_sessions(updated_since=yesterday)
# [END list_sessions_service_bus]
try:
# [START receive_deferred_messages_service_bus]
seq_numbers = []
with queue_client.get_receiver(idle_timeout=3) as queue_receiver:
for message in queue_receiver:
seq_numbers.append(message.sequence_number)
message.defer()
# Receive deferred messages - provide sequence numbers of
# messages which were deferred.
deferred = queue_client.receive_deferred_messages(sequence_numbers=seq_numbers)
# [END receive_deferred_messages_service_bus]
except ValueError:
pass
deferred = []
try:
# [START settle_deferred_messages_service_bus]
queue_client.settle_deferred_messages('completed', deferred)
# [END settle_deferred_messages_service_bus]
except ValueError:
pass
# [START get_dead_letter_receiver]
# Get dead lettered messages
with queue_client.get_deadletter_receiver(idle_timeout=1) as dead_letter_receiver:
# Receive dead lettered message continuously
for message in dead_letter_receiver:
print(message)
message.complete()
