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'" %
