def send_message_to_queue(queue_name, client_id, kube_add): queue = MessageQueue(queue_name, client_id, kube_add) message = create_queue_message( "someMeta", "some-simple_queue-queue-message".encode('UTF-8')) queue_send_response = queue.send_queue_message(message) print("finished sending to queue answer. message_id: %s, body: %s" % (queue_send_response.message_id, message.body))
def ack_all_messages_in_a_queue(queue_name, client_id, kube_add, max_number_messages, max_timeout): queue = MessageQueue(queue_name, client_id, kube_add, max_number_messages, max_timeout) queue_ack_response = queue.ack_all_queue_messages() print("finished sending message to ack answer: {} ".format( queue_ack_response))
def receive_message_from_queue(queue_name, client_id, kube_add, max_number_messages, max_timeout): queue = MessageQueue(queue_name, client_id, kube_add, max_number_messages, max_timeout) queue_receive_response = queue.receive_queue_messages() print("finished sending message to receive_queue answer: {} ".format( queue_receive_response))
def test_delayed_transaction_message_pass(self): queue_name = "transaction_message_pass" client_id = "transaction_message_pass" kube_add = "localhost:50000" queue = MessageQueue(queue_name, client_id, kube_add) mm = [] queuePolicy = QueueMessagePolicy(DelaySeconds=3) message = create_queue_message("queueName {}".format(0), "first test Ack".encode('UTF-8'), queuePolicy) mm.append(message) queuePolicy2 = QueueMessagePolicy(DelaySeconds=5) message2 = create_queue_message("queueName {}".format(1), "first test Ack".encode('UTF-8'), queuePolicy2) mm.append(message2) queue.send_queue_messages_batch(mm) tr = queue.create_transaction() recm = tr.receive() self.assertEqual( recm.error, "Error 138: no new message in queue, wait time expired") tr.close_stream() time.sleep(0.1) recm = tr.receive(2, 3) self.assertFalse(recm.is_error) tr.close_stream() time.sleep(0.01) recm = tr.receive(2, 5) self.assertFalse(recm.is_error)
def test_modify_after_ack_fail_with_auth(self): client_id = "ack_fail" kube_add = "localhost:50000" queue = MessageQueue("test_modify_after_ack_fail", client_id, kube_add, encryptionHeader=jwt.encode({}, algorithm="HS256", key="some-key")) mm = [] message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) mm.append(message) message2 = create_queue_message("sec test Ack", "hi again".encode('UTF-8')) mm.append(message2) queue.send_queue_messages_batch(mm) tr = queue.create_transaction() recm = tr.receive(5) tr.ack_message(recm.message.Attributes.Sequence) time.sleep(0.1) recMod = tr.extend_visibility(5) self.assertTrue(recMod.is_error)
def test_modify_new_message_pass(self): client_id = "message_pass" kube_add = "localhost:50000" queue = MessageQueue("send_modify_new_message_pass", client_id, kube_add) message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) queue.send_queue_message(message) tr = queue.create_transaction() recm = tr.receive(10) self.assertFalse(recm.is_error) modMsg = create_queue_message("hi there", "well hello".encode('UTF-8')) modMsg.queue = queue.queue_name resMod = tr.modify(modMsg) self.assertFalse(resMod.is_error) tr.close_stream() time.sleep(0.01) recm2 = tr.receive(3, 5) self.assertEqual("well hello", recm2.message.Body.decode("utf-8")) tr.close_stream()
def send_message_to_a_queue_with_delay(queue_name, client_id, kube_add, max_number_messages, max_timeout): queue = MessageQueue(queue_name, client_id, kube_add, max_number_messages, max_timeout) policy = QueueMessagePolicy() policy.DelaySeconds = 5 message = create_queue_message( "someMeta", "some-simple_queue-queue-message".encode('UTF-8'), policy) queue_send_message_to_queue_with_delay_response = queue.send_queue_message( message) print("finished sending message to queue with delay answer: {} ".format( queue_send_message_to_queue_with_delay_response))
def send_batch_message_to_queue(queue_name, client_id, kube_add, max_number_messages, max_timeout): queue = MessageQueue(queue_name, client_id, kube_add, max_number_messages, max_timeout) mm = [] for i in range(2): message = create_queue_message( "queueName {}".format(i), "some-simple_queue-queue-message".encode('UTF-8')) mm.append(message) queue_send_batch_response = queue.send_queue_messages_batch(mm) print("finished sending message to queue with batch answer: {} ".format( queue_send_batch_response))
def test_send_receive_tran_ack_pass(self): client_id = "tran_ack_pass" kube_add = "localhost:50000" queue = MessageQueue("SendReciveTranAck_Pass", client_id, kube_add) message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) queue.send_queue_message(message) tr = queue.create_transaction() recm = tr.receive(5) self.assertFalse( tr.ack_message(recm.message.Attributes.Sequence).is_error)
def send_message_to_a_queue_with_deadletter_queue(queue_name, client_id, kube_add, max_number_messages, max_timeout): queue = MessageQueue(queue_name, client_id, kube_add, max_number_messages, max_timeout) policy = QueueMessagePolicy() policy.MaxReceiveCount = 3 policy.MaxReceiveQueue = "DeadLetterQueue" message = create_queue_message( "someMeta", "some-simple_queue-queue-message".encode('UTF-8'), policy) queue_send_message_to_queue_with_deadletter_response = queue.send_queue_message( message) print( "finished sending message to queue with deadletter answer: {} ".format( queue_send_message_to_queue_with_deadletter_response))
def transactional_queue_reject(queue_name, client_id, kube_add): queue = MessageQueue(queue_name, client_id, kube_add) transaction = queue.create_transaction() res_rec = transaction.receive(10, 10) if res_rec.is_error: raise "Message dequeue error, error: %s" % res_rec.is_error print("Received message id: {}, body: {} tags:{}".format( res_rec.message.MessageID, res_rec.message.Body, res_rec.message.Tags)) res_rej = transaction.rejected_message(res_rec.message.Attributes.Sequence) if res_rej.is_error: raise Exception("Ack message error: %s" % res_rej.error) print("rejected message message of type: %s" % StreamRequestType(res_rej.stream_request_type).name)
def test_send_receive_tran_visability_expired_pass(self): client_id = "expired_pass" kube_add = "localhost:50000" queue = MessageQueue("send_receive_tran_visability_expired_pass", client_id, kube_add) message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) queue.send_queue_message(message) tr = queue.create_transaction() recm = tr.receive() tr.extend_visibility(5) time.sleep(4) ackms = tr.ack_message(recm.message.Attributes.Sequence) self.assertEqual(ackms.is_error, False)
def test_send_receive_tran_visability_expired_fail(self): client_id = "expired_fail" kube_add = "localhost:50000" queue = MessageQueue("send_receive_tran_visability_expired_fail", client_id, kube_add) message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) queue.send_queue_message(message) tr = queue.create_transaction() recm = tr.receive(4) time.sleep(5) ackms = tr.ack_message(recm.message.Attributes.Sequence) self.assertEqual(ackms.error, "Error 129: current visibility timer expired")
def test_delayed_message_pass(self): queue_name = "message_pass" client_id = "message_pass" kube_add = "localhost:50000" queue = MessageQueue(queue_name, client_id, kube_add) mm = [] queuePolicy = QueueMessagePolicy(DelaySeconds=3) message = create_queue_message( "queueName {}".format(0), "some-simple_queue-queue-message".encode('UTF-8'), queuePolicy) mm.append(message) queuePolicy2 = QueueMessagePolicy(DelaySeconds=5) message2 = create_queue_message( "queueName {}".format(1), "some-simple_queue-queue-message".encode('UTF-8'), queuePolicy2) mm.append(message2) queue.send_queue_messages_batch(mm) res = queue.receive_queue_messages() self.assertFalse(res.is_error) self.assertEqual(0, len(res.messages)) time.sleep(3.0) res = queue.receive_queue_messages() self.assertFalse(res.is_error) self.assertEqual(1, len(res.messages)) time.sleep(2.0) res = queue.receive_queue_messages() self.assertFalse(res.is_error) self.assertEqual(1, len(res.messages))
def transactional_queue_resend_to_new_queue(queue_name, client_id, kube_add): queue_rej = MessageQueue(queue_name, client_id, kube_add) message = create_queue_message("resend to new queue {}".format(0), "my resend".encode('UTF-8')) queue_rej.send_queue_message(message) queue = MessageQueue(queue_name, client_id, kube_add) tran = queue.create_transaction() res_rec = tran.receive(5, 10) if res_rec.is_error: raise "Message dequeue error, error: %s" % res_rec.is_error print("Received message id: {}, body: {} tags:{}".format( res_rec.message.MessageID, res_rec.message.Body, res_rec.message.Tags)) print("resend to new queue") res_resend = tran.resend("new-queue") if res_resend.is_error: raise "Message resend error, error: %s" % res_resend.is_error print("Done")
def transactional_queue_resend_modify_message(queue_name, client_id, kube_add): queue_res = MessageQueue(queue_name, client_id, kube_add) message = create_queue_message("resend to new queue {}".format(0), "my resend modify".encode('UTF-8')) queue_res.send_queue_message(message) queue = MessageQueue(queue_name, client_id, kube_add) tran = queue.create_transaction() res_rec = tran.receive(3, 5) if res_rec.is_error: raise "Message dequeue error, error: %s" % res_rec.is_error print("Received message id: {}, body: {} tags:{}".format( res_rec.message.MessageID, res_rec.message.Body, res_rec.message.Tags)) mod_msg = res_rec.message mod_msg.Channel = "receiverB" mod_msg.Metadata = "new Metadata" res_mod = tran.modify(mod_msg) if res_mod.is_error: raise "Message modify error, error: %s" % res_mod.is_error print("Done")
def test_send_receive_tran_ack_fail(self): client_id = "tran_ack_fail" kube_add = "localhost:50000" queue = MessageQueue("SendReciveTranAck_Fail", client_id, kube_add) message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) queue.send_queue_message(message) tr = queue.create_transaction() recm = tr.receive(5) ackms = tr.ack_message(recm.message.Attributes.Sequence) time.sleep(0.1) recm2 = tr.receive(5) self.assertFalse(ackms.is_error) self.assertTrue(recm2.is_error) tr.close_stream()
def test_send_receive_tran_ack_pass_with_auth(self): client_id = "tran_ack_pass" kube_add = "localhost:50000" queue = MessageQueue("SendReceiveTranAck_Pass", client_id, kube_add, encryptionHeader=jwt.encode({}, algorithm="HS256", key="some-key")) message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) queue.send_queue_message(message) tr = queue.create_transaction() recm = tr.receive(5) self.assertFalse( tr.ack_message(recm.message.Attributes.Sequence).is_error)
def test_send_receive_tran_visibility_expired_pass_with_auth(self): client_id = "expired_pass" kube_add = "localhost:50000" queue = MessageQueue("send_receive_tran_visibility_expired_pass", client_id, kube_add, encryptionHeader=jwt.encode({}, algorithm="HS256", key="some-key")) message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) queue.send_queue_message(message) tr = queue.create_transaction() recm = tr.receive() tr.extend_visibility(5) time.sleep(4) ackms = tr.ack_message(recm.message.Attributes.Sequence) self.assertEqual(ackms.is_error, False)
def test_get_message_pass_with_auth(self): client_id = "message_pass" kube_add = "localhost:50000" queue = MessageQueue("Get_Messages{}".format(randomString(10)), client_id, kube_add, encryptionHeader=jwt.encode({}, algorithm="HS256", key="some-key")) mm = [] message = create_queue_message("first test Ack", "hi there".encode('UTF-8')) mm.append(message) message2 = create_queue_message("sec test Ack", "hi again".encode('UTF-8')) mm.append(message2) queue.send_queue_messages_batch(mm) tr = queue.create_transaction() recm = tr.receive(3) self.assertFalse(recm.error) self.assertFalse( tr.ack_message(recm.message.Attributes.Sequence).is_error) self.assertEqual(1, len(queue.peek_queue_message().messages)) self.assertFalse(tr.receive().is_error) tr.close_stream()
def transactional_queue_extand_visibility(queue_name, client_id, kube_add): queue_rej = MessageQueue("reject_test", client_id, kube_add) message = create_queue_message("queueName {}".format(0), "my reject".encode('UTF-8')) queue_rej.send_queue_message(message) queue = MessageQueue("reject_test", client_id, kube_add) tran = queue.create_transaction() res_rec = tran.receive(5, 10) if res_rec.is_error: raise "Message dequeue error, error: %s" % res_rec.is_error print("Received message id: {}, body: {} tags: {}".format( res_rec.message.MessageID, res_rec.message.Body, res_rec.message.Tags)) print("work for 1 second") time.sleep(1) print("Need more time to process, extend visibility for more 3 seconds") res_ext = tran.extend_visibility(3) if res_ext.is_error: raise Exception("Ack message error: %s" % res_ext.error) print("Approved. work for 2.5 seconds") time.sleep(2.5) print("Work done... ack the message") res_ack = tran.ack_message(res_rec.message.Attributes.Sequence) if res_ack.is_error: raise Exception("Ack message error: %s" % res_ack.error) print("ack done")
try: subscriber_a = Subscriber("localhost:50000") subscribe_request_a = create_subscribe_request( SubscribeType.Events, 'python-sdk-cookbook-events-multicast-mix-client-receiver', EventsStoreType.Undefined, 0, 'e1') subscriber_a.subscribe_to_events(subscribe_request_a, handle_incoming_events_receiver, handle_incoming_error, cancel_token) except Exception as err: print('error, error:%s' % (err)) queue = MessageQueue("q1;events:e1", "python-sdk-cookbook-events-multicast-mix-client", "localhost:50000") message = create_queue_message( "some-metadata", "some-simple-event-multicast-mix-message-1".encode('UTF-8')) try: sent = queue.send_queue_message(message) if sent.error: print('message enqueue error, error:' + sent.error) else: print('Send to Queue at: %d' % (sent.sent_at)) except Exception as err: print('message enqueue error, error:%s' % (err)) queue_a = MessageQueue(
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. from kubemq.queue.message_queue import MessageQueue from kubemq.queue.message import Message if __name__ == "__main__": queue = MessageQueue("hello-world-queue", "test-queue-client-id2", "localhost:50000") message = Message() message.metadata = 'metadata' message.body = "some-simple_queue-queue-message".encode('UTF-8') message.attributes = None try: sent = queue.send_queue_message(message) if sent.error: print('message enqueue error, error:' + sent.error) else: print('message sent at: %d' % ( sent.sent_at )) except Exception as err: print('message enqueue error, error:%s' % ( err
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import jwt from kubemq.queue.message_queue import MessageQueue from kubemq.queue.message import Message if __name__ == "__main__": queue = MessageQueue("hello-world-queue", "test-queue-client-id2", "localhost:50000", encryptionHeader=jwt.encode({}, algorithm="HS256", key="some-key")) message = Message() message.metadata = 'metadata' message.body = "some-simple_queue-queue-message".encode('UTF-8') message.attributes = None try: sent = queue.send_queue_message(message) if sent.error: print('message enqueue error, error:' + sent.error) else: print('message sent at: %d' % (sent.sent_at)) except Exception as err: print('message error, error:%s' % (err))
message = Message() message.metadata = meta_data message.body = body message.tags = [ ('key', 'value'), ('key2', 'value2'), ] message.attributes = None message.policy = policy return message if __name__ == "__main__": client_id = "python-sdk-cookbook-queues-resend-sender" kube_add = "localhost:50000" queue = MessageQueue("Get_Messages{}".format(random_string(10)), client_id, kube_add) mm = [] message = create_queue_message("some-metadata", "hi there".encode('UTF-8')) mm.append(message) message2 = create_queue_message("some-metadata", "hi again".encode('UTF-8')) mm.append(message2) queue.send_queue_messages_batch(mm) tr = queue.create_transaction() for seq in range(3): stream = tr.receive(1, 5) print(stream.message) if seq == 0:
from kubemq.grpc import QueueMessagePolicy from kubemq.queue.message_queue import MessageQueue from kubemq.queue.message import Message def create_queue_message(meta_data, body, policy=None): message = Message() message.metadata = meta_data message.body = body message.tags = [ ('key', 'value'), ('key2', 'value2'), ] message.attributes = None message.policy = policy return message if __name__ == "__main__": channel = "queues.dead-letter" queue = MessageQueue(channel, "python-sdk-cookbook-queues-dead-letter-client", "localhost:50000") policy = QueueMessagePolicy() policy.MaxReceiveCount = 3 policy.MaxReceiveQueue = "DeadLetterQueue" message = create_queue_message("some-metadata", "some-simple-queue-dead-letter-message".encode('UTF-8'), policy) queue_send_message_to_queue_with_deadletter_response = queue.send_queue_message(message) print("finished sending message to queue with dead-letter answer: {} ".format( queue_send_message_to_queue_with_deadletter_response))
# copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. from kubemq.queue.message_queue import MessageQueue if __name__ == "__main__": queue = MessageQueue("hello-world-queue", "test-queue-client-id2", "localhost:50000", 2, 1) try: res = queue.receive_queue_messages() if res.error: print( "'Received:'%s'" % ( res.error ) ) else: for message in res.messages: print( "'MessageID :%s ,Body: sending:'%s'" % ( message.MessageID, message.Body )
def create_queue_message(meta_data, body, policy=None): message = Message() message.metadata = meta_data message.body = body message.tags = [ ('key', 'value'), ('key2', 'value2'), ] message.attributes = None message.policy = policy return message if __name__ == "__main__": channel = "queues.ack" queue = MessageQueue(channel, "python-sdk-cookbook-queues-ack-client", "localhost:50000") mm = [] message = create_queue_message( "queueName {}".format(channel), "some-simple-queue-ack-message-1".encode('UTF-8')) mm.append(message) message2 = create_queue_message( "queueName {}".format(channel), "some-simple-queue-ack-message-2".encode('UTF-8')) mm.append(message2) try: sent = queue.send_queue_messages_batch(mm) if sent.have_errors: print('message enqueue error, error:' + sent.have_errors)
message = Message() message.metadata = meta_data message.body = body message.tags = [ ('key', 'value'), ('key2', 'value2'), ] message.attributes = None message.policy = policy return message if __name__ == "__main__": channel = "queue.a;queue.b;queue.c" queue = MessageQueue(channel, "python-sdk-cookbook-queues-multicast-client", "localhost:50000") message = create_queue_message( "queueName {}".format(channel), "some-simple-queue-multicast-message-1".encode('UTF-8')) try: sent = queue.send_queue_message(message) if sent.error: print('message enqueue error, error:' + sent.error) else: print('Send to Queue at: %d' % (sent.sent_at)) except Exception as err: print('message enqueue error, error:%s' % (err)) queue_a = MessageQueue( 'queue.a', "python-sdk-cookbook-queues-multicast-client-receiver-A",
from kubemq.queue.message_queue import MessageQueue from kubemq.queue.message import Message if __name__ == "__main__": channel = "queues.single" queue = MessageQueue(channel, "python-sdk-cookbook-queues-single-client", "localhost:50000") message = Message() message.metadata = 'metadata' message.body = "some-simple-queue-message".encode('UTF-8') message.attributes = None try: sent = queue.send_queue_message(message) if sent.error: print('message enqueue error, error:' + sent.error) else: print('Send to Queue at: %d' % (sent.sent_at)) except Exception as err: print('message enqueue error, error:%s' % (err)) queue = MessageQueue(channel, "python-sdk-cookbook-queues-single-client-receiver", "localhost:50000", 2, 1) try: res = queue.receive_queue_messages() if res.error: print("'Received:'%s'" % (res.error)) else: for message in res.messages: print("'Received :%s ,Body: sending:'%s'" %