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()