def __return_sync_nothrow(self, name, pattern, response_info, response,
timeout, transId, pid):
self.__send(term_to_binary((OtpErlangAtom("return_sync"),
name, pattern,
OtpErlangBinary(response_info),
OtpErlangBinary(response), timeout,
OtpErlangBinary(transId), pid)))
def __forward_sync_nothrow(self, name, request_info, request, timeout,
priority, trans_id, pid):
self.__send(
term_to_binary(
(OtpErlangAtom('forward_sync'), name,
OtpErlangBinary(request_info), OtpErlangBinary(request),
timeout, priority, OtpErlangBinary(trans_id), pid)))
def return_sync(self, name, pattern, response_info, response,
timeout, trans_id, pid):
self.__send(term_to_binary((OtpErlangAtom(b'return_sync'),
name, pattern,
OtpErlangBinary(response_info),
OtpErlangBinary(response), timeout,
OtpErlangBinary(trans_id), pid)))
raise return_sync_exception()
def forward_sync(self, name, request_info, request,
timeout, priority, transId, pid):
self.__send(term_to_binary((OtpErlangAtom("forward_sync"), name,
OtpErlangBinary(request_info),
OtpErlangBinary(request),
timeout, priority,
OtpErlangBinary(transId), pid)))
raise return_sync_exception()
def forward_async(self, name, request_info, request,
timeout, priority, trans_id, pid):
self.__send(term_to_binary((OtpErlangAtom(b'forward_async'), name,
OtpErlangBinary(request_info),
OtpErlangBinary(request),
timeout, priority,
OtpErlangBinary(trans_id), pid)))
raise forward_async_exception()
def forward_sync(self, name, request_info, request,
timeout, priority, trans_id, pid):
if self.__request_timeout_adjustment:
if timeout == self.__request_timeout:
elapsed = default_timer() - self.__request_timer
timeout = int(max(0, timeout - elapsed))
self.__send(term_to_binary((OtpErlangAtom('forward_sync'), name,
OtpErlangBinary(request_info),
OtpErlangBinary(request),
timeout, priority,
OtpErlangBinary(trans_id), pid)))
raise forward_sync_exception()
def return_sync(self, name, pattern, response_info, response,
timeout, trans_id, pid):
if self.__request_timeout_adjustment:
if timeout == self.__request_timeout:
elapsed = default_timer() - self.__request_timer
timeout = int(max(0, timeout - elapsed))
self.__send(term_to_binary((OtpErlangAtom('return_sync'),
name, pattern,
OtpErlangBinary(response_info),
OtpErlangBinary(response), timeout,
OtpErlangBinary(trans_id), pid)))
raise return_sync_exception()
def forward_sync(self, name, request_info, request, timeout, priority,
trans_id, pid):
"""
forwards a synchronous service request to a different service name
"""
# pylint: disable=too-many-arguments
self.__send(
term_to_binary(
(OtpErlangAtom(b'forward_sync'), name,
OtpErlangBinary(request_info), OtpErlangBinary(request),
timeout, priority, OtpErlangBinary(trans_id), pid)))
raise ForwardSyncException()
def return_sync(self, name, pattern, response_info, response, timeout,
trans_id, pid):
"""
provides a response to a synchronous service request
"""
# pylint: disable=too-many-arguments
self.__send(
term_to_binary(
(OtpErlangAtom(b'return_sync'), name, pattern,
OtpErlangBinary(response_info), OtpErlangBinary(response),
timeout, OtpErlangBinary(trans_id), pid)))
raise ReturnSyncException()
def send_sync(self, name, request,
timeout=None, request_info=None, priority=None):
if timeout is None:
timeout = self.__timeout_sync
if request_info is None:
request_info = b''
if priority is None:
priority = self.__priority_default
self.__send(term_to_binary((OtpErlangAtom(b'send_sync'), name,
OtpErlangBinary(request_info),
OtpErlangBinary(request),
timeout, priority)))
return self.__poll_request(None, False)
def mcast_async(self, name, request,
timeout=None, request_info=None, priority=None):
if timeout is None:
timeout = self.__timeout_async
if request_info is None:
request_info = ''
if priority is None:
priority = self.__priority_default
self.__send(term_to_binary((OtpErlangAtom("mcast_async"), name,
OtpErlangBinary(request_info),
OtpErlangBinary(request),
timeout, priority)))
return self.poll()
def forward_sync(self, name, request_info, request,
timeout, priority, trans_id, pid):
if self.__request_timeout_adjustment:
if timeout == self.__request_timeout:
elapsed = max(0, int((default_timer() -
self.__request_timer) * 1000.0))
if elapsed > timeout:
timeout = 0
else:
timeout -= elapsed
self.__send(term_to_binary((OtpErlangAtom(b'forward_sync'), name,
OtpErlangBinary(request_info),
OtpErlangBinary(request),
timeout, priority,
OtpErlangBinary(trans_id), pid)))
raise forward_sync_exception()
def recv_async(self, timeout=None, transId=None):
if timeout is None:
timeout = self.__timeout_sync
if transId is None:
transId = chr(0) * 16
self.__send(term_to_binary((OtpErlangAtom("recv_async"), timeout,
OtpErlangBinary(transId))))
return self.poll()
def return_async(self, name, pattern, response_info, response, timeout,
trans_id, pid):
if self.__request_timeout_adjustment:
if timeout == self.__request_timeout:
elapsed = max(0, int(default_timer() - self.__request_timer))
if elapsed > timeout:
response_info = ''
response = ''
timeout = 0
else:
timeout -= elapsed
self.__send(
term_to_binary(
(OtpErlangAtom('return_async'), name, pattern,
OtpErlangBinary(response_info), OtpErlangBinary(response),
timeout, OtpErlangBinary(trans_id), pid)))
raise return_async_exception()
def recv_async(self, timeout=None, trans_id=None, consume=True):
if timeout is None:
timeout = self.__timeout_sync
if trans_id is None:
trans_id = chr(0) * 16
self.__send(term_to_binary((OtpErlangAtom('recv_async'), timeout,
OtpErlangBinary(trans_id), consume)))
return self.__poll_request(False)
def recv_async(self, timeout=None, trans_id=None, consume=True):
"""
blocks to receive an asynchronous service request response
"""
if timeout is None:
timeout = self.__timeout_sync
if trans_id is None:
trans_id = b'\0' * 16
self.__send(
term_to_binary((OtpErlangAtom(b'recv_async'), timeout,
OtpErlangBinary(trans_id), consume)))
return self.__poll_request(None, False)
def send_sync(self,
name,
request,
timeout=None,
request_info=None,
priority=None):
"""
sends a synchronous service request
"""
# pylint: disable=too-many-arguments
if timeout is None:
timeout = self.__timeout_sync
if request_info is None:
request_info = b''
if priority is None:
priority = self.__priority_default
self.__send(
term_to_binary((OtpErlangAtom(b'send_sync'), name,
OtpErlangBinary(request_info),
OtpErlangBinary(request), timeout, priority)))
return self.__poll_request(None, False)
def send_sync(self, name, request, timeout):
self.__s.sendall(
term_to_binary((OtpErlangAtom("send_sync"), name,
OtpErlangBinary(request), timeout)))
return self.poll()
def recv_async(self, timeout, transId):
self.__s.sendall(
term_to_binary((OtpErlangAtom("recv_async"), timeout,
OtpErlangBinary(transId))))
return self.poll()
def return_sync(self, name, response, timeout, transId, pid):
self.__s.sendall(
term_to_binary(
(OtpErlangAtom("return_sync"), name, OtpErlangBinary(response),
timeout, OtpErlangBinary(transId), pid)))
raise _return_sync_exception()
def forward_sync(self, name, request, timeout, transId, pid):
self.__s.sendall(
term_to_binary(
(OtpErlangAtom("forward_sync"), name, OtpErlangBinary(request),
timeout, OtpErlangBinary(transId), pid)))
raise _return_sync_exception()
