def resolve_arg(pyrlangval_tuple):
if isinstance(pyrlangval_tuple, tuple) \
and pyrlangval_tuple[0] == Atom("$pyrlangval"):
return self._retrieve_value(pyrlangval_tuple)
return pyrlangval_tuple
def handle_exit_call(self, msg):
reason = msg[1]
self.exit(reason)
return Atom('ok')
def test_b2t_library_equality_atoms(self):
a = pycodec.term_to_binary(Atom("hello"))
(b, _) = nativecodec.binary_to_term(a, None)
self.assertEqual(Atom("hello"), b)
def _create_atom_atom(name: bytes, encoding: str) -> Atom:
return Atom(name.decode(encoding))
def __etf__(self):
""" This function will fire if no "encode_hook" was passed in
options, and the library doesn't know what to do with this
'CustomClass'
"""
return Atom('custom-member!')
def catch_all_fn(obj):
""" This function will fire if "encode_hook" is passed in encode
options dict.
"""
if isinstance(obj, Class1):
return Atom('custom-hook!')
async def on_passthrough_message(self, control_term, msg_term):
""" On incoming 'p' message with control and data, handle it.
:raises DistributionError: when 'p' message is not a tuple
"""
LOG.info("Dist msg_t=%s; ctrl_t=%s", msg_term, control_term)
if type(control_term) != tuple:
raise DistributionError(
"In a 'p' message control term must be a tuple")
ctrl_msg_type = control_term[0]
n = self.get_node()
if ctrl_msg_type == CONTROL_TERM_REG_SEND:
return await n.send(sender=control_term[1],
receiver=control_term[3],
message=msg_term)
elif ctrl_msg_type == CONTROL_TERM_SEND:
return await n.send(sender=None,
receiver=control_term[2],
message=msg_term)
elif ctrl_msg_type == CONTROL_TERM_LINK:
(_, from_pid, to_pid) = control_term
await n.link(from_pid, to_pid, local_only=True)
elif ctrl_msg_type == CONTROL_TERM_UNLINK:
(_, from_pid, to_pid) = control_term
await n.unlink(from_pid, to_pid, local_only=True)
elif ctrl_msg_type == CONTROL_TERM_MONITOR_P:
(_, sender, target, ref) = control_term
from pyrlang.errors import ProcessNotFoundError
try:
return n.monitor_process(origin_pid=sender,
target=target,
ref=ref)
except ProcessNotFoundError:
pass
elif ctrl_msg_type == CONTROL_TERM_DEMONITOR_P:
(_, sender, target, ref) = control_term
from pyrlang.errors import ProcessNotFoundError
try:
return n.demonitor_process(origin_pid=sender,
target=target,
ref=ref)
except ProcessNotFoundError:
pass
elif ctrl_msg_type in [CONTROL_TERM_EXIT, CONTROL_TERM_EXIT2]:
(_, from_pid, to_pid, reason) = control_term
if to_pid.is_local_to(n):
n.exit_process(from_pid, to_pid, reason)
elif ctrl_msg_type == CONTROL_TERM_MONITOR_P_EXIT:
(_, from_pid, to_pid, ref, reason) = control_term
if to_pid.is_local_to(n):
down_msg = (Atom("DOWN"), ref, Atom("process"), from_pid,
reason)
await n.send(sender=from_pid,
receiver=to_pid,
message=down_msg)
else:
LOG.error("Unhandled 'p' message: %s; %s", control_term, msg_term)
def handle_cast(self, msg):
if type(msg) != tuple or len(msg) != 5 or msg[0] != Atom('cast'):
LOG.error("rex unknown cast msg: %s", msg)
return
act_on_msg(msg)
def __init__(self):
super().__init__()
self.get_node().register_name(self, Atom('rex'))