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