def test_subscription_by_sas_token_credential_conn_str_send_basic(self, servicebus_namespace, servicebus_namespace_key_name, servicebus_namespace_primary_key, servicebus_topic, servicebus_subscription, **kwargs):
fully_qualified_namespace = servicebus_namespace.name + '.servicebus.windows.net'
with ServiceBusClient(
fully_qualified_namespace=fully_qualified_namespace,
credential=ServiceBusSharedKeyCredential(
policy=servicebus_namespace_key_name,
key=servicebus_namespace_primary_key
),
logging_enable=False
) as sb_client:
with sb_client.get_topic_sender(topic_name=servicebus_topic.name) as sender:
message = Message(b"Sample topic message")
sender.send(message)
with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
idle_timeout=5
) as receiver:
count = 0
for message in receiver:
count += 1
message.complete()
assert count == 1
def IndexResult(self, result):
properties = { 'data_type' : 'sql_index_target', 'dumpling_id': self.data['RowKey']}
msg = Message(result.encode('ascii'))
msg.custom_properties = properties;
_bus_service.send_queue_message("dataworkerqueue", msg)
def sample_queue_send_receive_batch(sb_config, queue):
client = ServiceBusClient(
service_namespace=sb_config['hostname'],
shared_access_key_name=sb_config['key_name'],
shared_access_key_value=sb_config['access_key'],
debug=True)
queue_client = client.get_queue(queue)
with queue_client.get_sender() as sender:
for i in range(100):
message = Message("Sample message no. {}".format(i))
sender.send(message)
with queue_client.get_receiver(idle_timeout=1, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
total = 0
# Receive list of messages as a batch
batch = receiver.fetch_next(max_batch_size=10)
for message in batch:
print("Message: {}".format(message))
print("Sequence number: {}".format(message.sequence_number))
message.complete()
total += 1
# Receive messages as a continuous generator
for message in receiver:
print("Message: {}".format(message))
print("Sequence number: {}".format(message.sequence_number))
message.complete()
total += 1
print("Received total {} messages".format(total))
def copy_message(msg: Message) -> Message:
"""Create a copy of the service bus message given."""
msg_body = b''
for b in msg.body:
msg_body += b
new_msg = Message(msg_body)
new_msg.properties = msg.properties
return new_msg
def send_msg(self):
for i in range(10):
if i % 2:
msg = Message('Msg {0}'.format(i).encode('utf-8'),
custom_properties={'num': '1'})
else:
msg = Message('Msg {0}'.format(i).encode('utf-8'),
custom_properties={'num': '2'})
self.bus_service.send_topic_message('repertorysniff', msg)
def IndexResult(self, result):
properties = {
'data_type': 'sql_index_target',
'dumpling_id': self.data['RowKey']
}
msg = Message(result.encode('ascii'))
msg.custom_properties = properties
_bus_service.send_queue_message("dataworkerqueue", msg)
async def send_msg(settings, body, user_props, system_props):
client = ServiceBusClient.from_connection_string(
conn_str=settings.conn_str)
async with client:
sender = client.get_topic_sender(topic_name=settings.topic)
async with sender:
msg = Message(body, subject=system_props.get('Label', None))
msg.annotations = system_props
msg.user_properties = user_props
await sender.send(msg)
print(f"Successfully sent message to topic '{settings.topic}'")
pass
async def send_batch_message(sender):
batch_message = await sender.create_batch()
while True:
try:
message = Message("DATA" * 256)
message.session_id = SESSION_ID
batch_message.add(message)
except ValueError:
# BatchMessage object reaches max_size.
# New BatchMessage object can be created here to send more data.
break
await sender.send(batch_message)
async def sample_session_send_receive_with_pool_async(connection_string, queue_name):
concurrent_receivers = 5
sessions = [str(uuid.uuid4()) for i in range(concurrent_receivers)]
client = ServiceBusClient.from_connection_string(connection_string)
for session_id in sessions:
async with client.get_queue_sender(queue_name) as sender:
await asyncio.gather(*[sender.send(Message("Sample message no. {}".format(i), session_id=session_id)) for i in range(20)])
await sender.send(Message("shutdown", session_id=session_id))
receive_sessions = [message_processing(client, queue_name) for _ in range(concurrent_receivers)]
await asyncio.gather(*receive_sessions)
def test_subscription_by_servicebus_client_receive_batch_with_deadletter(
self, servicebus_namespace_connection_string, servicebus_topic,
servicebus_subscription, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as receiver:
with sb_client.get_topic_sender(
servicebus_topic.name) as sender:
for i in range(10):
message = Message(
"Dead lettered message no. {}".format(i))
sender.send_messages(message)
count = 0
messages = receiver.receive_messages()
while messages:
for message in messages:
print_message(_logger, message)
count += 1
message.dead_letter(reason="Testing reason",
description="Testing description")
messages = receiver.receive_messages()
assert count == 10
with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(_logger, message)
message.complete()
count += 1
assert count == 0
with sb_client.get_subscription_deadletter_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock) as dl_receiver:
count = 0
for message in dl_receiver:
message.complete()
count += 1
assert message.user_properties[
b'DeadLetterReason'] == b'Testing reason'
assert message.user_properties[
b'DeadLetterErrorDescription'] == b'Testing description'
assert count == 10
def _ConstructMessage(self):
if self.send_batch_size != None:
batch = BatchMessage()
for _ in range(self.send_batch_size):
message = Message(
self.PreProcessMessageBody("a" * self.message_size))
self.PreProcessMessage(message)
batch.add(message)
self.PreProcessMessageBatch(batch)
return batch
else:
message = Message(
self.PreProcessMessageBody("a" * self.message_size))
self.PreProcessMessage(message)
return message
async def example_send_and_receive_async():
servicebus_sender = await example_create_servicebus_sender_async()
servicebus_receiver = await example_create_servicebus_receiver_async()
from azure.servicebus import Message
# [START send_async]
async with servicebus_sender:
message = Message("Hello World")
await servicebus_sender.send_messages(message)
# [END send_async]
# [START create_batch_async]
async with servicebus_sender:
batch_message = await servicebus_sender.create_batch()
batch_message.add(Message("Single message inside batch"))
# [END create_batch_async]
# [START peek_messages_async]
async with servicebus_receiver:
messages = await servicebus_receiver.peek_messages()
for message in messages:
print(str(message))
# [END peek_messages_async]
# [START receive_async]
async with servicebus_receiver:
messages = await servicebus_receiver.receive_messages(max_wait_time=5)
for message in messages:
print(str(message))
await message.complete()
# [END receive_async]
# [START receive_forever_async]
async with servicebus_receiver:
async for message in servicebus_receiver.get_streaming_message_iter():
print(str(message))
await message.complete()
# [END receive_forever_async]
# [START auto_lock_renew_message_async]
from azure.servicebus.aio import AutoLockRenewer
lock_renewal = AutoLockRenewer()
async with servicebus_receiver:
async for message in servicebus_receiver:
lock_renewal.register(message, timeout=60)
await process_message(message)
await message.complete()
def run(self):
i = 0
while self.running:
i += 1
msg = Message(b'Test Message1')
self.bus_service.send_topic_message(topic_name, msg)
self.rate.increment()
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()
db.session.refresh(notification)
notid = '{}'.format(notification.id)
try:
msg = Message(notid)
sentResult = queue_client.send(msg)
# logging.info(msg)
print(msg)
except Exception as e:
logging.error(
'Error occurred while sending message to queue {}', str(e))
return redirect('/Notifications')
except:
logging.error('Unable to save notification')
else:
return render_template('notification.html')
def queue_event(event_data):
"""send slack event data to service bus message queue"""
data = json.dumps(event_data)
with ServiceBusClient.from_connection_string(connstr) as client:
with client.get_queue_sender(queue_name) as sender:
single_message = Message(data)
sender.send_messages(single_message)
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 renew_lock_on_session_of_the_sessionful_entity():
servicebus_client = ServiceBusClient.from_connection_string(conn_str=CONNECTION_STR)
with servicebus_client:
with servicebus_client.get_queue_sender(queue_name=SESSION_QUEUE_NAME) as sender:
msgs_to_send = [Message("session message: {}".format(i), session_id='SESSION') for i in range(10)]
sender.send_messages(msgs_to_send)
print('Send messages to sessionful queue.')
renewer = AutoLockRenew()
with servicebus_client.get_queue_session_receiver(
queue_name=SESSION_QUEUE_NAME,
session_id='SESSION',
prefetch=10
) as receiver:
# automatically renew the lock on the session for 100 seconds
renewer.register(receiver.session, timeout=100)
print('Register session into AutoLockRenew.')
received_msgs = receiver.receive_messages(max_batch_size=10, max_wait_time=5)
time.sleep(100) # message handling for long period (E.g. application logic)
for msg in received_msgs:
msg.complete()
print('Complete messages.')
renewer.close()
def renew_lock_on_message_received_from_non_sessionful_entity():
servicebus_client = ServiceBusClient.from_connection_string(conn_str=CONNECTION_STR)
with servicebus_client:
with servicebus_client.get_queue_sender(queue_name=QUEUE_NAME) as sender:
msgs_to_send = [Message("message: {}".format(i)) for i in range(10)]
sender.send_messages(msgs_to_send)
print('Send messages to non-sessionful queue.')
# Can also be called via "with AutoLockRenew() as renewer" to automate shutdown.
renewer = AutoLockRenew()
with servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME, prefetch=10) as receiver:
received_msgs = receiver.receive_messages(max_batch_size=10, max_wait_time=5)
for msg in received_msgs:
# automatically renew the lock on each message for 100 seconds
renewer.register(msg, timeout=100)
print('Register messages into AutoLockRenew done.')
time.sleep(100) # message handling for long period (E.g. application logic)
for msg in received_msgs:
msg.complete() # Settling the message deregisters it from the AutoLockRenewer
print('Complete messages.')
renewer.close()
def sample_session_send_receive_with_pool(sb_config, queue):
concurrent_receivers = 5
sessions = [str(uuid.uuid4()) for i in range(2 * concurrent_receivers)]
client = ServiceBusClient(service_namespace=sb_config['hostname'],
shared_access_key_name=sb_config['key_name'],
shared_access_key_value=sb_config['access_key'],
debug=False)
queue_client = client.get_queue(queue)
for session_id in sessions:
with queue_client.get_sender(session=session_id) as sender:
for i in range(20):
message = Message("Sample message no. {}".format(i))
sender.send(message)
all_messages = []
futures = []
with concurrent.futures.ThreadPoolExecutor(
max_workers=concurrent_receivers) as thread_pool:
for _ in range(concurrent_receivers):
futures.append(
thread_pool.submit(message_processing, queue_client,
all_messages))
concurrent.futures.wait(futures)
print("Received total {} messages across {} sessions.".format(
len(all_messages), 2 * concurrent_receivers))
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()
logging.info("Record just created")
try:
db.session.add(notification)
db.session.commit()
##################################################
## TODO: Refactor This logic into an Azure Function
## Code below will be replaced by a message queue
#################################################
notification_id = notification.id
msg = Message(str(notification_id))
queue_client.send(msg)
#################################################
## END of TODO
#################################################
return redirect('/Notifications')
except :
logging.error('log unable to save notification')
else:
return render_template('notification.html')
async def on_message(message):
if message.author == discordclient.user:
return None #Bot ignores itself
if (message.guild is None or message.content.startswith(commandprefix)
or 'http' in message.content): #Adding support for Private Message
discordmessage = {}
discordmessage['messageid'] = message.id
discordmessage['authorid'] = message.author.id
discordmessage['authordisplayname'] = message.author.display_name
discordmessage['authormention'] = message.author.mention
if discordclient.user in message.mentions:
discordmessage['botmention'] = True
if message.guild is not None:
discordmessage['guildid'] = message.guild.id
discordmessage['guildchannelid'] = message.channel.id
discordmessage['guildchannelname'] = message.channel.name
discordmessage['guildchannelmention'] = message.channel.mention
discordmessage[
'admin'] = message.author.guild_permissions.administrator
discordmessage[
'kick_members'] = message.author.guild_permissions.kick_members
discordmessage[
'ban_members'] = message.author.guild_permissions.ban_members
else:
discordmessage['privatemessage'] = True
discordmessage['privatemessagechannelid'] = message.channel.id
discordmessage['message'] = message.content
discordmessage['type'] = 'message'
jsonmessage = json.dumps(discordmessage)
eventdata = (Message(jsonmessage))
servicebusclient.send(eventdata)
def sendwork():
work = request.get_json()['work']
print("Creating job with work: ", work)
bus_service.send_queue_message(queueConf['queue_name'], Message(work))
return SUCCESS
async def schedule_single_message(sender):
message = Message("Message to be scheduled")
scheduled_time_utc = datetime.datetime.utcnow() + datetime.timedelta(
seconds=30)
sequence_number = await sender.schedule_messages(message,
scheduled_time_utc)
return sequence_number
async def main():
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=CONNECTION_STR)
async with servicebus_client:
sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
messages = [Message("Message to be deadlettered") for _ in range(10)]
async with sender:
await sender.send_messages(messages)
print('dead lettering messages')
receiver = servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME)
async with receiver:
received_msgs = await receiver.receive_messages(
max_message_count=10, max_wait_time=5)
for msg in received_msgs:
print(str(msg))
await msg.dead_letter()
print('receiving deadlettered messages')
dlq_receiver = servicebus_client.get_queue_receiver(
queue_name=QUEUE_NAME,
sub_queue=SubQueue.DeadLetter,
prefetch_count=10)
async with dlq_receiver:
received_msgs = await dlq_receiver.receive_messages(
max_message_count=10, max_wait_time=5)
for msg in received_msgs:
print(str(msg))
await msg.complete()
def send(self, jsondict):
t = json.dumps(jsondict)
msg = Message(t)
logger.info(t)
Q = jsondict['medium'] + '_sender'
self.bus_service.send_queue_message(Q, msg)
def test_does_not_call_the_download_service_when_invalid_event_received(
self):
message = Message(body="")
self.bus.receive_subscription_message.return_value = message
self.provider.provide()
self.blob.download.assert_not_called()
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
msg = Message(str(notification_id))
# Call servicebus queue_client to enqueue notification ID
queue_client.send(msg)
# 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()
return redirect('/Notifications')
except Exception as e:
logging.error(e)
logging.error('log unable to save notification')
else:
return render_template('notification.html')
def sample_session_send_receive_with_pool(connection_string, queue_name):
concurrent_receivers = 5
sessions = [str(uuid.uuid4()) for i in range(2 * concurrent_receivers)]
with ServiceBusClient.from_connection_string(connection_string) as client:
with client.get_queue_sender(queue_name) as sender:
for session_id in sessions:
for i in range(20):
message = Message("Sample message no. {}".format(i),
session_id=session_id)
sender.send_messages(message)
all_messages = []
futures = []
with concurrent.futures.ThreadPoolExecutor(
max_workers=concurrent_receivers) as thread_pool:
for _ in range(concurrent_receivers):
futures.append(
thread_pool.submit(message_processing, client, queue_name,
all_messages))
concurrent.futures.wait(futures)
print("Received total {} messages across {} sessions.".format(
len(all_messages), len(sessions)))
async def main():
servicebus_client = ServiceBusClient.from_connection_string(
conn_str=CONNECTION_STR)
async with servicebus_client:
sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
messages = [Message("Message to be deferred") for _ in range(10)]
async with sender:
await sender.send_messages(messages)
receiver = servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME)
async with receiver:
received_msgs = await receiver.receive_messages(max_batch_size=10,
max_wait_time=5)
deferred_sequenced_numbers = []
for msg in received_msgs:
print("Deferring msg: {}".format(str(msg)))
deferred_sequenced_numbers.append(msg.sequence_number)
await msg.defer()
if deferred_sequenced_numbers:
received_deferred_msg = await receiver.receive_deferred_messages(
sequence_numbers=deferred_sequenced_numbers)
for msg in received_deferred_msg:
print("Completing deferred msg: {}".format(str(msg)))
await msg.complete()
else:
print("No messages received.")
def test_send_queue_message_with_custom_message_properties(self):
# Arrange
self._create_queue(self.queue_name)
# Act
props = {
'hello': 'world',
'foo': 42,
'active': True,
'deceased': False,
'large': 8555111000,
'floating': 3.14,
'dob': datetime(2011, 12, 14)
}
sent_msg = Message('message with properties', custom_properties=props)
self.sbs.send_queue_message(self.queue_name, sent_msg)
received_msg = self.sbs.receive_queue_message(self.queue_name, True, 5)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(received_msg.custom_properties['hello'], 'world')
self.assertEquals(received_msg.custom_properties['foo'], 42)
self.assertEquals(received_msg.custom_properties['active'], True)
self.assertEquals(received_msg.custom_properties['deceased'], False)
self.assertEquals(received_msg.custom_properties['large'], 8555111000)
self.assertEquals(received_msg.custom_properties['floating'], 3.14)
self.assertEquals(received_msg.custom_properties['dob'],
datetime(2011, 12, 14))
def test_send_queue_message(self):
# Arrange
self._create_queue(self.queue_name)
sent_msg = Message('send message')
# Act
self.sbs.send_queue_message(self.queue_name, sent_msg)
def test_send_topic_message(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
# Act
self.sbs.send_topic_message(self.topic_name, sent_msg)
def sample_session_send_receive_batch(sb_config, queue):
session_id = str(uuid.uuid4())
client = ServiceBusClient(
service_namespace=sb_config['hostname'],
shared_access_key_name=sb_config['key_name'],
shared_access_key_value=sb_config['access_key'],
debug=True)
queue_client = client.get_queue(queue)
with queue_client.get_sender(session=session_id) as sender:
for i in range(100):
message = Message("Sample message no. {}".format(i))
sender.send(message)
sender.send(Message("shutdown"))
with queue_client.get_receiver(session=session_id) as session:
session.set_session_state("START")
for message in session:
print(message)
message.complete()
if str(message) == "shutdown":
session.set_session_state("END")
break
def doSomething():
# Write to log file and update Slack
hostname = socket.gethostname()
logMessage = "SIMULATOR (" + hostname + "): Creating statistics starting @ " + str(time.ctime())
log = Log()
log.info(logMessage)
notify.info(logMessage)
# Gather environment variables
AZURE_SB_SERVICE_NAMESPACE = os.getenv('AZURE_SB_SERVICE_NAMESPACE')
AZURE_SB_SHARED_ACCESS_KEY_NAME = os.getenv('AZURE_SB_SHARED_ACCESS_KEY_NAME')
AZURE_SB_SHARED_ACCESS_KEY = os.getenv('AZURE_SB_SHARED_ACCESS_KEY')
# Start loop and write random messages to Azure Service Bus Queue
x=0
while True:
x=x+1
time.sleep(2)
# Write message to SB Queue
sb_service = ServiceBusService(service_namespace=AZURE_SB_SERVICE_NAMESPACE,shared_access_key_name=AZURE_SB_SHARED_ACCESS_KEY_NAME,shared_access_key_value=AZURE_SB_SHARED_ACCESS_KEY)
msg_text = "Update number: " + str(x)
msg = Message(msg_text.encode("utf-8"))
# Randomly create data for SB Queue
r = random.randint(1, 10)
if r == 1:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'40.8','pressure':'61.93','humidity':'20','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 2:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'50.8','pressure':'62.83','humidity':'30','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 3:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'60.8','pressure':'63.73','humidity':'40','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 4:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'70.8','pressure':'64.63','humidity':'50','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 5:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'80.8','pressure':'51.93','humidity':'60','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 6:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'90.8','pressure':'55.93','humidity':'70','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 7:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'45.2','pressure':'34.99','humidity':'45','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 8:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'55.2','pressure':'38.99','humidity':'55','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 9:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'65.2','pressure':'36.99','humidity':'65','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
else:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'75.2','pressure':'71.77','humidity':'38','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
log.info("Message #" + str(x) + " posted.")
def test_example_create_sender_send_message(live_servicebus_config, standard_queue, session_queue):
import os
from azure.servicebus import ServiceBusClient
from azure.servicebus import Message
from azure.servicebus.send_handler import Sender, SessionSender
sb_client = create_servicebus_client()
queue_client = sb_client.get_queue(standard_queue)
session_client = sb_client.get_queue(session_queue)
# [START create_sender_client]
from azure.servicebus import Message
with queue_client.get_sender() as sender:
sender.send(Message("Hello World!"))
# [END create_sender_client]
# [START create_session_sender_client]
from azure.servicebus import Message
with session_client.get_sender(session="MySessionID") as sender:
sender.send(Message("Hello World!"))
with session_client.get_sender() as sender:
message = Message("Hello World!")
message.session_id = "MySessionID"
sender.send(message)
# [END create_session_sender_client]
# [START send_message]
# Send the message via sender
with queue_client.get_sender() as sender:
message = Message("Hello World!")
sender.send(message)
# [END send_message]
# [START scheduling_messages]
with queue_client.get_sender() as sender:
message = Message("Hello World!")
today = datetime.datetime.today()
# Schedule the message 5 days from today
sequence_numbers = sender.schedule(today + datetime.timedelta(days=5), message)
# [END scheduling_messages]
# [START cancel_scheduled_messages]
with queue_client.get_sender() as sender:
message = Message("Hello World!")
today = datetime.datetime.today()
# Schedule the message 5 days from today
sequence_numbers = sender.schedule(today + datetime.timedelta(days=5), message)
# Cancel scheduled messages
sender.cancel_scheduled_messages(*sequence_numbers)
# [END cancel_scheduled_messages]
# [START queue_and_send_messages]
with queue_client.get_sender() as sender:
message1 = Message("Hello World!")
message2 = Message("How are you?")
sender.queue_message(message1)
sender.queue_message(message2)
message_status = sender.send_pending_messages()
for status in message_status:
if not status[0]:
print("Message send failed: {}".format(status[1]))
# [END queue_and_send_messages]
# [START queue_and_send_session_messages]
with queue_client.get_sender(session="MySessionID") as sender:
message1 = Message("Hello World!")
message2 = Message("How are you?")
sender.queue_message(message1)
sender.queue_message(message2)
message_status = sender.send_pending_messages()
for status in message_status:
if not status[0]:
print("Message send failed: {}".format(status[1]))
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()
