def __init__(self,
inner_request=None,
request_id=None,
request_type=None,
client_id=None,
channel=None,
reply_channel=None,
metadata=None,
body=None,
timeout=None,
cache_key=None,
cache_ttl=None,
tags=None):
"""Initializes a new instance of the Request with a set of parameters."""
if inner_request:
self.request_id = inner_request.RequestID or get_next_id()
"""Represents a Request identifier."""
self.request_type = inner_request.RequestTypeData
"""Represents the type of the request operation."""
self.client_id = inner_request.ClientID
"""Represents the sender ID that the Request will be send under."""
self.channel = inner_request.Channel
"""Represents The channel name to send to using the KubeMQ."""
self.reply_channel = inner_request.ReplyChannel
"""Represents The channel name to return response to."""
self.metadata = inner_request.Metadata
"""Represents metadata text attached to the request."""
self.body = inner_request.Body
"""Represents The content of the request."""
self.timeout = inner_request.Timeout
"""Represents the limit for waiting for response (Milliseconds)."""
self.cache_key = inner_request.CacheKey
"""Represents if the request should be saved from Cache and under what "Key"(Str) to save it."""
self.cache_ttl = inner_request.CacheTTL
"""Cache time to live : for how long does the request should be saved in Cache."""
self.tags = inner_request.Tags
"""Represents key value pairs that help distinguish the message"""
else:
self.request_id = request_id
self.request_type = request_type
self.client_id = client_id
self.channel = channel
self.reply_channel = reply_channel
self.metadata = metadata
self.body = body
self.timeout = timeout
self.cache_key = cache_key
self.cache_ttl = cache_ttl
self.tags = tags
def convert_to_ack_all_queue_message_request(self):
"""create AckAllQueueMessagesRequest from MessageQueue"""
return AckAllQueueMessagesRequest(
RequestID=get_next_id(),
ClientID=self.client_id,
Channel=self.queue_name,
WaitTimeSeconds=self.wait_time_seconds_queue_messages,
)
def convert_to_send_queue_message_result(self):
"""Convert a SendMessageResult to an SendQueueMessageResult"""
return SendQueueMessageResult(MessageID=self.message_id
or get_next_id(),
ExpirationAt=self.expiration_at.value
or "",
IsError=self.is_error or "",
SentAt=self.sent_at,
DelayedTo=self.delayed_to,
Error=self.error)
def receive_queue_messages(self, number_of_messages=None):
"""Receive messages from queue"""
try:
id = get_next_id()
inner_response = self.get_kubemq_client().ReceiveQueueMessages(
self.convert_to_receive_queue_messages_request(id, False, number_of_messages), metadata=self._metadata)
return ReceiveMessagesResponse(inner_response)
except Exception as e:
logging.exception("Grpc Exception in send_queue_messages:'%s'" % (e))
raise
def send_queue_messages_batch(self, messages):
""""Publish a group of messages to a queue"""
try:
id = get_next_id()
inner_response = self.get_kubemq_client().SendQueueMessagesBatch(
convert_queue_message_batch_request(id, to_queue_messages(messages, self)), metadata=self._metadata)
return convert_from_queue_messages_batch_response(inner_response)
except Exception as e:
logging.exception("Grpc Exception in send_queue_messages_batch:'%s'" % (e))
raise
def peek_queue_message(self, number_of_messages=None):
"""peek queue messages from queue"""
try:
id = get_next_id()
inner_response = self.get_kubemq_client().ReceiveQueueMessages(
self.convert_to_receive_queue_messages_request(id, True, number_of_messages))
return ReceiveMessagesResponse(inner_response)
except Exception as e:
logging.exception("Grpc Exception in send_queue_messages_batch:'%s'" % (e))
raise
def convert_to_queue_message(self, queue=None):
"""Convert a Message to an QueueMessage"""
return QueueMessage(MessageID=self.message_id or get_next_id(),
ClientID=self.client_id or queue.client_id,
Channel=self.queue or queue.queue_name,
Metadata=self.metadata,
Body=self.body,
Tags=self.tags or "",
Attributes=self.attributes,
Policy=self.policy)
def convert(self):
"""Convert a Request to an InnerRequest"""
return InnerRequest(RequestID=self.request_id or get_next_id(),
RequestTypeData=self.request_type.value,
ClientID=self.client_id or "",
Channel=self.channel,
Metadata=self.metadata or "",
Body=self.body,
Timeout=self.timeout,
CacheKey=self.cache_key,
CacheTTL=self.cache_ttl,
Tags=self.tags)
def create_stream_queue_message_ack_request(_queue, msg_sequence):
"""Create StreamQueueMessageRequest for ack"""
return StreamQueueMessagesRequest(
ClientID=_queue.client_id,
Channel=_queue.queue_name,
RequestID=get_next_id(),
StreamRequestTypeData=AckMessage,
VisibilitySeconds=0,
WaitTimeSeconds=0,
ModifiedMessage=None,
RefSequence=msg_sequence
)
def create_stream_queue_message_check_call_is_in_transaction_request(_queue):
"""Create empty for checking check_call_is_in_transaction"""
return StreamQueueMessagesRequest(
ClientID=_queue.client_id,
Channel=_queue.queue_name,
RequestID=get_next_id(),
StreamRequestTypeData=StreamRequestTypeUnknown,
VisibilitySeconds=20,
WaitTimeSeconds=8,
ModifiedMessage=QueueMessage(),
RefSequence=0
)
def create_stream_queue_message_receive_request(queue, visibility_seconds, wait_time_seconds=None):
"""Create StreamQueueMessageRequest for receive"""
return StreamQueueMessagesRequest(
ClientID=queue.client_id,
Channel=queue.queue_name,
RequestID=get_next_id(),
StreamRequestTypeData=ReceiveMessage,
VisibilitySeconds=visibility_seconds,
WaitTimeSeconds=wait_time_seconds or queue.WaitTimeSecondsQueueMessages,
ModifiedMessage=QueueMessage(),
RefSequence=0
)
def create_stream_queue_message_modify_request(_queue, message):
"""Create StreamQueueMessageRequest for modify"""
return StreamQueueMessagesRequest(
ClientID=_queue.client_id,
Channel="",
RequestID=get_next_id(),
StreamRequestTypeData=SendModifiedMessage,
VisibilitySeconds=0,
WaitTimeSeconds=0,
ModifiedMessage=message,
RefSequence=0
)
def create_stream_queue_message_resend_request(_queue, queue_name):
"""Create StreamQueueMessageRequest for resend"""
return StreamQueueMessagesRequest(
ClientID=_queue.client_id,
Channel=queue_name,
RequestID=get_next_id(),
StreamRequestTypeData=ResendMessage,
VisibilitySeconds=0,
WaitTimeSeconds=0,
ModifiedMessage=None,
RefSequence=0
)
def create_stream_queue_message_extend_visibility_request(_queue, visibility):
"""Create StreamQueueMessageRequest for extend_visibility"""
return StreamQueueMessagesRequest(
ClientID=_queue.client_id,
Channel=_queue.queue_name,
RequestID=get_next_id(),
StreamRequestTypeData=ModifyVisibility,
VisibilitySeconds=visibility,
WaitTimeSeconds=0,
ModifiedMessage=None,
RefSequence=0
)
def modify(self, msg):
"""Resend the new message to a new channel."""
if not self.check_call_is_in_transaction():
return TransactionMessagesResponse(
None, None, True,
"no active message to modify, call Receive first")
else:
try:
if isinstance(msg, Message):
msg.client_id = msg.client_id or self.queue.client_id
msg = msg.convert_to_queue_message()
msg.ClientID = msg.ClientID
msg.MessageID = get_next_id()
msg = create_stream_queue_message_modify_request(
self.queue, msg)
self.stream_observer.put(msg)
return TransactionMessagesResponse(next(self.inner_stream))
except Exception as e:
logging.exception("Exception in resend:'%s'" % e)
raise